onlyne-client 2.0.0

Onlyne client: role runtime, dispatch, intent, adapter socket
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

use super::*;
use std::collections::{HashMap, HashSet};
use std::sync::{Arc, Mutex};

#[derive(Clone, Default)]
pub struct FakeBackend {
    state: Arc<Mutex<HashMap<String, SessionRef>>>,
    failed_probes: Arc<Mutex<HashSet<String>>>,
    pub fail_available: bool,
}

impl FakeBackend {
    pub fn new() -> Self {
        Self::default()
    }

    fn guard<'a, T>(
        mutex: &'a Mutex<T>,
        task_id: &str,
        what: &str,
    ) -> Result<std::sync::MutexGuard<'a, T>> {
        mutex
            .lock()
            .map_err(|_| anyhow::anyhow!("fake {what} lock poisoned for task {task_id}"))
    }

    pub fn sessions(&self) -> HashMap<String, SessionRef> {
        Self::guard(&self.state, "<sessions>", "state")
            .unwrap_or_else(|err| panic!("{err}"))
            .clone()
    }

    /// Force probes for one task to report a dead backend resource.
    pub fn fail_probe(&self, task_id: &str) {
        Self::guard(&self.failed_probes, task_id, "failed_probes")
            .unwrap_or_else(|err| panic!("{err}"))
            .insert(task_id.to_owned());
    }

    /// Clear a forced probe failure for one task.
    pub fn clear_probe_failure(&self, task_id: &str) {
        Self::guard(&self.failed_probes, task_id, "failed_probes")
            .unwrap_or_else(|err| panic!("{err}"))
            .remove(task_id);
    }
}

impl SessionBackend for FakeBackend {
    fn name(&self) -> &'static str {
        "fake"
    }
    fn capabilities(&self) -> Capabilities {
        Capabilities {
            spawn: true,
            attach: true,
            probe: true,
            close: true,
            focus: true,
            rename: true,
        }
    }
    fn available(&self) -> Result<bool> {
        Ok(!self.fail_available)
    }
    fn spawn(&self, spec: SpawnSpec) -> Result<SessionRef> {
        let session = SessionRef {
            task_id: spec.task_id.clone(),
            backend: self.name().into(),
            backend_ref: serde_json::json!({"id": spec.task_id}),
            generation: 1,
        };
        Self::guard(&self.state, &session.task_id, "state")?.insert(spec.task_id, session.clone());
        Ok(session)
    }
    fn attach(&self, session: &SessionRef) -> Result<SessionRef> {
        if Self::guard(&self.state, &session.task_id, "state")?.contains_key(&session.task_id) {
            Ok(session.clone())
        } else {
            anyhow::bail!("fake session not found: {}", session.task_id)
        }
    }
    fn probe(&self, session: &SessionRef) -> Result<ResourceProbe> {
        let failed = Self::guard(&self.failed_probes, &session.task_id, "failed_probes")?
            .contains(&session.task_id);
        Ok(ResourceProbe {
            alive: !failed
                && Self::guard(&self.state, &session.task_id, "state")?
                    .contains_key(&session.task_id),
            attached: !failed,
            detail: failed.then(|| serde_json::json!({"forced": "probe_failure"})),
        })
    }
    fn close(&self, session: &SessionRef, _reason: CloseReason, _force: bool) -> Result<()> {
        Self::guard(&self.state, &session.task_id, "state")?.remove(&session.task_id);
        Ok(())
    }
}