a3s-box-sdk 3.0.10

Rust SDK for a3s-box direct runtime-backed management APIs.
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

impl A3sBoxClient {
    /// Persist an unstarted execution through the canonical lifecycle facade.
    pub async fn create_box(
        &self,
        request: CreateExecutionRequest,
        operation_id: &OperationId,
    ) -> Result<ExecutionReservation> {
        Ok(self.execution_manager.create(request, operation_id).await?)
    }

    /// Start a previously created execution with generation fencing.
    pub async fn start_box(
        &self,
        execution_id: &ExecutionId,
        generation: ExecutionGeneration,
    ) -> Result<ExecutionLease> {
        Ok(self
            .execution_manager
            .start(execution_id, generation)
            .await?)
    }

    /// Atomically create or recover and then start an execution.
    pub async fn run_box(
        &self,
        request: CreateExecutionRequest,
        operation_id: &OperationId,
    ) -> Result<ExecutionLease> {
        Ok(self
            .execution_manager
            .create_and_start(request, operation_id)
            .await?)
    }

    /// Inspect the generation-fenced state of a managed execution.
    pub async fn inspect_execution(&self, execution_id: &ExecutionId) -> Result<ExecutionStatus> {
        Ok(self.execution_manager.inspect(execution_id).await?)
    }

    /// Pause a managed execution through its resolved backend.
    pub async fn pause_execution(
        &self,
        execution_id: &ExecutionId,
        generation: ExecutionGeneration,
        keep_memory: bool,
    ) -> Result<ExecutionLease> {
        Ok(self
            .execution_manager
            .pause(execution_id, generation, keep_memory)
            .await?)
    }

    /// Resume a managed execution through its resolved backend.
    pub async fn resume_execution(
        &self,
        execution_id: &ExecutionId,
        generation: ExecutionGeneration,
    ) -> Result<ExecutionLease> {
        Ok(self
            .execution_manager
            .resume(execution_id, generation)
            .await?)
    }

    /// Restart a managed execution under an idempotent operation identity.
    pub async fn restart_execution(
        &self,
        execution_id: &ExecutionId,
        generation: ExecutionGeneration,
        operation_id: &OperationId,
        options: RestartExecutionOptions,
    ) -> Result<ExecutionLease> {
        Ok(self
            .execution_manager
            .restart_with_options(execution_id, generation, operation_id, options)
            .await?)
    }

    /// Kill a managed execution and release runtime-owned resources.
    pub async fn kill_execution(
        &self,
        execution_id: &ExecutionId,
        generation: ExecutionGeneration,
    ) -> Result<KillOutcome> {
        Ok(self
            .execution_manager
            .kill(execution_id, generation)
            .await?)
    }

    /// Reconcile one idempotent create operation after caller or service restart.
    pub async fn reconcile_operation(
        &self,
        operation_id: &OperationId,
    ) -> Result<ReconcileOutcome> {
        Ok(self.execution_manager.reconcile(operation_id).await?)
    }
}