https://github.com/ntoskrnl7/wsmq-rs
A simple messaging library based on websockets and protocol buffers.
https://github.com/ntoskrnl7/wsmq-rs
easy-to-use protobuf rust snapy websocket
Last synced: 2 days ago
JSON representation
A simple messaging library based on websockets and protocol buffers.
- Host: GitHub
- URL: https://github.com/ntoskrnl7/wsmq-rs
- Owner: ntoskrnl7
- License: mit
- Created: 2021-06-06T17:20:31.000Z (about 5 years ago)
- Default Branch: main
- Last Pushed: 2021-09-06T13:50:15.000Z (almost 5 years ago)
- Last Synced: 2023-03-03T19:58:18.623Z (over 3 years ago)
- Topics: easy-to-use, protobuf, rust, snapy, websocket
- Language: Rust
- Homepage:
- Size: 102 KB
- Stars: 1
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# wsmq-rs
[](https://github.com/ntoskrnl7/wsmq-rs/actions/workflows/rust.yml)
A simple websocket messaging library based on protocol buffers.
## Example
### Basic
#### Server
```rust
wsmq::server::run("0.0.0.0:8080", |addr, res, _| {
let mut recieved = res.to_vec().clone();
tokio::spawn(async move {
recieved.extend(&addr.port().to_le_bytes());
res.reply(recieved).await;
});
})
.await
.unwrap();
```
#### Client
```rust
let client = wsmq::client::connect("ws://127.0.0.1:8080")
.await
.unwrap();
client.send(vec![1, 2, 3, 4, 5]).unwrap();
let res = client.send(vec![1, 2, 3, 4, 5]).unwrap().await.unwrap();
let recieved = res.to_vec();
println!("{:?}", recieved);
```
---
### With protocol buffers
#### Protocol buffers
```proto
syntax = "proto3";
message RequestMessage {
string text = 1;
}
message ResponseMessage {
string text = 1;
bytes payload = 2;
}
```
#### Server with protocol buffers
```rust
wsmq::server::run("0.0.0.0:8080", |addr, res, _| {
let mut message = res.to_message::().expect("[server] Failed to to_message");
tokio::spawn(async move {
let mut response_message = ResponseMessage::new();
response_message.set_text("response text".to_string());
response_message.set_payload(message.get_text().as_bytes().to_vec());
res.reply_message(&response_message).await;
});
})
.await
.expect("[server] Failed to run");
```
#### Client with protocol buffers
```rust
let client = wsmq::client::connect("ws://127.0.0.1:8080")
.await
.expect("[client] Failed to connect");
let mut message = RequestMessage::new();
message.set_text("request text".to_string());
let res = client.send_message(&message)
.expect("[client] Failed to send_message");
.await
.expect("[client] Failed to send_message");
let message = res.to_message::()
.expect("[client] Failed to to_message");
println!("{:?}", message);
```
---
### With config
#### Server with config
```rust
wsmq::server::run_with_config(
"0.0.0.0:8080",
|addr, res, _| {
let mut recieved = res.to_vec().clone();
tokio::spawn(async move {
recieved.extend(&addr.port().to_le_bytes());
res.reply(recieved).await;
});
},
wsmq::server::Config::<()>::new().set_bandwidth(1024 * 1024 * 6),
)
.await
.unwrap();
```
#### Client with config
```rust
let client = wsmq::client::connect_with_config(
"ws://127.0.0.1:8080",
wsmq::client::Config::new().set_bandwidth(1024 * 1024 * 6),
)
.await
.unwrap();
client.send(vec![1, 2, 3, 4, 5]).unwrap();
let res = client.send(vec![1, 2, 3, 4, 5]).unwrap().await.unwrap();
let recieved = res.to_vec();
println!("{:?}", recieved);
```
---
### With context
#### Server with context
```rust
#[derive(Debug)]
struct Context {
port: u16,
sent: usize,
recieved: usize,
}
wsmq::server::run_with_config(
"0.0.0.0:8080",
|addr, res, context| {
context.recieved += 1;
let mut recieved = res.to_vec().clone();
recieved.extend(&addr.port().to_le_bytes());
if let Ok(_) = block_on(res.reply(recieved)) {
context.sent += 1;
}
},
wsmq::server::Config::new()
set_bandwidth(1024),
.on_connect(Box::new(|addr| {
println!("connected ({})", addr);
Context {
port: addr.port(),
sent: 0,
recieved: 0,
}
}))
.on_disconnect(Box::new(|addr, context| {
assert_eq!(addr.port(), context.port);
println!("disconnected({}): {:?}", addr, context);
}))
.on_started(Box::new(|| {
println!("started");
}))
.on_error(Box::new(|err, ctx| {
if let Some(ctx) = ctx {
println!("error({:?}) : {}", ctx, err);
} else {
println!("error : {}", err);
}
}))
.on_progress(Box::new(|pctx, ctx| {
println!("progress ({:?}) : {:?}", ctx, pctx);
})),
)
.await
.unwrap();
```
#### Client with context
```rust
let client = wsmq::client::connect_with_config(
"ws://127.0.0.1:8080",
wsmq::client::Config::new().set_bandwidth(1024),
)
.await
.unwrap();
client.send(vec![1, 2, 3, 4, 5]).unwrap();
let res = client.send(vec![1, 2, 3, 4, 5]).unwrap().await.unwrap();
let recieved = res.to_vec();
println!("{:?}", recieved);
```