harmos-operations 0.1.8

Portable Harmos built-in operations and optional execution.
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

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

/* === Modules === */

mod cancel;
mod initialize;
mod shutdown;
mod status;
mod watch;

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

pub use cancel::Cancel;
pub use harmos_domain::model::operations::lifecycle::*;
#[cfg(feature = "lifecycle")]
pub use initialize::ControlError;
pub use initialize::Initialize;
pub use shutdown::Shutdown;
pub use status::{InstanceState, Status};
pub use watch::Watch;

/* === Imports === */

/* === Constants === */

pub const POLICY: harmos_domain::OperationPolicy = harmos_domain::OperationPolicy {
    timeout: std::time::Duration::from_secs(30),
    attempt_timeout: std::time::Duration::from_secs(30),
    retries: harmos_domain::RetryPolicy::Never,
};
const WATCH_POLICY: harmos_domain::OperationPolicy = harmos_domain::OperationPolicy {
    timeout: harmos_domain::operations::UNBOUNDED,
    attempt_timeout: harmos_domain::operations::UNBOUNDED,
    ..POLICY
};

/* === Macros === */

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

/* === Structs === */

/* === Enums === */

#[harmos::catalog(harmos_path = crate)]
pub enum Lifecycle {
    Status(Status),
    Cancel(Cancel),
    Watch(Watch),
}

#[cfg(feature = "lifecycle")]
pub fn bind<P: harmos_sdk::Plugin>(
    owner: std::sync::Arc<harmos_sdk::plugin::Owner<P>>, table: &harmos_sdk::plugin::Table,
) -> Result<(), harmos_sdk::plugin::Error<P>> {
    use harmos_sdk::operations::lifecycle::LifecycleAccess;
    let mut dependencies = harmos_sdk::Dependencies::new();
    dependencies
        .insert(std::sync::Arc::new(LifecycleAccess(owner)))
        .map_err(|error| harmos_sdk::plugin::Error::Resource(std::sync::Arc::new(error)))?;
    let mut table = table.lock().map_err(|_| harmos_sdk::plugin::Error::Poisoned)?;
    let initialize = Descriptor::of_initialize::<P>()
        .map_err(harmos_sdk::ServingError::from)
        .map_err(|error| harmos_sdk::plugin::Error::Serving(std::sync::Arc::new(error)))?;
    let shutdown = Descriptor::of_shutdown::<P>()
        .map_err(harmos_sdk::ServingError::from)
        .map_err(|error| harmos_sdk::plugin::Error::Serving(std::sync::Arc::new(error)))?;
    table
        .install_lifecycle::<Initialize, initialize::Control>(dependencies.clone(), initialize)
        .map_err(|error| harmos_sdk::plugin::Error::Serving(std::sync::Arc::new(error)))?;
    table
        .install_lifecycle::<Shutdown, shutdown::Control>(dependencies, shutdown)
        .map_err(|error| harmos_sdk::plugin::Error::Serving(std::sync::Arc::new(error)))
}

/* === Traits === */

/* === Implementations === */

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

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

/* === Tests === */