camel-component-seda 0.24.0

SEDA component for rust-camel (asynchronous in-memory staging)
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

# camel-component-seda

> SEDA component for rust-camel (asynchronous in-memory staging)

## Overview

The SEDA (Staged Event-Driven Architecture) component provides asynchronous, in-memory communication between routes via bounded queues. Unlike the Direct component (synchronous), a producer sends to a SEDA endpoint and returns immediately — the consumer processes the exchange asynchronously from a background task.

This is ideal for decoupling routes, buffering bursts of messages, and building staged processing pipelines.

## Features

- **Asynchronous**: Producer returns immediately; consumer processes in background
- **Bounded queues**: Configurable queue size with fail-fast or blocking behavior
- **Exchange patterns**: InOnly (fire-and-forget) and InOut (request-reply with timeout)
- **Fanout**: Multiple consumers on the same SEDA name (pub-sub)
- **Configurable concurrency**: `concurrentConsumers` hint for parallel processing

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
camel-component-seda = "*"
```

## URI Format

```
seda:name[?options]
```

### Options

| Option | Default | Description |
|--------|---------|-------------|
| `size` | `1000` | Queue capacity |
| `exchangePattern` | `InOnly` | `InOnly` or `InOut` |
| `multipleConsumers` | `false` | Enable fanout (multiple consumers) |
| `concurrentConsumers` | `1` | Concurrency hint for the runtime |
| `blockWhenFull` | `false` | Block producer if queue is full |
| `timeout` | `30000` | Timeout (ms) for InOut and blockWhenFull |
| `waitForTaskToComplete` | `IfReplyExpected` | `Never`, `IfReplyExpected`, or `Always` |
| `discardIfNoConsumers` | `false` | Silently discard if no active consumers |

## Usage

### Connecting Routes (Fire-and-Forget)

```rust
use camel_builder::RouteBuilder;
use camel_component_seda::SedaComponent;
use camel_core::context::CamelContext;

let mut ctx = CamelContext::new();
ctx.register_component(SedaComponent::new());

// Route 1: Producer (returns immediately)
let route1 = RouteBuilder::from("timer:tick?period=1000")
    .to("seda:processing")
    .build()?;

// Route 2: Consumer (processes asynchronously)
let route2 = RouteBuilder::from("seda:processing")
    .to("log:output?showBody=true")
    .build()?;

ctx.add_route(route1).await?;
ctx.add_route(route2).await?;
```

### Request-Reply (InOut)

```rust
// Consumer processes and replies
let consumer = RouteBuilder::from("seda:bridge?exchangePattern=InOut")
    .process(|mut ex| async move {
        // Transform and reply
        Ok(ex)
    })
    .build()?;

// Producer waits for reply (up to timeout)
let producer = RouteBuilder::from("timer:tick?period=1000")
    .to("seda:bridge?exchangePattern=InOut&timeout=5000")
    .to("log:reply?showBody=true")
    .build()?;
```

### Fanout (Multiple Consumers)

```rust
// Enable multipleConsumers — all subscribers receive each exchange
let publisher = RouteBuilder::from("timer:events?period=500")
    .to("seda:events?multipleConsumers=true")
    .build()?;

let subscriber_a = RouteBuilder::from("seda:events?multipleConsumers=true")
    .to("log:A?showBody=true")
    .build()?;

let subscriber_b = RouteBuilder::from("seda:events?multipleConsumers=true")
    .to("log:B?showBody=true")
    .build()?;
```

### Backpressure with blockWhenFull

```rust
// Producer blocks (up to timeout) when queue is full
let route = RouteBuilder::from("timer:fast?period=10")
    .to("seda:buffer?size=50&blockWhenFull=true&timeout=5000")
    .build()?;
```

## Differences from Direct

| | Direct | SEDA |
|---|---|---|
| Communication | Synchronous | Asynchronous |
| Producer blocks? | Yes (until consumer done) | No (unless `blockWhenFull`) |
| Queue | None | Bounded (`size`) |
| Multiple consumers | No | Yes (`multipleConsumers`) |
| Use case | Modular route linking | Decoupling, buffering, staging |

## Example

See [`examples/seda-demo/`](../../examples/seda-demo/) for a complete working example.

## Documentation

- [API Documentation](https://docs.rs/camel-component-seda)
- [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.