chorus 0.20.0

A library for interacting with multiple Spacebar-compatible Instances at once.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

// This example showcase how to properly use gateway observers.
// (This assumes you have a manually created gateway, if you created
// a ChorusUser by e.g. logging in, you can access the gateway with user.gateway)
//
// To properly run it, you will need to change the token below.

const TOKEN: &str = "";

/// Find the gateway websocket url of the server we want to connect to
const GATEWAY_URL: &str = "wss://gateway.old.server.spacebar.chat/";

use async_trait::async_trait;
use chorus::gateway::{Gateway, GatewayOptions};
use chorus::{
    self,
    types::{GatewayIdentifyPayload, GatewayReady},
};
use pubserve::Subscriber;
use std::{sync::Arc, time::Duration};
use tokio::{self};

#[cfg(not(target_arch = "wasm32"))]
use tokio::time::sleep;
#[cfg(target_arch = "wasm32")]
use wasmtimer::tokio::sleep;

// This example creates a simple gateway connection and a basic observer struct

// Due to certain limitations all observers must impl debug
#[derive(Debug)]
pub struct ExampleObserver {}

// This struct can observe GatewayReady events when subscribed, because it implements the trait Subscriber<GatewayReady>.
// The Subscriber trait can be implemented for a struct for a given websocketevent to handle observing it
//
// Note that this trait is quite generic and can be use to observe any type.
//
// It is just used for WebSocketEvents in chorus.
//
// One struct can be an observer of multiple websocketevents, if needed
#[async_trait]
impl Subscriber<GatewayReady> for ExampleObserver {
    // After we subscribe to an event this function is called every time we receive it
    async fn update(&self, _data: &GatewayReady) {
        println!("Observed Ready!");
    }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let gateway_websocket_url = GATEWAY_URL;

    // These options specify the encoding format, compression, etc
    //
    // For most cases the defaults should work, though some implementations
    // might only support some formats or not support compression
    let options = GatewayOptions::default();

    // Initiate the gateway connection
    let gateway = Gateway::spawn(gateway_websocket_url, options)
        .await
        .unwrap();

    // Create an instance of our observer
    let observer = ExampleObserver {};

    // Share ownership of the observer with the gateway
    let shared_observer = Arc::new(observer);

    // Subscribe our observer to the Ready event on this gateway
    // From now on observer.update(data) will be called every time we receive the Ready event
    gateway
        .events
        .lock()
        .await
        .session
        .ready
        .subscribe(shared_observer);

    // Authenticate so we will receive any events
    let token = TOKEN.to_string();
    let mut identify = GatewayIdentifyPayload::common();
    identify.token = token;
    gateway.send_identify(identify).await;

    // Do something on the main thread so we don't quit
    loop {
        sleep(Duration::from_secs(3600)).await;
    }
}