simple-pub-sub 0.1.4

simple message broker
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

# Simple-pub-sub

A simple message broker implemented in rust.

The message frame looks like

|header|version|pkt type|topic length|message length|padding|topic|message|
|------|-------|--------|------------|--------------|-------|-----|-------|
|1 byte|2 bytes|1 byte|1 byte|2 bytes|1 byte|.....|.....|

So it's a 8 byte header followed by the topic and message.

## Cli Usage

- Server:

  - Using Tcp socket:

    ```bash
    simple-pub-sub server tcp 0.0.0.0 6480 --log-level trace
    ```

    To use TLS:

    ```bash
    # Generate the server key and certificate
    openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes -subj "/CN=localhost"
    # generate the identity file.
    openssl pkcs12 -export -out identity.pfx -inkey key.pem -in cert.pem -passout pass:password
    ```

    Start the server using these keys:

    ```bash
    simple-pub-sub server tcp -c identity.pfx -p password 0.0.0.0 6480  --log-level trace
    ```

  - Using Unix socket:

    ```bash
    simple-pub-sub server unix /tmp/pubsub.sock --log-level trace
    ```

- Client:
  - Using Tcp socket:
    - subscribe:

        ```bash
        simple-pub-sub client subscribe the_topic tcp 0.0.0.0 6480 --log-level trace
        ```

        Using TLS:

        ```bash
        simple-pub-sub client subscribe the_topic tcp -c certs/cert.pem 0.0.0.0 6480 --log-level trace
        ```

    - publish:

        ```bash
        simple-pub-sub client publish the_topic the_message tcp 0.0.0.0 6480 --log-level info
        ```

        Using TLS:

        ```bash
        simple-pub-sub client publish the_topic the_message tcp -c certs/cert.pem 0.0.0.0 6480 --log-level trace
        ```

    - query:

        ```bash
        simple-pub-sub client query the_topic tcp 0.0.0.0 6480  --log-level trace
        ```

        Using TLS:

        ```bash
        simple-pub-sub client query the_topic tcp -c certs/cert.pem 0.0.0.0 6480  --log-level trace
        ```

  - Using Unix socket:
    - subscribe:

        ```bash
        simple-pub-sub client unix /tmp/pubsub.sock subscribe the_topic --log-level trace
        ```

    - publish:

        ```bash
        simple-pub-sub client unix /tmp/pubsub.sock publish the_topic the_message --log-level info
        ```

    - query:

        ```bash
        simple-pub-sub client unix /tmp/pubsub.sock query the_topic --log-level trace
        ```

## API Usage

To subscribe

```rust
use simple-pub-sub

// define the on_message function (callback).
pub fn on_msg(topic: String, message: Vec<u8>) {
    println!("topic: {} message: {:?}", topic, message)
}
#[tokio::main]
async fn main() -> Result<(), String> {
    let client_type = simple_pub_sub::client::PubSubTcpClient {
        server: "localhost".to_string(),
        port: 6480,
    };
    // initialize the client.
    let mut client =
        simple_pub_sub::client::Client::new(simple_pub_sub::client::PubSubClient::Tcp(client_type));
    // set the callback function.
    client.on_message(on_msg);
    // connect the client.
    let _ = client.connect().await;
    // subscribe to the given topic.
    let _ = client.subscribe("abc".to_string()).await;
    Ok(())
}
```

To publish a message

```rust
use simple_pub_sub;
async fn main() -> Result<(), String> {
    let client_type = simple_pub_sub::client::PubSubTcpClient {
        server: "localhost".to_string(),
        port: 6480,
    };
    // initialize the client.
    let mut client =
        simple_pub_sub::client::Client::new(simple_pub_sub::client::PubSubClient::Tcp(client_type));
    // connect the client.
    let _ = client.connect().await;
    // subscribe to the given topic.
    let _ = client
        .publish(
            "abc".to_string(),
            "test message".to_string().into_bytes().to_vec(),
        )
        .await;
    Ok(())
}
```