agent-team-mail-core 1.3.1

Core library for local agent team mail workflows.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::sync::Arc;

use crate::ack;
use crate::boundary::{self, ClientTransport};
use crate::clear;
use crate::doctor;
use crate::error::AtmError;
use crate::list;
use crate::observability::{
    AtmLogQuery, AtmLogSnapshot, AtmObservabilityHealth, AtmObservabilityHealthState, CommandEvent,
    LogTailSession, ObservabilityPort,
};
use crate::protocol::{
    RequestEnvelope, ResponseEnvelope, SendRequestEnvelope, SendResponseEnvelope,
};
use crate::read;
use crate::send;

#[derive(Clone)]
pub struct FakeClientTransport {
    handler: Arc<dyn Fn(RequestEnvelope) -> Result<ResponseEnvelope, AtmError> + Send + Sync>,
}

impl std::fmt::Debug for FakeClientTransport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("FakeClientTransport")
            .finish_non_exhaustive()
    }
}

impl FakeClientTransport {
    pub fn new<F>(handler: F) -> Self
    where
        F: Fn(RequestEnvelope) -> Result<ResponseEnvelope, AtmError> + Send + Sync + 'static,
    {
        Self {
            handler: Arc::new(handler),
        }
    }
}

impl boundary::sealed::Sealed for FakeClientTransport {}

impl ClientTransport for FakeClientTransport {
    fn send(&self, request: RequestEnvelope) -> Result<ResponseEnvelope, AtmError> {
        (self.handler)(request)
    }
}

pub struct LoopbackClientTransport {
    observability: Arc<dyn ObservabilityPort + Send + Sync>,
}

impl std::fmt::Debug for LoopbackClientTransport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("LoopbackClientTransport")
            .finish_non_exhaustive()
    }
}

impl LoopbackClientTransport {
    pub fn new(observability: Arc<dyn ObservabilityPort + Send + Sync>) -> Self {
        Self { observability }
    }
}

impl boundary::sealed::Sealed for LoopbackClientTransport {}

impl ClientTransport for LoopbackClientTransport {
    fn send(&self, request: RequestEnvelope) -> Result<ResponseEnvelope, AtmError> {
        match request {
            RequestEnvelope::Send(SendRequestEnvelope::Compose(request)) => {
                send::send_mail(request, self.observability.as_ref())
                    .map(|outcome| ResponseEnvelope::Send(SendResponseEnvelope::Sent(outcome)))
            }
            RequestEnvelope::Send(SendRequestEnvelope::Acknowledge(request)) => {
                ack::ack_mail(request, self.observability.as_ref()).map(|outcome| {
                    ResponseEnvelope::Send(SendResponseEnvelope::Acknowledged(outcome))
                })
            }
            RequestEnvelope::CompatibilityPreflight(_) => Err(AtmError::daemon_unavailable(
                "loopback compatibility preflight is not wired outside the daemon runtime",
            )),
            RequestEnvelope::Heartbeat(_) => Err(AtmError::daemon_unavailable(
                "loopback heartbeat transport is not wired outside the daemon runtime",
            )),
            RequestEnvelope::List(query) => {
                list::list_mail(query, self.observability.as_ref()).map(ResponseEnvelope::List)
            }
            RequestEnvelope::Peek(query) => read::peek_mail(query, self.observability.as_ref())
                .map(|outcome| ResponseEnvelope::Peek(Box::new(outcome))),
            RequestEnvelope::Receive(query) => read::read_mail(query, self.observability.as_ref())
                .map(|outcome| ResponseEnvelope::Receive(Box::new(outcome))),
            RequestEnvelope::Clear(query) => {
                clear::clear_mail(query, self.observability.as_ref()).map(ResponseEnvelope::Clear)
            }
            RequestEnvelope::Doctor(query) => {
                doctor::run_doctor(query, self.observability.as_ref())
                    .map(|report| ResponseEnvelope::Doctor(Box::new(report)))
            }
        }
    }
}

#[derive(Debug, Default)]
pub struct HealthyObservability;

impl boundary::sealed::Sealed for HealthyObservability {}

impl ObservabilityPort for HealthyObservability {
    fn emit(&self, _event: CommandEvent) -> Result<(), AtmError> {
        Ok(())
    }

    fn query(&self, _req: AtmLogQuery) -> Result<AtmLogSnapshot, AtmError> {
        Ok(AtmLogSnapshot::default())
    }

    fn follow(&self, _req: AtmLogQuery) -> Result<LogTailSession, AtmError> {
        Ok(LogTailSession::empty())
    }

    fn health(&self) -> Result<AtmObservabilityHealth, AtmError> {
        Ok(AtmObservabilityHealth {
            active_log_path: None,
            logging_state: AtmObservabilityHealthState::Healthy,
            query_state: Some(AtmObservabilityHealthState::Healthy),
            maintenance: None,
            diagnostic: None,
            detail: None,
        })
    }
}