fleche 6.19.1

Remote job runner for Slurm clusters
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

//! Runtime helpers shared across command handlers.

use crate::config::Settings;
use crate::ssh::SshClient;
use std::io::Write;

/// SSH timeout settings in seconds.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SshTimeouts {
    /// Maximum time for a command to complete.
    pub exec_timeout_secs: u64,
    /// Maximum time to establish the SSH connection.
    pub connect_timeout_secs: u64,
}

/// Extracts SSH timeout settings from config settings.
pub fn ssh_timeouts_from_settings(settings: &Settings) -> SshTimeouts {
    SshTimeouts {
        exec_timeout_secs: settings.ssh_timeout_secs,
        connect_timeout_secs: settings.ssh_connect_timeout_secs,
    }
}

/// Notification behavior policy.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum NotifyPolicy {
    /// Only notify when a command explicitly asks for notifications.
    #[default]
    CliFlagOnly,
    /// Always notify on terminal states.
    Always,
    /// Never notify.
    Never,
}

/// Shared runtime settings used by command handlers.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RuntimeCtx {
    /// Enable verbose SSH output.
    pub debug: bool,
    /// SSH timeout settings to apply when creating clients.
    pub ssh_timeouts: Option<SshTimeouts>,
    /// Poll interval in seconds when waiting for local jobs.
    pub poll_interval_local_secs: u64,
    /// Poll interval in seconds when waiting for remote jobs.
    pub poll_interval_remote_secs: u64,
    /// Base delay in seconds for exponential retry backoff.
    pub retry_base_delay_secs: u64,
    /// Default notification policy.
    pub notify_policy: NotifyPolicy,
}

impl Default for RuntimeCtx {
    fn default() -> Self {
        Self::from_optional_settings(false, None)
    }
}

impl RuntimeCtx {
    /// Builds a runtime context from project settings.
    pub fn from_settings(debug: bool, settings: &Settings) -> Self {
        let notify_policy = match std::env::var("FLECHE_NOTIFY_POLICY").ok().as_deref() {
            Some("always") => NotifyPolicy::Always,
            Some("never") => NotifyPolicy::Never,
            _ => NotifyPolicy::CliFlagOnly,
        };

        Self {
            debug,
            ssh_timeouts: Some(ssh_timeouts_from_settings(settings)),
            poll_interval_local_secs: settings.poll_interval_local_secs,
            poll_interval_remote_secs: settings.poll_interval_remote_secs,
            retry_base_delay_secs: settings.retry_base_delay_secs,
            notify_policy,
        }
    }

    /// Builds a runtime context with optional project settings.
    ///
    /// If `settings` is `None`, default settings are used.
    pub fn from_optional_settings(debug: bool, settings: Option<&Settings>) -> Self {
        if let Some(settings) = settings {
            Self::from_settings(debug, settings)
        } else {
            Self::from_settings(debug, &Settings::default())
        }
    }

    /// Creates an SSH client for a host using this context.
    pub fn ssh(&self, host: &str) -> SshClient {
        ssh_client(host, self.debug, self.ssh_timeouts)
    }

    /// Resolves whether notification should be sent for this event.
    pub fn should_notify(&self, requested: bool) -> bool {
        match self.notify_policy {
            NotifyPolicy::CliFlagOnly => requested,
            NotifyPolicy::Always => true,
            NotifyPolicy::Never => false,
        }
    }
}

/// Creates an SSH client with optional configured timeouts.
pub fn ssh_client(host: &str, debug: bool, timeouts: Option<SshTimeouts>) -> SshClient {
    if let Some(timeouts) = timeouts {
        SshClient::with_timeouts(
            host,
            debug,
            timeouts.exec_timeout_secs,
            timeouts.connect_timeout_secs,
        )
    } else {
        SshClient::new(host, debug)
    }
}

/// Sends a terminal notification using OSC 9.
pub fn send_notification(message: &str) {
    if std::env::var_os("TMUX").is_some() {
        print!("\x1bPtmux;\x1b\x1b]9;fleche: {message}\x07\x1b\\");
    } else {
        print!("\x1b]9;fleche: {message}\x07");
    }
    let _ = std::io::stdout().flush();
}