foxhunt/common/src/types.rs

//! Common data types used across services
//!
//! This module provides shared data types that are used throughout
//! the Foxhunt HFT trading system.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::fmt;
use uuid::Uuid;

/// Unique identifier for services
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ServiceId(pub String);

impl ServiceId {
    /// Create a new service ID
    pub fn new<S: Into<String>>(id: S) -> Self {
        Self(id.into())
    }
    
    /// Get the inner string value
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl fmt::Display for ServiceId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl From<&str> for ServiceId {
    fn from(s: &str) -> Self {
        Self(s.to_owned())
    }
}

impl From<String> for ServiceId {
    fn from(s: String) -> Self {
        Self(s)
    }
}

/// Service status enumeration
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ServiceStatus {
    /// Service is starting up
    Starting,
    /// Service is running normally
    Running,
    /// Service is degraded but functional
    Degraded,
    /// Service is stopping
    Stopping,
    /// Service is stopped
    Stopped,
    /// Service has encountered an error
    Error,
    /// Service is in maintenance mode
    Maintenance,
}

impl fmt::Display for ServiceStatus {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Starting => write!(f, "STARTING"),
            Self::Running => write!(f, "RUNNING"),
            Self::Degraded => write!(f, "DEGRADED"),
            Self::Stopping => write!(f, "STOPPING"),
            Self::Stopped => write!(f, "STOPPED"),
            Self::Error => write!(f, "ERROR"),
            Self::Maintenance => write!(f, "MAINTENANCE"),
        }
    }
}

impl ServiceStatus {
    /// Check if the service is healthy
    pub fn is_healthy(&self) -> bool {
        matches!(self, Self::Running | Self::Starting)
    }
    
    /// Check if the service is available for requests
    pub fn is_available(&self) -> bool {
        matches!(self, Self::Running | Self::Degraded)
    }
}

/// Configuration version for tracking changes
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConfigVersion {
    /// Version number
    pub version: u64,
    /// Timestamp when version was created
    pub timestamp: DateTime<Utc>,
    /// Optional description of changes
    pub description: Option<String>,
}

impl ConfigVersion {
    /// Create a new config version
    pub fn new(version: u64) -> Self {
        Self {
            version,
            timestamp: Utc::now(),
            description: None,
        }
    }
    
    /// Create a new config version with description
    pub fn with_description<S: Into<String>>(version: u64, description: S) -> Self {
        Self {
            version,
            timestamp: Utc::now(),
            description: Some(description.into()),
        }
    }
}

/// Timestamp type for consistent time handling
pub type Timestamp = DateTime<Utc>;

/// Request ID for tracing and correlation
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct RequestId(pub Uuid);

impl RequestId {
    /// Generate a new random request ID
    pub fn new() -> Self {
        Self(Uuid::new_v4())
    }
    
    /// Create from UUID
    pub fn from_uuid(uuid: Uuid) -> Self {
        Self(uuid)
    }
    
    /// Get the inner UUID
    pub fn as_uuid(&self) -> Uuid {
        self.0
    }
}

impl Default for RequestId {
    fn default() -> Self {
        Self::new()
    }
}

impl fmt::Display for RequestId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

/// Connection information for services
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConnectionInfo {
    /// Host address
    pub host: String,
    /// Port number
    pub port: u16,
    /// Whether TLS is enabled
    pub tls: bool,
    /// Connection timeout in milliseconds
    pub timeout_ms: u64,
}

impl ConnectionInfo {
    /// Create new connection info
    pub fn new<S: Into<String>>(host: S, port: u16) -> Self {
        Self {
            host: host.into(),
            port,
            tls: false,
            timeout_ms: 5000,
        }
    }
    
    /// Enable TLS
    pub fn with_tls(mut self) -> Self {
        self.tls = true;
        self
    }
    
    /// Set timeout
    pub fn with_timeout(mut self, timeout_ms: u64) -> Self {
        self.timeout_ms = timeout_ms;
        self
    }
    
    /// Get connection URL
    pub fn url(&self) -> String {
        let scheme = if self.tls { "https" } else { "http" };
        format!("{}://{}:{}", scheme, self.host, self.port)
    }
}

/// Resource limits for services
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceLimits {
    /// Maximum memory usage in bytes
    pub max_memory_bytes: Option<u64>,
    /// Maximum CPU usage as percentage (0-100)
    pub max_cpu_percent: Option<f64>,
    /// Maximum number of open file descriptors
    pub max_file_descriptors: Option<u32>,
    /// Maximum number of network connections
    pub max_connections: Option<u32>,
}

impl Default for ResourceLimits {
    fn default() -> Self {
        Self {
            max_memory_bytes: None,
            max_cpu_percent: None,
            max_file_descriptors: None,
            max_connections: None,
        }
    }
}