lash-core 0.1.0-alpha.90

Sans-IO turn machine and runtime kernel for the lash agent runtime.
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

use serde::{Deserialize, Serialize};

use super::model::{ProcessExecutionEnvRef, ProcessRecord};

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProcessLiveReferenceSummary {
    pub definition: Option<serde_json::Value>,
    pub env_ref: Option<ProcessExecutionEnvRef>,
    pub process_count: usize,
}

impl ProcessLiveReferenceSummary {
    pub fn from_records<'record>(
        records: impl IntoIterator<Item = &'record ProcessRecord>,
    ) -> Vec<Self> {
        let mut summaries: Vec<Self> = Vec::new();
        for record in records {
            if record.is_terminal() {
                continue;
            }
            if let Some(summary) = summaries.iter_mut().find(|summary| {
                summary.definition == record.identity.definition
                    && summary.env_ref == record.env_ref
            }) {
                summary.process_count += 1;
            } else {
                summaries.push(Self {
                    definition: record.identity.definition.clone(),
                    env_ref: record.env_ref.clone(),
                    process_count: 1,
                });
            }
        }
        summaries.sort_by_key(live_reference_sort_key);
        summaries
    }
}

fn live_reference_sort_key(summary: &ProcessLiveReferenceSummary) -> (String, String) {
    let definition = summary
        .definition
        .as_ref()
        .map(|definition| serde_json::to_string(definition).expect("definition serializes"))
        .unwrap_or_default();
    let env_ref = summary
        .env_ref
        .as_ref()
        .map(|env_ref| env_ref.as_str().to_string())
        .unwrap_or_default();
    (definition, env_ref)
}