rust-eureka 0.2.0

Simple Netflix Eureka Client
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

# rust_eureka

<!-- markdownlint-disable line-length --->

[![Crates.io](https://img.shields.io/crates/v/rust-eureka.svg)](https://crates.io/crates/rust-eureka)
[![Build Status](https://img.shields.io/github/actions/workflow/status/ayax79/rust_eureka/ci.yml?branch=main)](https://github.com/ayax79/rust_eureka/actions)
[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)

A Rust implementation of a client for Netflix
[Eureka](https://github.com/Netflix/eureka)

## Features

- Service registration
- Application discovery (single and all)
- Async/await with Tokio
- Full JSON serialization/deserialization
- Type-safe API
- Comprehensive error handling

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
rust-eureka = "0.2"
```

## Usage

```rust
use rust_eureka::{EurekaClient, request::{Instance, RegisterRequest, Status, DataCenterInfo, DcName}};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a Eureka client
    let client = EurekaClient::new("my-service", "http://localhost:8080");

    // Build an instance registration
    let instance = Instance {
        host_name: "localhost".to_owned(),
        app: "MY_SERVICE".to_owned(),
        ip_addr: "127.0.0.1".to_owned(),
        vip_address: "127.0.0.1".to_owned(),
        secure_vip_address: "127.0.0.1".to_owned(),
        status: Status::Up,
        port: Some(8080),
        secure_port: None,
        homepage_url: "http://localhost:8080".to_owned(),
        status_page_url: "http://localhost:8080/status".to_owned(),
        health_check_url: "http://localhost:8080/health".to_owned(),
        data_center_info: DataCenterInfo {
            name: DcName::MyOwn,
            metadata: None,
        },
        lease_info: None,
        metadata: serde_json::Map::new(),
    };

    let request = RegisterRequest::new(instance);

    // Register with Eureka
    client.register("MY_SERVICE", &request).await?;
    println!("Successfully registered with Eureka");

    // Query for a specific application
    let app = client.get_application("MY_SERVICE").await?;
    println!("Found application: {}", app.application.name);

    // Query all applications
    let apps = client.get_applications().await?;
    println!("Total applications: {}", apps.applications.applications.len());

    Ok(())
}
```

## Testing

### Unit Tests

Run the unit tests:

```bash
cargo test
```

### Integration Tests

The project includes comprehensive integration tests that run against a real
Eureka server. See [INTEGRATION_TESTING.md](INTEGRATION_TESTING.md) for detailed
instructions.

Quick start:

```bash
# Start Eureka with Docker
docker run -p 8080:8080 springcloud/eureka

# Run integration tests
EUREKA_URI=http://localhost:8080 cargo test --test integration_tests -- --ignored --test-threads=1
```

## Development

This project follows strict Rust quality standards:

CI: GitHub Actions workflow added to run formatting, clippy, tests, docs, and
security/coverage checks. See .github/workflows/ci.yml

- Zero clippy warnings with `-D warnings`
- Formatted with `rustfmt`
- 80%+ code coverage
- Comprehensive documentation

See [AGENT_GUIDELINES.md](.project_hints) for detailed development guidelines.

### Pre-commit Checklist

```bash
cargo fmt --all
cargo clippy --all-targets --all-features -- -D warnings
cargo test --all-features
cargo doc --no-deps
```

## API Endpoints

This client implements the Eureka v2 REST API:

- `POST /v2/apps/{appID}` - Register instance
- `GET /v2/apps/{appID}` - Get application
- `GET /v2/apps` - Get all applications

For more details, see the
[Eureka REST API documentation](https://github.com/Netflix/eureka/wiki/Eureka-REST-operations).

## License

Licensed under the MIT license. See [LICENSE](LICENSE) for details.