camel-component-ws 0.5.6

WebSocket component for rust-camel
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

# camel-component-ws

> WebSocket client/server component for rust-camel

## Overview

`camel-component-ws` adds WebSocket endpoints to rust-camel for both inbound server consumers and outbound client producers.

## URI Format

```text
ws://host:port/path[?options]
wss://host:port/path[?options]
```

## Features

- **Server Consumer**: accept incoming WebSocket connections and feed route exchanges
- **Client Producer**: connect to remote WebSocket endpoints and send/receive frames
- **Server-send mode**: send to all local clients (broadcast) or specific connections
- **TLS**: secure server/client URIs via `wss://` (rustls, no OpenSSL dependency)
- **Runtime enforcement**: max connections, message size, heartbeat, and idle timeout

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
camel-component-ws = "0.5"
```

## URI Parameters

| Parameter | Default | Description |
|-----------|---------|-------------|
| `maxConnections` | `100` | Maximum concurrent connections for the endpoint path |
| `maxMessageSize` | `65536` | Maximum inbound message size (bytes) |
| `sendToAll` | `false` | Default producer behavior for local server-send mode |
| `heartbeatIntervalMs` | `0` | Ping interval in milliseconds (`0` disables heartbeat) |
| `idleTimeoutMs` | `0` | Idle timeout in milliseconds (`0` disables timeout) |
| `connectTimeoutMs` | `10000` | Client connect timeout in milliseconds (10s) |
| `responseTimeoutMs` | `30000` | Client response timeout in milliseconds |
| `allowOrigin` | `*` | Allowed Origin header for WS upgrade requests |
| `tlsCert` | _(none)_ | TLS certificate path (required for `wss` consumer) |
| `tlsKey` | _(none)_ | TLS private key path (required for `wss` consumer) |

## Exchange Headers

| Header | Direction | Description |
|--------|-----------|-------------|
| `CamelWsConnectionKey` | Consumer → route | Unique connection key for the current client |
| `CamelWsPath` | Consumer → route | Request path that received the message |
| `CamelWsRemoteAddress` | Consumer → route | Remote peer socket address |
| `CamelWsSendToAll` | Route → producer | If `true`, producer broadcasts to all local clients |
| `sendToAll` | Route → producer | Fallback for `CamelWsSendToAll` (checked if not set) |
| `CamelWsMessageType` | Route → producer | Outbound type: `text` (default) or `binary` |

## Usage (DSL)

### WebSocket Consumer Route

```rust
use camel_builder::RouteBuilder;
use camel_component_ws::WsComponent;
use camel_core::CamelContext;

let mut ctx = CamelContext::new();
ctx.register_component("ws", Box::new(WsComponent));

ctx.add_route(
    RouteBuilder::from("ws://0.0.0.0:9000/chat?maxConnections=200")
        .process(|ex| async move {
            // ex.input contains CamelWsConnectionKey / CamelWsPath / CamelWsRemoteAddress
            Ok(ex)
        })
        .build()?
).await?;
```

### WebSocket Client Producer

```rust
let route = RouteBuilder::from("direct:send")
    .to("ws://127.0.0.1:9000/chat?responseTimeoutMs=5000")
    .build()?;
```

### Local Server Broadcast

```rust
use serde_json::Value;

let route = RouteBuilder::from("direct:broadcast")
    .set_header("CamelWsSendToAll", Value::Bool(true))
    .set_header("CamelWsMessageType", Value::String("text".into()))
    .to("ws://127.0.0.1:9000/chat")
    .build()?;
```

### Local Server Targeted Send

```rust
use serde_json::Value;

let route = RouteBuilder::from("direct:target")
    .set_header(
        "CamelWsConnectionKey",
        Value::String("conn-a,conn-b".to_string())
    )
    .to("ws://127.0.0.1:9000/chat")
    .build()?;
```

### Secure WSS Consumer

```rust
let route = RouteBuilder::from(
    "wss://0.0.0.0:9443/secure?tlsCert=/etc/certs/server.pem&tlsKey=/etc/certs/server.key"
)
.build()?;
```

## Camel.toml Example

```toml
[default.components.ws]
max_connections = 200
max_message_size = 131072
heartbeat_interval_ms = 15000
idle_timeout_ms = 60000
connect_timeout_ms = 5000
response_timeout_ms = 10000
```

URI parameters still take precedence over global defaults.

> **Note:** Global config from Camel.toml is parsed but not yet applied to endpoints. Currently only URI parameters and code defaults are active. Full 3-tier override (defaults → Camel.toml → URI) is planned.

## Documentation

- [API Documentation](https://docs.rs/camel-component-ws)
- [Repository](https://github.com/kennycallado/rust-camel)

## License

Apache-2.0

## Contributing

Contributions are welcome! Please see the [main repository](https://github.com/kennycallado/rust-camel) for details.