Your First Service

cargo new my-first-service
cd my-first-service

[dependencies]
scoutquest-rust = "1.0"
axum = "0.7"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tower = "0.4"
tower-http = { version = "0.5", features = ["cors"] }

use axum::{
    extract::Path,
    http::StatusCode,
    response::Json,
    routing::{get, post},
    Router,
};
use scoutquest_rust::ServiceDiscoveryClient;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use tokio::signal;
use tower_http::cors::CorsLayer;

#[derive(Serialize)]
struct HealthResponse {
    status: String,
    timestamp: String,
    service: String,
}

#[derive(Serialize)]
struct HelloResponse {
    message: String,
    timestamp: String,
}

#[derive(Serialize)]
struct UserResponse {
    id: String,
    name: String,
    email: String,
    service: String,
}

async fn health_check() -> Json {
    Json(HealthResponse {
        status: "healthy".to_string(),
        timestamp: chrono::Utc::now().to_rfc3339(),
        service: "my-first-service".to_string(),
    })
}

async fn hello() -> Json {
    Json(HelloResponse {
        message: "Hello from my first service!".to_string(),
        timestamp: chrono::Utc::now().to_rfc3339(),
    })
}

async fn get_user(Path(user_id): Path) -> Json {
    Json(UserResponse {
        id: user_id.clone(),
        name: format!("User {}", user_id),
        email: format!("user{}@example.com", user_id),
        service: "my-first-service".to_string(),
    })
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    println!("🚀 Starting my first service...");

    // Create ScoutQuest client
    let client = ServiceDiscoveryClient::new("http://localhost:8080")?;

    // Create router
    let app = Router::new()
        .route("/health", get(health_check))
        .route("/api/hello", get(hello))
        .route("/api/users/:id", get(get_user))
        .layer(CorsLayer::permissive());

    // Start server
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await?;
    println!("📡 Service running on port 3000");

    // Register service with ScoutQuest
    let mut metadata = HashMap::new();
    metadata.insert("version".to_string(), "1.0.0".to_string());
    metadata.insert("description".to_string(), "My first ScoutQuest service".to_string());
    metadata.insert("endpoints".to_string(), "/api/hello,/api/users/:id".to_string());

    let service_instance = client.register_service(
        "my-first-service",
        "localhost",
        3000,
        Some(metadata)
    ).await?;

    println!("✅ Service registered with ScoutQuest!");
    println!("   Instance ID: {}", service_instance.id);
    println!("   URL: http://localhost:3000");
    println!("   Health Check: http://localhost:3000/health");

    // Start server with graceful shutdown
    tokio::select! {
        result = axum::serve(listener, app) => {
            if let Err(err) = result {
                eprintln!("❌ Server error: {}", err);
            }
        }
        _ = shutdown_signal() => {
            println!("🛑 Shutting down gracefully...");

            // Deregister service
            if let Err(err) = client.deregister_service(&service_instance.id).await {
                eprintln!("⚠️  Failed to deregister service: {}", err);
            } else {
                println!("✅ Service deregistered from ScoutQuest");
            }
        }
    }

    Ok(())
}

async fn shutdown_signal() {
    let ctrl_c = async {
        signal::ctrl_c()
            .await
            .expect("failed to install Ctrl+C handler");
    };

    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to install signal handler")
            .recv()
            .await;
    };

    #[cfg(not(unix))]
    let terminate = std::future::pending::<()>();

    tokio::select! {
        _ = ctrl_c => {},
        _ = terminate => {},
    }
}

cargo add chrono --features serde

cargo run

use scoutquest_rust::ServiceDiscoveryClient;

#[tokio::main]
async fn main() -> Result<(), Box> {
    println!("🔍 ScoutQuest Client Demo");
    println!("========================");

    let client = ServiceDiscoveryClient::new("http://localhost:8080")?;

    // Discover the service
    println!("🔍 Discovering \"my-first-service\"...");
    match client.discover_service("my-first-service").await {
        Ok(instance) => {
            println!("✅ Service found:");
            println!("   ID: {}", instance.id);
            println!("   Address: {}:{}", instance.host, instance.port);
            println!("   Status: {}", instance.status);
            println!("   Tags: {:?}", instance.tags);

            // Make HTTP calls through service discovery
            println!("\n📡 Making HTTP calls...");

            // Call hello endpoint
            match client.get_service("my-first-service", "/api/hello").await {
                Ok(response) => {
                    println!("✅ Hello response: {}", response);
                }
                Err(e) => println!("❌ Hello call failed: {}", e),
            }

            // Call user endpoint
            match client.get_service("my-first-service", "/api/users/456").await {
                Ok(response) => {
                    println!("✅ User response: {}", response);
                }
                Err(e) => println!("❌ User call failed: {}", e),
            }
        }
        Err(e) => {
            println!("❌ Service discovery failed: {}", e);
        }
    }

    // List all services
    println!("\n📋 All registered services:");
    match client.list_services().await {
        Ok(services) => {
            for service in services {
                println!("   - {} ({} instances)", service.name, service.instance_count);
            }
        }
        Err(e) => println!("❌ Failed to list services: {}", e),
    }

    Ok(())
}

cargo run --bin client