Struct Client 

pub struct Client<'a> { /* private fields */ }

Allows interaction as a client with a WAMP server

Implementations

impl<'a> Client<'a>

pub async fn connect<T: AsRef<str>>( uri: T, cfg: Option<ClientConfig>, ) -> Result<(Client<'a>, (GenericFuture<'a>, Option<UnboundedReceiver<GenericFuture<'a>>>)), WampError>

Connects to a WAMP server using the specified protocol

Note

On success, this function returns :

• Client : Used to interact with the server
• Main event loop Future : This MUST be spawned by the caller (e.g using tokio::spawn())
• RPC event queue : If you register RPC endpoints, you MUST spawn a seperate task to also handle these events

To customize parmeters used for the connection, see the ClientConfig struct

pub async fn join_realm<T: Into<String>>( &mut self, realm: T, ) -> Result<(), WampError>

Attempts to join a realm and start a session with the server.

• realm - A name of the WAMP realm

pub async fn join_realm_with_authentication<Realm, AuthenticationId, AuthenticationChallengeHandler, AuthenticationChallengeHandlerResponse>( &mut self, realm: Realm, authentication_methods: Vec<AuthenticationMethod>, authentication_id: AuthenticationId, on_challenge_handler: AuthenticationChallengeHandler, ) -> Result<(), WampError>

where Realm: Into<String>, AuthenticationId: Into<String>, AuthenticationChallengeHandler: Fn(AuthenticationMethod, WampDict) -> AuthenticationChallengeHandlerResponse + Send + Sync + 'a, AuthenticationChallengeHandlerResponse: Future<Output = Result<AuthenticationChallengeResponse, WampError>> + Send + 'a,

Attempts to join a realm and start a session with the server.

• realm - A name of the WAMP realm
• authentication_methods - A set of all the authentication methods the client will support
• authentication_id - An authentication ID (e.g. username) the client wishes to authenticate as. It is required for non-anynomous authentication methods.
• on_challenge_handler - An authentication handler function

client
    .join_realm_with_authentication(
        "realm1",
        vec![wamp_async::AuthenticationMethod::Ticket],
        "username",
        |_authentication_method, _extra| async {
            Ok(wamp_async::AuthenticationChallengeResponse::with_signature(
                "password".into(),
            ))
        },
    )
    .await?;

pub async fn leave_realm(&mut self) -> Result<(), WampError>

Leaves the current realm and terminates the session with the server

pub async fn subscribe<T: AsRef<str>>( &self, topic: T, ) -> Result<(WampId, UnboundedReceiver<(WampId, Option<WampArgs>, Option<WampKwArgs>)>), WampError>

Subscribes to events for the specifiec topic

This function returns a subscription ID (required to unsubscribe) and the receive end of a channel for events published on the topic.

pub async fn unsubscribe(&self, sub_id: WampId) -> Result<(), WampError>

Unsubscribes to a previously subscribed topic

pub async fn publish<T: AsRef<str>>( &self, topic: T, arguments: Option<WampArgs>, arguments_kw: Option<WampKwArgs>, acknowledge: bool, ) -> Result<Option<WampId>, WampError>

Publishes an event on a specific topic

The caller can set acknowledge to true to receive unique IDs from the server for each published event.

pub async fn register<T, F, Fut>( &self, uri: T, func_ptr: F, ) -> Result<WampId, WampError>

where T: AsRef<str>, F: Fn(Option<WampArgs>, Option<WampKwArgs>) -> Fut + Send + Sync + 'a, Fut: Future<Output = Result<(Option<WampArgs>, Option<WampKwArgs>), WampError>> + Send + 'a,

Register an RPC endpoint. Upon succesful registration, a registration ID is returned (used to unregister) and calls received from the server will generate a future which will be sent on the rpc event channel returned by the call to event_loop()

pub async fn unregister(&self, rpc_id: WampId) -> Result<(), WampError>

Unregisters an RPC endpoint

pub async fn call<T: AsRef<str>>( &self, uri: T, arguments: Option<WampArgs>, arguments_kw: Option<WampKwArgs>, ) -> Result<(Option<WampArgs>, Option<WampKwArgs>), WampError>

Calls a registered RPC endpoint on the server

pub fn get_cur_status(&mut self) -> &ClientState

Returns the current client status

pub fn is_connected(&mut self) -> bool

Returns whether we are connected to the server or not

pub async fn block_until_disconnect(&mut self) -> &ClientState

Blocks the caller until the connection with the server is terminated

pub async fn disconnect(self)

Cleanly closes a connection with the server