Line data    Source code

       1              : use crate::config::SslMode;
       2              : use crate::tls::TlsConnect;
       3              : 
       4              : use crate::{cancel_query, client::SocketConfig, tls::MakeTlsConnect};
       5              : use crate::{cancel_query_raw, Error};
       6              : use tokio::io::{AsyncRead, AsyncWrite};
       7              : use tokio::net::TcpStream;
       8              : 
       9              : /// The capability to request cancellation of in-progress queries on a
      10              : /// connection.
      11              : #[derive(Clone)]
      12              : pub struct CancelToken {
      13              :     pub socket_config: Option<SocketConfig>,
      14              :     pub ssl_mode: SslMode,
      15              :     pub process_id: i32,
      16              :     pub secret_key: i32,
      17              : }
      18              : 
      19              : impl CancelToken {
      20              :     /// Attempts to cancel the in-progress query on the connection associated
      21              :     /// with this `CancelToken`.
      22              :     ///
      23              :     /// The server provides no information about whether a cancellation attempt was successful or not. An error will
      24              :     /// only be returned if the client was unable to connect to the database.
      25              :     ///
      26              :     /// Cancellation is inherently racy. There is no guarantee that the
      27              :     /// cancellation request will reach the server before the query terminates
      28              :     /// normally, or that the connection associated with this token is still
      29              :     /// active.
      30              :     ///
      31              :     /// Requires the `runtime` Cargo feature (enabled by default).
      32            0 :     pub async fn cancel_query<T>(&self, tls: T) -> Result<(), Error>
      33            0 :     where
      34            0 :         T: MakeTlsConnect<TcpStream>,
      35            0 :     {
      36            0 :         cancel_query::cancel_query(
      37            0 :             self.socket_config.clone(),
      38            0 :             self.ssl_mode,
      39            0 :             tls,
      40            0 :             self.process_id,
      41            0 :             self.secret_key,
      42            0 :         )
      43            0 :         .await
      44            0 :     }
      45              : 
      46              :     /// Like `cancel_query`, but uses a stream which is already connected to the server rather than opening a new
      47              :     /// connection itself.
      48            0 :     pub async fn cancel_query_raw<S, T>(&self, stream: S, tls: T) -> Result<(), Error>
      49            0 :     where
      50            0 :         S: AsyncRead + AsyncWrite + Unpin,
      51            0 :         T: TlsConnect<S>,
      52            0 :     {
      53            0 :         cancel_query_raw::cancel_query_raw(
      54            0 :             stream,
      55            0 :             self.ssl_mode,
      56            0 :             tls,
      57            0 :             self.process_id,
      58            0 :             self.secret_key,
      59            0 :         )
      60            0 :         .await
      61            0 :     }
      62              : }