rustpbx 0.4.9

A SIP PBX implementation in Rust
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

//! SessionActionExecutor - Bridge to existing SessionAction implementation
//!
//! This executor wraps the existing `CallSession::apply_session_action` path,
//! converting `CallCommand` to `SessionAction` and executing via the legacy runtime.
//!
//! ## Status
//!
//! This is a **migration executor**. It will be replaced by `SipSessionRuntime`
//! once Phase D is complete.
//!
//! NOTE: This file has been updated to work with SipSessionHandle directly.
//! The SessionAction conversion is no longer used since SipSessionHandle
//! accepts CallCommand directly.

use async_trait::async_trait;
use std::sync::Arc;

use crate::call::domain::CallCommand;
use crate::call::domain::MediaRuntimeProfile;
use crate::proxy::active_call_registry::ActiveProxyCallRegistry;

use super::{CommandExecutor, CommandResult, ExecutionContext, MediaCapabilityCheck};

/// Executor that bridges to the SipSession runtime
pub struct SessionActionExecutor {
    registry: Arc<ActiveProxyCallRegistry>,
}

impl SessionActionExecutor {
    pub fn new(registry: Arc<ActiveProxyCallRegistry>) -> Self {
        Self { registry }
    }

    /// Apply a CallCommand to a session via SipSessionHandle
    fn apply_command(
        &self,
        session_id: &str,
        command: CallCommand,
    ) -> anyhow::Result<CommandResult> {
        // Get the session handle from registry
        let Some(handle) = self.registry.get_handle(session_id) else {
            return Ok(CommandResult::failure(format!(
                "session {} not found",
                session_id
            )));
        };

        // Send the command directly to SipSessionHandle
        match handle.send_command(command) {
            Ok(_) => Ok(CommandResult::success()),
            Err(e) => Ok(CommandResult::failure(format!(
                "failed to apply command: {}",
                e
            ))),
        }
    }
}

#[async_trait]
impl CommandExecutor for SessionActionExecutor {
    async fn execute(
        &self,
        ctx: ExecutionContext,
        command: CallCommand,
    ) -> anyhow::Result<CommandResult> {
        // Step 1: Check media capabilities
        match ctx.check_media_capability(&command) {
            MediaCapabilityCheck::Denied { reason } => {
                // Command cannot be executed due to capability limitations
                return Ok(CommandResult::not_supported(reason));
            }
            MediaCapabilityCheck::Degraded { reason } => {
                // Command can execute but with degraded functionality
                // For now, we still try to execute but return degraded result
                let _ = reason; // Acknowledge for now
            }
            MediaCapabilityCheck::Allowed => {
                // Command can execute fully
            }
        }

        // Step 2: Send command directly to SipSessionHandle
        self.apply_command(&ctx.session_id, command)
    }

    async fn session_exists(&self, session_id: &str) -> bool {
        self.registry.get_handle(session_id).is_some()
    }

    async fn get_media_profile(&self, _session_id: &str) -> Option<MediaRuntimeProfile> {
        // For now, return default profile (Anchored)
        // TODO: Get actual media path mode from session state
        Some(MediaRuntimeProfile::default())
    }
}

#[cfg(test)]
mod tests {
    // Note: Integration tests for SessionActionExecutor require a full test setup
    // with ActiveProxyCallRegistry and SipSession. These are tested in the
    // integration_tests module.
    //
    // Unit tests for command conversion are in session_action_bridge.rs
}