VesselRs 0.1.0

Shared memory primitives for multi-agent orchestration
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

//! # Use Cases
//!
//! Application services that orchestrate domain logic.
//!
//! ## CQRS Pattern
//!
//! - **Commands**: Operations that change state
//! - **Queries**: Operations that read state without side effects

use crate::ports::driven::{CircuitBreakerPort, CommandCachePort, EventPort};
use crate::domain::events::ShmEvent;
use std::time::SystemTime;

/// Use case for acquiring a command lock
pub struct AcquireLockUseCase<T: CommandCachePort, E: EventPort> {
    cache: T,
    events: E,
}

impl<T: CommandCachePort, E: EventPort> AcquireLockUseCase<T, E> {
    pub fn new(cache: T, events: E) -> Self {
        Self { cache, events }
    }

    pub fn execute(&mut self, cmd_hash: String, pid: u32) -> Result<(), String> {
        self.cache.acquire_lock(&cmd_hash, pid)?;
        self.events.publish(ShmEvent::CommandLockAcquired {
            cmd_hash,
            pid,
            timestamp: SystemTime::now(),
        })?;
        Ok(())
    }
}

/// Use case for releasing a command lock
pub struct ReleaseLockUseCase<T: CommandCachePort, E: EventPort> {
    cache: T,
    events: E,
}

impl<T: CommandCachePort, E: EventPort> ReleaseLockUseCase<T, E> {
    pub fn new(cache: T, events: E) -> Self {
        Self { cache, events }
    }

    pub fn execute(&mut self, cmd_hash: String, pid: u32) -> Result<(), String> {
        self.cache.release_lock(&cmd_hash, pid)?;
        self.events.publish(ShmEvent::CommandLockReleased {
            cmd_hash,
            pid,
            timestamp: SystemTime::now(),
        })?;
        Ok(())
    }
}

/// Use case for circuit breaker operations
pub struct CircuitBreakerUseCase<T: CircuitBreakerPort, E: EventPort> {
    breakers: T,
    events: E,
}

impl<T: CircuitBreakerPort, E: EventPort> CircuitBreakerUseCase<T, E> {
    pub fn new(breakers: T, events: E) -> Self {
        Self { breakers, events }
    }

    pub fn record_success(&mut self, target: String) -> Result<(), String> {
        self.breakers.record_success(&target)?;
        self.events.publish(ShmEvent::CircuitBreakerClosed {
            target,
            timestamp: SystemTime::now(),
        })?;
        Ok(())
    }

    pub fn record_failure(&mut self, target: String) -> Result<(), String> {
        self.breakers.record_failure(&target)?;
        // Check if breaker opened
        if let Some(breaker) = self.breakers.get_breaker(&target) {
            if breaker.state == crate::domain::value_objects::CircuitState::Open {
                self.events.publish(ShmEvent::CircuitBreakerOpened {
                    target,
                    failures: breaker.failures,
                    timestamp: SystemTime::now(),
                })?;
            }
        }
        Ok(())
    }
}