Struct mz_pgwire::codec::FramedConn

pub struct FramedConn<A> {
    conn_id: ConnectionId,
    peer_addr: Option<IpAddr>,
    inner: Buffer<Framed<Conn<A>, Codec>, BackendMessage>,
}

A connection that manages the encoding and decoding of pgwire frames.

Fields

conn_id: ConnectionId

peer_addr: Option<IpAddr>

inner: Buffer<Framed<Conn<A>, Codec>, BackendMessage>

Implementations

impl<A> FramedConn<A>

where A: AsyncRead + AsyncWrite + Unpin,

pub fn new( conn_id: ConnectionId, peer_addr: Option<IpAddr>, inner: Conn<A>, ) -> FramedConn<A>

Constructs a new framed connection.

The underlying connection, inner, is expected to be something like a TCP stream. Anything that implements AsyncRead and AsyncWrite will do.

The supplied conn_id is used to identify the connection in logging messages.

pub async fn recv(&mut self) -> Result<Option<FrontendMessage>, Error>

Reads and decodes one frontend message from the client.

Blocks until the client sends a complete message. If the client terminates the stream, returns None. Returns an error if the client sends a malformed message or if the connection underlying is broken.

Cancel safety

This method is cancel safe. The returned future only holds onto a reference to thea underlying stream, so dropping it will never lose a value.

https://docs.rs/tokio-stream/latest/tokio_stream/trait.StreamExt.html#cancel-safety-1

pub async fn send<M>(&mut self, message: M) -> Result<(), Error>

where M: Into<BackendMessage>,

Encodes and sends one backend message to the client.

Note that the connection is not flushed after calling this method. You must call FramedConn::flush explicitly. Returns an error if the underlying connection is broken.

Please use StateMachine::send instead if calling from StateMachine, as it applies session-based filters before calling this method.

pub async fn send_all( &mut self, messages: impl IntoIterator<Item = BackendMessage>, ) -> Result<(), Error>

Encodes and sends the backend messages in the messages iterator to the client.

As with FramedConn::send, the connection is not flushed after calling this method. You must call FramedConn::flush explicitly. Returns an error if the underlying connection is broken.

pub async fn flush(&mut self) -> Result<(), Error>

Flushes all outstanding messages.

pub fn set_encode_state(&mut self, encode_state: Vec<(Type, Format)>)

Injects state that affects how certain backend messages are encoded.

Specifically, the encoding of BackendMessage::DataRow depends upon the types of the datums in the row. To avoid including the same type information in each message, we use this side channel to install the type information in the codec before sending any data row messages. This violates the abstraction boundary a bit but results in much better performance.

pub async fn wait_closed(&self) -> Error

where A: AsyncReady + Send + Sync,

Waits for the connection to be closed.

Returns a “connection closed” error when the connection is closed. If another error occurs before the connection is closed, that error is returned instead.

Use this method when you have an unbounded stream of data to forward to the connection and the protocol does not require the client to periodically acknowledge receipt. If you don’t call this method to periodically check if the connection has closed, you may not notice that the client has gone away for an unboundedly long amount of time; usually not until the stream of data produces its next message and you attempt to write the data to the connection.

pub fn conn_id(&self) -> &ConnectionId

Returns the ID associated with this connection.

pub fn peer_addr(&self) -> &Option<IpAddr>

Returns the peer address of the connection.

impl<A> FramedConn<A>

where A: AsyncRead + AsyncWrite + Unpin,

pub fn inner(&self) -> &Conn<A>

Trait Implementations

impl<A> AsyncReady for FramedConn<A>

where A: AsyncRead + AsyncWrite + AsyncReady + Send + Sync + Unpin,

fn ready<'life0, 'async_trait>( &'life0 self, interest: Interest, ) -> Pin<Box<dyn Future<Output = Result<Ready>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Checks for IO readiness.