ops-rs 1.63.594

A Rust ops framework with composable wrappers and batch 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

use crate::{BatchOp, DryContext, Op, OpMetadata, OpResult, WetContext};
use async_trait::async_trait;
use std::sync::Arc;

pub mod predicates;
pub use predicates::*;
pub mod registry;
pub use registry::*;
pub mod engine;
pub use engine::*;

#[async_trait]
pub trait Trigger: Send + Sync {
    fn name(&self) -> String;

    fn predicate(&self) -> Arc<dyn Op<bool>>;
    fn actions(&self) -> Vec<Arc<dyn Op<()>>>;

    async fn perform(&self, dry: &mut DryContext, wet: &mut WetContext) -> OpResult<()> {
        let should = self.predicate().perform(dry, wet).await?;
        if should {
            let batch = BatchOp::new(self.actions());
            batch.perform(dry, wet).await?;
        }
        Ok(())
    }

    fn metadata(&self) -> OpMetadata {
        OpMetadata {
            name: format!(
                "Trigger {} with {} actions",
                self.name(),
                self.actions().len()
            ),
            description: None,
            input_schema: None,
            reference_schema: None,
            output_schema: None,
        }
    }
}

#[async_trait]
impl<T> Op<()> for T
where
    T: Trigger,
{
    async fn perform(&self, dry: &mut DryContext, wet: &mut WetContext) -> OpResult<()> {
        self.perform(dry, wet).await
    }

    fn metadata(&self) -> OpMetadata {
        self.metadata()
    }
}