harmos-domain 0.1.5

Harmos domain model: identifiers, contracts, catalogs and storage identities.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

/* ***
 *
 * Harmos
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ***
 */

/* === Modules === */

/* === Re-Exports === */

/* === Imports === */

// Standard Library Imports

// Third Party Imports

// Local Imports
use super::{Cancel, InstanceState, Status, Watch};
use crate::operations::instance::{self, Id, Outcome, Phase};
use crate::operations::{OperationPolicy, Visibility};

/* === Constants === */

// A watch lasts until its instance settles or the caller cancels it.
const WATCH_POLICY: OperationPolicy = OperationPolicy {
    timeout: crate::operations::UNBOUNDED,
    attempt_timeout: crate::operations::UNBOUNDED,
    ..crate::operations::host::POLICY
};

/* === Macros === */

crate::declare!(Status {
    id: "host.operations.status",
    version: 1,
    policy: crate::operations::host::POLICY,
    response: InstanceState,
    description: "Report the status of an operation instance the caller submitted",
    visibility: Visibility::Shared,
    grpc: ("harmos.host.v1", "Operations", "Status"),
});

crate::declare!(Cancel {
    id: "host.operations.cancel",
    version: 1,
    policy: crate::operations::host::POLICY,
    response: InstanceState,
    description: "Request cancellation of an operation instance the caller submitted",
    visibility: Visibility::Shared,
    grpc: ("harmos.host.v1", "Operations", "Cancel"),
});

crate::declare!(Watch {
    id: "host.operations.watch",
    version: 1,
    policy: WATCH_POLICY,
    response: InstanceState,
    output: InstanceState,
    description: "Stream the status changes of an operation instance the caller submitted until it settles",
    visibility: Visibility::Shared,
    grpc: ("harmos.host.v1", "Operations", "Watch"),
});

/* === Type Aliases === */

/* === Structs === */

/* === Enums === */

/* === Traits === */

/* === Implementations === */

impl Status {
    pub fn of(instance: Id) -> Self {
        Self { instance: instance.value() }
    }
}

impl Watch {
    pub fn of(instance: Id) -> Self {
        Self { instance: instance.value() }
    }
}

impl Cancel {
    pub fn of(instance: Id) -> Self {
        Self { instance: instance.value() }
    }
}

impl From<instance::Status> for InstanceState {
    fn from(status: instance::Status) -> Self {
        Self {
            phase: status.phase.as_str().to_owned(),
            outcome: status.outcome.map(Outcome::as_str).unwrap_or_default().to_owned(),
            cancellation_requested: status.cancellation_requested,
            attempt: status.attempt,
        }
    }
}

impl TryFrom<&InstanceState> for instance::Status {
    type Error = instance::ParseError;

    fn try_from(state: &InstanceState) -> Result<Self, Self::Error> {
        let phase = state.phase.parse::<Phase>()?;
        let outcome = match state.outcome.as_str() {
            "" => None,
            outcome => Some(outcome.parse::<Outcome>()?),
        };
        Ok(Self { phase, outcome, cancellation_requested: state.cancellation_requested, attempt: state.attempt })
    }
}

/* === Public Functions === */

/* === Private Functions === */

/* === Tests === */