cm-dashboard/shared/src/protocol.rs

use crate::metrics::Metric;
use serde::{Deserialize, Serialize};

/// Message sent from agent to dashboard via ZMQ
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetricMessage {
    pub hostname: String,
    pub timestamp: u64,
    pub metrics: Vec<Metric>,
}

/// Command output streaming message
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommandOutputMessage {
    pub hostname: String,
    pub command_id: String,
    pub command_type: String,
    pub output_line: String,
    pub is_complete: bool,
    pub timestamp: u64,
}

impl MetricMessage {
    pub fn new(hostname: String, metrics: Vec<Metric>) -> Self {
        Self {
            hostname,
            timestamp: chrono::Utc::now().timestamp() as u64,
            metrics,
        }
    }
}

impl CommandOutputMessage {
    pub fn new(hostname: String, command_id: String, command_type: String, output_line: String, is_complete: bool) -> Self {
        Self {
            hostname,
            command_id,
            command_type,
            output_line,
            is_complete,
            timestamp: chrono::Utc::now().timestamp() as u64,
        }
    }
}

/// Commands that can be sent from dashboard to agent
#[derive(Debug, Serialize, Deserialize)]
pub enum Command {
    /// Request immediate metric refresh
    RefreshMetrics,
    /// Request specific metrics by name
    RequestMetrics { metric_names: Vec<String> },
    /// Ping command for connection testing
    Ping,
}

/// Response from agent to dashboard commands
#[derive(Debug, Serialize, Deserialize)]
pub enum CommandResponse {
    /// Acknowledgment of command
    Ack,
    /// Metrics response
    Metrics(Vec<Metric>),
    /// Pong response to ping
    Pong,
    /// Error response
    Error { message: String },
}

/// ZMQ message envelope for routing
#[derive(Debug, Serialize, Deserialize)]
pub struct MessageEnvelope {
    pub message_type: MessageType,
    pub payload: Vec<u8>,
}

#[derive(Debug, Serialize, Deserialize)]
pub enum MessageType {
    Metrics,
    Command,
    CommandResponse,
    CommandOutput,
    Heartbeat,
}

impl MessageEnvelope {
    pub fn metrics(message: MetricMessage) -> Result<Self, crate::SharedError> {
        Ok(Self {
            message_type: MessageType::Metrics,
            payload: serde_json::to_vec(&message)?,
        })
    }

    pub fn command(command: Command) -> Result<Self, crate::SharedError> {
        Ok(Self {
            message_type: MessageType::Command,
            payload: serde_json::to_vec(&command)?,
        })
    }

    pub fn command_response(response: CommandResponse) -> Result<Self, crate::SharedError> {
        Ok(Self {
            message_type: MessageType::CommandResponse,
            payload: serde_json::to_vec(&response)?,
        })
    }

    pub fn command_output(message: CommandOutputMessage) -> Result<Self, crate::SharedError> {
        Ok(Self {
            message_type: MessageType::CommandOutput,
            payload: serde_json::to_vec(&message)?,
        })
    }

    pub fn heartbeat() -> Result<Self, crate::SharedError> {
        Ok(Self {
            message_type: MessageType::Heartbeat,
            payload: Vec::new(),
        })
    }

    pub fn decode_metrics(&self) -> Result<MetricMessage, crate::SharedError> {
        match self.message_type {
            MessageType::Metrics => Ok(serde_json::from_slice(&self.payload)?),
            _ => Err(crate::SharedError::Protocol {
                message: "Expected metrics message".to_string(),
            }),
        }
    }

    pub fn decode_command(&self) -> Result<Command, crate::SharedError> {
        match self.message_type {
            MessageType::Command => Ok(serde_json::from_slice(&self.payload)?),
            _ => Err(crate::SharedError::Protocol {
                message: "Expected command message".to_string(),
            }),
        }
    }

    pub fn decode_command_response(&self) -> Result<CommandResponse, crate::SharedError> {
        match self.message_type {
            MessageType::CommandResponse => Ok(serde_json::from_slice(&self.payload)?),
            _ => Err(crate::SharedError::Protocol {
                message: "Expected command response message".to_string(),
            }),
        }
    }

    pub fn decode_command_output(&self) -> Result<CommandOutputMessage, crate::SharedError> {
        match self.message_type {
            MessageType::CommandOutput => Ok(serde_json::from_slice(&self.payload)?),
            _ => Err(crate::SharedError::Protocol {
                message: "Expected command output message".to_string(),
            }),
        }
    }
}