camel-master 0.7.1

Master crate for Rust Camel, re-exporting all public APIs of the workspace
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

# camel-master

> Leader-only route execution component for rust-camel

## Overview

The Master component ensures that only the current leader consumes from a route while delegating endpoint behavior to any wrapped component URI.

It wraps a delegate URI using `master:<lockname>:<delegate-uri>` and uses the configured leader elector to start or stop the delegate consumer based on leadership.

## Features

- Consumer-only leadership gating
- Leader election driven startup and shutdown
- Producer passthrough to delegate endpoints
- Graceful lifecycle management with drain timeout

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
camel-master = "0.6"
```

## URI Format

```
master:<lockname>:<delegate-uri>
```

## URI Options

The master component has no URI query parameters of its own. Any query parameters belong to the delegate URI.

| Option | Default | Description |
|--------|---------|-------------|
| delegate URI options | delegate-defined | All options after `<delegate-uri>` are parsed by the delegate component |

## Bundle Config

`camel-master` supports bundle configuration in `Camel.toml` under `[components.master]`.

| Section | Key | Default | Description |
|--------|-----|---------|-------------|
| `[components.master]` | `drain_timeout_ms` | `5000` | Max time to wait for delegate consumer shutdown on leadership loss |
| `[components.master]` | `delegate_retry_max_attempts` | `30` | Max attempts to start the delegate consumer while leading. `0` = unlimited |

## Usage

### Basic Leader-Only Timer

```rust
from("master:orders:timer:tick?period=5000")
```

Only the active leader processes timer ticks for the `orders` lock.

### With Kafka

```rust
from("master:invoices:kafka:my-topic")
```

Only the route instance that holds leadership consumes from the delegated Kafka endpoint.

### Producer Passthrough

```rust
to("master:mylock:http://api.example.com")
```

Producer calls are passed through to the delegate producer and are not gated by leadership.

## How It Works

When a master consumer starts, it joins leader election with the configured lock name. The delegate consumer is not started until leadership is acquired. On leadership loss, the delegate consumer is stopped and drained up to `drain_timeout_ms`.

If leadership is gained again, the delegate consumer is started again with the same delegate URI.

## Backends

- `NoopPlatformService` (default): single-node behavior, always leader
- `KubernetesPlatformService`: distributed leader election backed by Kubernetes Leases, configured via `[platform]` in `Camel.toml`

## Example Camel.toml

```toml
[components.master]
drain_timeout_ms = 5000

[platform]
type = "kubernetes"
namespace = "default"
```

## License

Apache-2.0

## Contributing

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