Struct ClientConnection 

#[non_exhaustive]
pub struct ClientConnection {
    pub replica_id: u64,
    pub module: ModuleHost,
    /* private fields */
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

replica_id: u64

module: ModuleHost

Implementations

impl ClientConnection

pub async fn call_client_connected_maybe_reject( module_rx: &mut Receiver<ModuleHost>, id: ClientActorId, ) -> Result<Connected, ClientConnectedError>

Call the database at module_rx’s client_connection reducer, if any, and return Err if it signals rejecting this client’s connection.

Call this method before Self::spawn and pass the returned [Connected] to Self::spawn as proof that the client is authorized.

pub async fn spawn<Fut>( id: ClientActorId, config: ClientConfig, replica_id: u64, module_rx: Receiver<ModuleHost>, actor: impl FnOnce(ClientConnection, MeteredReceiver<SerializableMessage>) -> Fut, _proof_of_client_connected_call: Connected, ) -> ClientConnection

where Fut: Future<Output = ()> + Send + 'static,

Spawn a new ClientConnection for a WebSocket subscriber.

Callers should first call Self::call_client_connected_maybe_reject to verify that the database at module_rx approves of this connection, and should not invoke this method if that call returns an error, and pass the returned [Connected] as _proof_of_client_connected_call.

pub fn dummy( id: ClientActorId, config: ClientConfig, replica_id: u64, module_rx: Receiver<ModuleHost>, ) -> Self

pub fn sender(&self) -> Arc<ClientConnectionSender>

pub fn handle_message( &self, message: impl Into<DataMessage>, timer: Instant, ) -> impl Future<Output = Result<(), MessageHandleError>> + '_

pub async fn watch_module_host(&mut self) -> Result<(), NoSuchModule>

pub async fn call_reducer( &self, reducer: &str, args: ReducerArgs, request_id: RequestId, timer: Instant, flags: CallReducerFlags, ) -> Result<ReducerCallResult, ReducerCallError>

pub async fn subscribe_single( &self, subscription: SubscribeSingle, timer: Instant, ) -> Result<Option<ExecutionMetrics>, DBError>

pub async fn unsubscribe( &self, request: Unsubscribe, timer: Instant, ) -> Result<Option<ExecutionMetrics>, DBError>

pub async fn subscribe_multi( &self, request: SubscribeMulti, timer: Instant, ) -> Result<Option<ExecutionMetrics>, DBError>

pub async fn unsubscribe_multi( &self, request: UnsubscribeMulti, timer: Instant, ) -> Result<Option<ExecutionMetrics>, DBError>

pub async fn subscribe( &self, subscription: Subscribe, timer: Instant, ) -> Result<ExecutionMetrics, DBError>

pub async fn one_off_query_json( &self, query: &str, message_id: &[u8], timer: Instant, ) -> Result<(), Error>

pub async fn one_off_query_bsatn( &self, query: &str, message_id: &[u8], timer: Instant, ) -> Result<(), Error>

pub async fn disconnect(self)

Methods from Deref<Target = ClientConnectionSender>

pub fn is_cancelled(&self) -> bool

pub fn send_message( &self, message: impl Into<SerializableMessage>, ) -> Result<(), ClientSendError>

Send a message to the client. For data-related messages, you should probably use BroadcastQueue::send to ensure that the client sees data messages in a consistent order.

Trait Implementations

impl Clone for ClientConnection

fn clone(&self) -> ClientConnection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for ClientConnection

type Target = ClientConnectionSender

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.