# revoke-core
Core traits and types for the Revoke microservices framework.
## Overview
`revoke-core` provides the foundational abstractions and common types used throughout the Revoke framework. It defines the core traits that all implementations must follow, ensuring consistency and interoperability between different components.
## Features
- **Service Registry Trait**: Abstract interface for service discovery and registration
- **Configuration Provider Trait**: Unified configuration management interface
- **Message Queue Trait**: Common messaging abstraction
- **Health Check Types**: Standardized health status reporting
- **Error Types**: Consistent error handling across the framework
- **Middleware Configurations**: Common patterns for retry and circuit breaker
## Core Traits
### ServiceRegistry
Manages service registration and discovery:
```rust
use revoke_core::{ServiceRegistry, ServiceInfo, Protocol};
use uuid::Uuid;
// Register a service
let service = ServiceInfo {
id: Uuid::new_v4(),
name: "user-service".to_string(),
version: "1.0.0".to_string(),
address: "127.0.0.1".to_string(),
port: 8080,
protocol: Protocol::Http,
metadata: HashMap::new(),
};
registry.register(service).await?;
// Discover services
let services = registry.get_service("user-service").await?;
// Update health status
let health = HealthStatus {
service_id: service.id,
status: Status::Healthy,
last_check: chrono::Utc::now(),
message: Some("Service is running".to_string()),
};
registry.update_health(health).await?;
```
### ConfigProvider
Provides configuration management:
```rust
use revoke_core::ConfigProvider;
// Get configuration value
let db_url = provider.get("database.url").await?;
// Set configuration value
provider.set("app.name", "my-service").await?;
// Watch for configuration changes
let mut stream = provider.watch("feature.flags").await?;
while let Some(value) = stream.next().await {
println!("Config changed: {}", value);
}
```
### MessageQueue
Abstract message queue operations:
```rust
use revoke_core::MessageQueue;
// Publish a message
let message = b"Hello, World!";
queue.publish("events", message).await?;
// Subscribe to messages
let mut stream = queue.subscribe("events").await?;
while let Some(msg) = stream.next().await {
println!("Received: {:?}", msg);
}
```
## Types
### ServiceInfo
Represents a service instance:
```rust
pub struct ServiceInfo {
pub id: Uuid,
pub name: String,
pub version: String,
pub address: String,
pub port: u16,
pub protocol: Protocol,
pub metadata: HashMap<String, String>,
}
```
### Protocol
Supported communication protocols:
```rust
pub enum Protocol {
Http,
Https,
Grpc,
Tcp,
}
```
### HealthStatus
Service health information:
```rust
pub struct HealthStatus {
pub service_id: Uuid,
pub status: Status,
pub last_check: DateTime<Utc>,
pub message: Option<String>,
}
pub enum Status {
Healthy,
Unhealthy,
Unknown,
}
```
## Error Handling
The framework uses a unified error type:
```rust
pub enum RevokeError {
ServiceNotFound(String),
ConfigError(String),
ConnectionError(String),
SerializationError(#[from] serde_json::Error),
IoError(#[from] std::io::Error),
Unknown(String),
}
pub type Result<T> = std::result::Result<T, RevokeError>;
```
## Middleware Configuration
### RetryConfig
Configuration for retry middleware:
```rust
use revoke_core::middleware::RetryConfig;
use std::time::Duration;
let config = RetryConfig {
max_attempts: 3,
initial_delay: Duration::from_millis(100),
max_delay: Duration::from_secs(10),
multiplier: 2.0,
};
```
### CircuitBreakerConfig
Configuration for circuit breaker:
```rust
use revoke_core::middleware::CircuitBreakerConfig;
use std::time::Duration;
let config = CircuitBreakerConfig {
failure_threshold: 5,
success_threshold: 2,
timeout: Duration::from_secs(60),
};
```
## Usage
Add to your `Cargo.toml`:
```toml
[dependencies]
revoke-core = { version = "0.1.0" }
```
Then use the traits in your implementation:
```rust
use revoke_core::{ServiceRegistry, ConfigProvider, Result};
use async_trait::async_trait;
struct MyRegistry;
#[async_trait]
impl ServiceRegistry for MyRegistry {
async fn register(&self, service: ServiceInfo) -> Result<()> {
// Implementation
Ok(())
}
// ... other methods
}
```
## Design Principles
1. **Trait-based Abstraction**: All major components are defined as traits, allowing for flexible implementations
2. **Async-first**: All operations are async by default using Tokio
3. **Type Safety**: Strong typing with serde serialization
4. **Error Propagation**: Consistent error handling with the `?` operator
5. **Zero-copy Streaming**: Uses streams for efficient data transfer
## Integration
`revoke-core` is designed to be the foundation for:
- Service registries (Consul, etcd, Kubernetes)
- Configuration providers (Consul KV, etcd, files)
- Message queues (Redis, Kafka, RabbitMQ)
- Health check systems
- Monitoring and metrics collection
## Examples
See the individual module documentation for specific implementation examples:
- [revoke-registry](../revoke-registry) - Service discovery implementations
- [revoke-config](../revoke-config) - Configuration management
- [revoke-mq](../revoke-mq) - Message queue clients