Struct wamp_async::Client

pub struct Client { /* fields omitted */ }

Allows interaction as a client with a WAMP server

Methods

impl Client

pub async fn connect<T: AsRef<str>>(
    uri: T,
    cfg: Option<ClientConfig>
) -> Result<Self, WampError>

Connects to a WAMP server using the specified protocol

Currently supported protocols are :

• WebSocket : ws://some.site.com/wamp | (Secure) wss://localhost:8080
• RawSocket : tcp://some.site.com:80 | (Secure) tcps://localhost:443

Extra customization can be specified through the ClientConfig struct

pub fn event_loop(
    &mut self
) -> Result<(Pin<Box<dyn Future<Output = ()> + Send>>, Option<UnboundedReceiver<GenericFuture>>), WampError>

This function must be called by the client after a succesful connection. It returns a future for the event loop which MUST be executed by the caller. It also returns the receiving end of a channel (if the client has the 'callee' role) which is reponsible for receiving RPC call futures. The caller is also responsible for executing the RPC call futures in whatever way they wish.async_trait

This allows the caller to use whatever runtime & task execution method they wish

pub async fn join_realm<'_, T: AsRef<str>>(
    &'_ mut self,
    realm: T
) -> Result<(), WampError>

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

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, WampArgs, 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: WampArgs,
    arguments_kw: WampKwArgs,
    acknowledge: bool
) -> Result<WampId, WampError>

Publishes an event on a specifiec 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(WampArgs, WampKwArgs) -> Fut + Send + Sync + 'static,
    Fut: Future<Output = Result<(WampArgs, WampKwArgs), WampError>> + Send + 'static, 

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: WampArgs,
    arguments_kw: WampKwArgs
) -> Result<(WampArgs, WampKwArgs), WampError>

Calls a registered RPC endpoint on the server

pub fn get_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(__arg0: Self)

Cleanly closes a connection with the server