rubbo 0.1.0

Rust implementation of Apache Dubbo 3. High-performance RPC framework with Triple 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
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

[English](README.md) | [δΈ­ζ–‡](README_zh.md)

# Rubbo πŸ¦€πŸš€

Rubbo is a high-performance, Rust-based RPC framework designed to be fully compatible with the [Dubbo 3.0](https://dubbo.apache.org/) ecosystem. It leverages the Triple protocol (based on gRPC/HTTP2) and supports seamless interoperability with Java Dubbo applications using Nacos for service discovery.

## Features

- **Triple Protocol**: Fully compatible with Dubbo 3.0 Triple protocol.
- **Service Discovery**: Built-in support for Nacos registry.
- **Macro Support**: Easy-to-use attribute macros for defining services and references.
- **High Performance**: Built on top of `tokio` and `hyper` for asynchronous I/O.
- **Interoperability**: Works out-of-the-box with Java Dubbo providers and consumers.
- **Load Balancing**: Pluggable load balancing strategies (default: RoundRobin).

## Supported Protocols & Serialization

| Category | Type | Description | Feature Flag |
| :--- | :--- | :--- | :--- |
| **Protocol** | **Triple** | Based on HTTP/2 and gRPC, fully compatible with Dubbo 3.0. | - |
| **Serialization** | **FastJSON** | Default text-based JSON serialization. | `fastjson` (Default) |
| **Serialization** | **FastJSON2** | High-performance binary JSONB format (Dubbo 3 default). | `fastjson2` |
| **Serialization** | **Hessian2** | Standard binary serialization. | `hessian2` |

## Getting Started

### Prerequisites

- Rust (latest stable)
- Nacos Server (running on 127.0.0.1:8848 or configurable)

### Defining a Service

Define your service interface using the `#[rubbo::service]` macro:

```rust
#[rubbo::service]
trait HelloService {
    async fn say_hello(&self, name: String) -> String;
}
```

### Implementing a Provider

Implement the service and start a provider:

```rust
use rubbo::{ProviderBuilder, Registry, Protocol, Serialize};

struct HelloServiceImpl;

#[rubbo::service_impl(group = "test_group", version = "1.0.0", name = "com.example.HelloService")]
impl HelloService for HelloServiceImpl {
    async fn say_hello(&self, name: String) -> String {
        format!("Hello, {}!", name)
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt::init();

    rubbo::ProviderBuilder::new()
        .service(HelloServiceImpl)
        .application("rubbo-provider-example")
        .registry(Registry::Nacos("nacos://127.0.0.1:8848".to_string()))
        .protocol(Protocol::Triple)
        .serialization(Serialize::Fastjson2)
        .port(50051)
        .start()
        .await?;
    Ok(())
}
```

### Implementing a Consumer

Create a consumer to invoke the service:

```rust
use rubbo::{ConsumerBuilder, Registry};

#[rubbo::reference(interface_name = "com.example.HelloService", version = "1.0.0", group = "test_group")]
trait HelloService {
    async fn say_hello(&self, name: String) -> String;
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt::init();

    let consumer = ConsumerBuilder::new()
        .application("rubbo-consumer-example")
        .registry(Registry::Nacos("nacos://127.0.0.1:8848".to_string()))
        .reference::<dyn HelloService>()
        .build()
        .await?;

    let service = consumer.reference::<dyn HelloService>().await?;
    let response = service.say_hello("World".to_string()).await?;
    println!("Response: {}", response);
    Ok(())
}
```

## Benchmark

We provide a built-in benchmark tool to measure the performance of Rubbo.

### Environment
- **OS**: macOS
- **Protocol**: Triple (HTTP/2)
- **Registry**: Nacos (Local)
- **Serialization**: FastJSON
- **Machine**: Local Development Machine

### Running the Benchmark

1. **Start Nacos Server** (Ensure it's running on port 8848)
2. **Start the Benchmark Provider**:
   ```bash
   cargo run --release --example benchmark_provider
   ```
3. **Run the Benchmark Consumer**:
   ```bash
   BENCH_CONCURRENCY=50 BENCH_REQUESTS=20000 cargo run --release --example benchmark_consumer
   ```

### Results

| Metric | Value |
|--------|-------|
| **Concurrency** | 50 threads |
| **Total Requests** | 20,000 |
| **QPS** | **~26,384** |
| **Avg Latency** | **1.88 ms** |
| **Success Rate** | 100% |

*Note: Results may vary based on hardware and network conditions.*

## License

MIT