harn-vm 0.7.52

Async bytecode virtual machine for the Harn programming language
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

use std::rc::Rc;
use std::time::Duration;

use crate::value::VmClosure;

#[derive(Clone)]
pub struct TriggerExpressionSpec {
    pub raw: String,
    pub closure: Rc<VmClosure>,
}

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

#[derive(Clone, Debug)]
pub struct TriggerConcurrencyConfig {
    pub key: Option<TriggerExpressionSpec>,
    pub max: u32,
}

#[derive(Clone, Debug)]
pub struct TriggerThrottleConfig {
    pub key: Option<TriggerExpressionSpec>,
    pub period: Duration,
    pub max: u32,
}

#[derive(Clone, Debug)]
pub struct TriggerRateLimitConfig {
    pub key: Option<TriggerExpressionSpec>,
    pub period: Duration,
    pub max: u32,
}

#[derive(Clone, Debug)]
pub struct TriggerDebounceConfig {
    pub key: TriggerExpressionSpec,
    pub period: Duration,
}

#[derive(Clone, Debug)]
pub struct TriggerSingletonConfig {
    pub key: Option<TriggerExpressionSpec>,
}

#[derive(Clone, Debug)]
pub struct TriggerBatchConfig {
    pub key: Option<TriggerExpressionSpec>,
    pub size: u32,
    pub timeout: Duration,
}

#[derive(Clone, Debug)]
pub struct TriggerPriorityOrderConfig {
    pub key: TriggerExpressionSpec,
    pub order: Vec<String>,
}

#[derive(Clone, Debug, Default)]
pub struct TriggerFlowControlConfig {
    pub concurrency: Option<TriggerConcurrencyConfig>,
    pub throttle: Option<TriggerThrottleConfig>,
    pub rate_limit: Option<TriggerRateLimitConfig>,
    pub debounce: Option<TriggerDebounceConfig>,
    pub singleton: Option<TriggerSingletonConfig>,
    pub batch: Option<TriggerBatchConfig>,
    pub priority: Option<TriggerPriorityOrderConfig>,
}

pub fn parse_flow_control_duration(raw: &str) -> Result<Duration, String> {
    let trimmed = raw.trim();
    if trimmed.len() < 2 {
        return Err(format!("invalid duration '{raw}': expected <int><unit>"));
    }
    let split = trimmed
        .find(|ch: char| !ch.is_ascii_digit())
        .ok_or_else(|| format!("invalid duration '{raw}': missing unit suffix"))?;
    if split == 0 || split == trimmed.len() {
        return Err(format!("invalid duration '{raw}': expected <int><unit>"));
    }
    let value = trimmed[..split]
        .parse::<u64>()
        .map_err(|_| format!("invalid duration '{raw}': expected integer prefix"))?;
    if value == 0 {
        return Err(format!(
            "invalid duration '{raw}': duration must be positive"
        ));
    }
    let factor = match trimmed[split..].to_ascii_lowercase().as_str() {
        "s" => 1,
        "m" => 60,
        "h" => 60 * 60,
        "d" => 60 * 60 * 24,
        "w" => 60 * 60 * 24 * 7,
        other => {
            return Err(format!(
                "invalid duration '{raw}': unsupported unit '{other}', expected s/m/h/d/w"
            ))
        }
    };
    Ok(Duration::from_secs(value.saturating_mul(factor)))
}