mikros 0.3.0

An optionated crate to help building multi-purpose applications.
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

use std::collections::HashMap;
use std::sync::Arc;

use tokio::sync::watch;

use crate::service::context::Context;
use crate::service::lifecycle::Lifecycle;
use crate::{definition, env, errors};

/// Service is a set of methods that every new kind of service must implement
/// to be supported by the framework.
#[async_trait::async_trait]
pub trait Service: ServiceClone + Lifecycle {
    /// The new service kind. Usually the ServiceKind::Custom should be used
    /// for new services implementation.
    fn kind(&self) -> definition::ServiceKind;

    /// Returns internal information about the service implementation to be
    /// logged when the service is being initialized.
    fn info(&self) -> serde_json::Value;

    /// Defines which type of execution the service implementation uses.
    fn mode(&self) -> ServiceExecutionMode;

    /// Initializes everything that the service implementation needs to run.
    fn initialize(
        &mut self,
        ctx: Arc<Context>,
        definitions: Arc<definition::Definitions>,
        envs: Arc<env::Env>,
        options: HashMap<String, serde_json::Value>,
    ) -> errors::Result<()>;

    /// Puts the service implementation to run.
    async fn run(&mut self, ctx: Arc<Context>, shutdown_rx: watch::Receiver<()>) -> errors::Result<()>;

    /// Stops the current service implementation. The place to let the service
    /// execute its graceful shutdown.
    async fn stop(&self, ctx: Arc<Context>);
}

pub trait ServiceClone {
    fn clone_box(&self) -> Box<dyn Service>;
}

impl<T> ServiceClone for T
where
    T: 'static + Service + Clone,
{
    fn clone_box(&self) -> Box<dyn Service> {
        Box::new(self.clone())
    }
}

impl Clone for Box<dyn Service> {
    fn clone(&self) -> Self {
        ServiceClone::clone_box(self.as_ref())
    }
}

#[derive(PartialEq)]
pub enum ServiceExecutionMode {
    Block,
    NonBlock,
}