mycelium-api 8.3.1-rc.1

Provide API ports to the mycelium project.
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

use myc_core::domain::dtos::callback::{
    CallbackContext, CallbackError, CallbackExecutor,
};
use shaku::Component;
use std::path::PathBuf;
use tokio::process::Command;

#[derive(Component)]
#[shaku(interface = CallbackExecutor)]
pub struct PythonCallback {
    script_path: PathBuf,
    python_path: String,
    timeout_ms: u64,
    name: String,
}

impl PythonCallback {
    pub fn new(
        script_path: impl Into<PathBuf>,
        python_path: Option<String>,
        timeout_ms: Option<u64>,
    ) -> Result<Self, CallbackError> {
        let script_path = script_path.into();

        if !script_path.exists() {
            return Err(CallbackError::ConfigError(format!(
                "Script not found: {}",
                script_path.display()
            )));
        }

        let name = script_path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("unknown")
            .to_string();

        Ok(Self {
            script_path,
            python_path: python_path.unwrap_or_else(|| "python3".to_string()),
            timeout_ms: timeout_ms.unwrap_or(5000),
            name,
        })
    }
}

#[async_trait::async_trait]
impl CallbackExecutor for PythonCallback {
    async fn execute(
        &self,
        context: &CallbackContext,
    ) -> Result<(), CallbackError> {
        let context_json = serde_json::to_string(context).map_err(|e| {
            CallbackError::ScriptError(format!(
                "Failed to serialize context: {}",
                e
            ))
        })?;

        let output = tokio::time::timeout(
            std::time::Duration::from_millis(self.timeout_ms),
            Command::new(&self.python_path)
                .arg(&self.script_path)
                .arg("--context")
                .arg(&context_json)
                .output(),
        )
        .await
        .map_err(|_| {
            CallbackError::ScriptError("Script execution timeout".into())
        })?
        .map_err(|e| {
            CallbackError::ScriptError(format!(
                "Failed to execute python: {}",
                e
            ))
        })?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(CallbackError::ScriptError(format!(
                "Script failed: {}",
                stderr
            )));
        }

        if !output.stdout.is_empty() {
            let stdout = String::from_utf8_lossy(&output.stdout);
            tracing::debug!("Script output: {}", stdout);
        }

        Ok(())
    }

    fn name(&self) -> &str {
        &self.name
    }
}