rac_rs 0.1.1

A Rust client library for RAC (Real Address Chat) protocol.
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

# `rac-rs`

[![crates.io](https://img.shields.io/crates/v/rac_rs.svg)](https://crates.io/crates/rac_rs)
[![docs.rs](https://docs.rs/rac_rs/badge.svg)](https://docs.rs/rac_rs)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)


A Rust client library for RAC (Real Address Chat) protocol.

`rac_rs` provides both synchronous and asynchronous clients to interact with RAC servers. It supports both the TCP
`RAC` protocol and the WebSocket-based `WRAC` protocol.

## Features


- Support for both `RAC` and `WRAC` protocols.
- TLS support for secure connections.
- Synchronous (`Client`) and Asynchronous (`async_client`) APIs.
- User registration and authentication for `RACv2`.
- Fetch all or only new messages.
- Send messages with `{username}` placeholder replacement.
- Comprehensive error handling via `ClientError`.

## Installation


Add this to your `Cargo.toml`:

```toml
[dependencies]
rac_rs = "0.1.0"
```

Or use bleeding-edge version from GitHub:

```toml
[dependencies]
rac_rs = { git = "https://github.com/kostya-zero/rac-rs.git" }
```

## Configuring


The crate APIs are split into separate features:

- `client` - Synchronous client for RAC protocol.
- `async_client` - Asynchronous client for RAC protocol.
- `wrac` - Synchronous client for WRAC protocol.
- `async_wrac` - Asynchronous client for WRAC protocol.

All of these features are enabled by default.

## Usage


Here is a basic example of how to use the synchronous `Client`.

```rust
use rac_rs::client::Client;
use rac_rs::shared::{ClientError,Credentials};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let credentials = Credentials {
        username: "test_user".to_string(),
        password: Some("password123".to_string()),
    };

    let mut client = Client::new(
        "127.0.0.1:42666".to_string(), // Your RAC server address
        credentials,
        false
    );

    // Test the connection
    client.test_connection()?;
    println!("Successfully connected to the server.");

    // Register a new user (only for RACv2)
    // This might fail if the user already exists.
    match client.register_user() {
        Ok(()) => println!("User registered successfully!"),
        Err(ClientError::UsernameAlreadyTaken) => println!("Username is already taken."),
        Err(e) => println!("Failed to register user: {}", e),
    }

    // Send a message. The `{username}` placeholder is automatically replaced.
    client.send_message("<{username}> Hello from rac_rs!")?;
    println!("Message sent.");

    // Fetch all messages
    println!("\n--- All Messages ---");
    let messages = client.fetch_all_messages()?;
    for msg in &messages {
        println!("{}", msg);
    }

    // Fetch only new messages since the last fetch
    println!("\n--- New Messages ---");
    // In a real application, you might wait here for new messages to arrive.
    let new_messages = client.fetch_new_messages()?;
    if new_messages.is_empty() {
        println!("No new messages.");
    } else {
        for msg in new_messages {
            println!("{}", msg);
        }
    }

    Ok(())
}
```

## Projects using `rac_rs`:

- [Tower](https://github.com/kostya-zero/tower): A modern desktop client for RAC protocol built with Tauri.

## License


This project is licensed under the [MIT License](LICENSE).