arcbox-agent 0.6.3

Guest agent for ArcBox VMs
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

//! Sandbox checkpoint / restore handlers.

use arcbox_connect::sandbox_v1;
use arcbox_vm::{RestoreSandboxSpec, SandboxState};
use buffa::Message;

use super::{SandboxService, convert, register_sandbox_dns};
use crate::error::SandboxError;

impl SandboxService {
    /// Checkpoint a sandbox.
    pub async fn checkpoint(
        &self,
        payload: &[u8],
    ) -> Result<sandbox_v1::CheckpointResponse, SandboxError> {
        let req = sandbox_v1::CheckpointRequest::decode_from_slice(payload)
            .map_err(|e| SandboxError::Decode(e.to_string()))?;
        let _operation = self.operations.lock(&req.sandbox_id).await;
        let info = self
            .manager
            .checkpoint_sandbox(&req.sandbox_id, req.name, req.labels.into_iter().collect())
            .await
            .map_err(SandboxError::from)?;
        Ok(convert::checkpoint_to_proto(info))
    }

    /// Restore a sandbox from a snapshot.
    pub async fn restore(
        &self,
        payload: &[u8],
    ) -> Result<sandbox_v1::RestoreResponse, SandboxError> {
        let req = sandbox_v1::RestoreRequest::decode_from_slice(payload)
            .map_err(|e| SandboxError::Decode(e.to_string()))?;
        self.manager.wait_startup_cleanup_complete().await;
        let _operation = self.operations.lock(&req.id).await;
        let restore_key = crate::create_key::restore_key(&req);
        if !req.id.is_empty() {
            self.clear_stale_completed_create(&req.id);
        }
        let spec = RestoreSandboxSpec {
            id: if req.id.is_empty() {
                None
            } else {
                Some(req.id)
            },
            snapshot_id: req.snapshot_id,
            labels: req.labels.into_iter().collect(),
            network_override: req.network_override,
            ttl_seconds: req.ttl_seconds,
        };
        let (id, ip_address) = self
            .manager
            .restore_sandbox_keyed(spec, &restore_key)
            .await
            .map_err(SandboxError::from)?;
        let live = self.manager.inspect_sandbox(&id).is_ok_and(|info| {
            matches!(
                info.state,
                SandboxState::Starting | SandboxState::Ready | SandboxState::Running
            ) && info
                .network
                .is_some_and(|network| network.ip_address == ip_address)
        });
        if live {
            register_sandbox_dns(&id, &ip_address);
        }
        Ok(sandbox_v1::RestoreResponse {
            id,
            ip_address,
            ..Default::default()
        })
    }

    /// List snapshots (id-ordered, paginated).
    pub fn list_snapshots(
        &self,
        payload: &[u8],
    ) -> Result<sandbox_v1::ListSnapshotsResponse, SandboxError> {
        let req = sandbox_v1::ListSnapshotsRequest::decode_from_slice(payload)
            .map_err(|e| SandboxError::Decode(e.to_string()))?;
        let filter = if req.sandbox_id.is_empty() {
            None
        } else {
            Some(req.sandbox_id.as_str())
        };
        let mut summaries = self
            .manager
            .list_checkpoints(filter)
            .map_err(SandboxError::from)?;
        // Label filter: every requested pair must match, mirroring List.
        // The manager only filters by origin sandbox, so apply it here
        // rather than silently returning unrelated snapshots.
        if !req.labels.is_empty() {
            summaries.retain(|s| {
                req.labels
                    .iter()
                    .all(|(key, value)| s.labels.get(key) == Some(value))
            });
        }
        let (page, next_page_token) =
            convert::paginate(summaries, |s| &s.id, req.page_size, &req.page_token);
        Ok(sandbox_v1::ListSnapshotsResponse {
            snapshots: page
                .into_iter()
                .map(convert::checkpoint_summary_to_proto)
                .collect(),
            next_page_token,
            ..Default::default()
        })
    }

    /// Delete a snapshot.
    pub fn delete_snapshot(&self, payload: &[u8]) -> Result<(), SandboxError> {
        let req = sandbox_v1::DeleteSnapshotRequest::decode_from_slice(payload)
            .map_err(|e| SandboxError::Decode(e.to_string()))?;
        self.manager
            .delete_checkpoint(&req.snapshot_id)
            .map_err(SandboxError::from)
    }
}