pollen-transport 0.1.0

//! Message types for cluster communication.

use bytes::Bytes;
use pollen_types::{Member, MemberState, NodeId, TaskId};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Membership update message.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MembershipUpdateMsg {
    /// Members being updated.
    pub members: Vec<MemberInfo>,
}

/// Simplified member info for wire transfer.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MemberInfo {
    pub id: NodeId,
    pub addr: String,
    pub state: MemberState,
    pub metadata: HashMap<String, String>,
    pub incarnation: u64,
}

impl From<&Member> for MemberInfo {
    fn from(m: &Member) -> Self {
        Self {
            id: m.id,
            addr: m.addr.to_string(),
            state: m.state,
            metadata: m.metadata.clone(),
            incarnation: 0,
        }
    }
}

/// CRDT delta message.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CrdtDeltaMsg {
    /// Key being updated.
    pub key: String,
    /// CRDT type.
    pub crdt_type: String,
    /// Serialized delta.
    pub delta: Bytes,
    /// HLC timestamp.
    pub timestamp: u64,
}

/// CRDT full sync request.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CrdtSyncRequestMsg {
    /// Keys to sync.
    pub keys: Vec<String>,
}

/// CRDT full sync response.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CrdtFullSyncMsg {
    /// Key-value pairs.
    pub entries: Vec<CrdtEntry>,
}

/// A single CRDT entry.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CrdtEntry {
    pub key: String,
    pub crdt_type: String,
    pub data: Bytes,
    pub timestamp: u64,
}

/// Merkle tree request for anti-entropy.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MerkleTreeRequestMsg {
    /// Depth of tree to request.
    pub depth: u32,
    /// Prefix to request (for partial sync).
    pub prefix: Option<String>,
}

/// Merkle tree response.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MerkleTreeResponseMsg {
    /// Tree nodes (hash -> children hashes).
    pub nodes: Vec<MerkleNode>,
    /// Root hash.
    pub root_hash: Bytes,
}

/// A node in the Merkle tree.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MerkleNode {
    pub hash: Bytes,
    pub range_start: String,
    pub range_end: String,
    pub children: Vec<Bytes>,
}

/// Data range request for syncing differences.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DataRangeRequestMsg {
    /// Start key (inclusive).
    pub start: String,
    /// End key (exclusive).
    pub end: String,
}

/// Data range response.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DataRangeResponseMsg {
    /// Entries in the range.
    pub entries: Vec<CrdtEntry>,
}

/// Task claim message.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TaskClaimMsg {
    /// Task being claimed.
    pub task_id: TaskId,
    /// Instance being claimed.
    pub instance_id: String,
    /// Version for optimistic locking.
    pub version: u64,
}

/// Task claim acknowledgment.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TaskClaimAckMsg {
    /// Whether the claim was successful.
    pub success: bool,
    /// Instance ID.
    pub instance_id: String,
    /// New version if successful.
    pub version: u64,
}

/// Task completion notification.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TaskCompleteMsg {
    /// Instance ID.
    pub instance_id: String,
    /// Whether execution was successful.
    pub success: bool,
    /// Error message if failed.
    pub error: Option<String>,
}