dagrs 0.8.1

Dagrs follows the concept of Flow-based Programming and is suitable for the execution of multiple tasks with graph-like dependencies. Dagrs has the characteristics of high performance and asynchronous execution. It provides users with a convenient programming interface.
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

use std::sync::Arc;

use async_trait::async_trait;

use crate::{
    EnvVar, InChannels, OutChannels, Output,
    action::Action,
    connection::{in_channel::TypedInChannels, out_channel::TypedOutChannels},
};

/// A trait that provides typed channel operations
///
/// This trait allows actions to use typed input and output channels instead of raw channel types.
/// Through generic parameters `I` and `O`, specific types can be specified for input and output channels,
/// providing compile-time type checking.
///
/// # Type Parameters
///
/// * `I` - The type parameter for input channels, must satisfy `Send + Sync + 'static`
/// * `O` - The type parameter for output channels, must satisfy `Send + Sync + 'static`
/// When both `I` and `O` are set to `Content`, this trait degenerates to the base `Action` trait.
#[async_trait]
pub trait TypedAction: Send + Sync {
    /// The type parameter for input channels
    type I: Send + Sync + 'static;
    /// The type parameter for output channels
    type O: Send + Sync + 'static;

    /// Converts raw input channels to typed input channels
    ///
    /// # Arguments
    ///
    /// * `in_channels` - The raw input channels
    ///
    /// # Returns
    ///
    /// Returns a typed input channel with the type specified by the associated type `I`
    fn make_typed_in_channels(&self, in_channels: &InChannels) -> TypedInChannels<Self::I> {
        TypedInChannels(
            in_channels.0.clone(),
            in_channels.1.clone(),
            Default::default(),
        )
    }

    /// Converts raw output channels to typed output channels
    ///
    /// # Arguments
    ///
    /// * `out_channels` - The raw output channels
    ///
    /// # Returns
    ///
    /// Returns a typed output channel with the type specified by the associated type `O`
    fn make_typed_out_channels(&self, out_channels: &OutChannels) -> TypedOutChannels<Self::O> {
        TypedOutChannels(out_channels.0.clone(), Default::default())
    }

    /// The method that users need to implement to define their action logic
    ///
    /// This is the main method of the trait, used to execute the specific action logic.
    /// It receives typed input and output channels, along with environment variables,
    /// and returns the execution result.
    ///
    /// # Arguments
    ///
    /// * `in_channels` - The typed input channels
    /// * `out_channels` - The typed output channels
    /// * `env` - The environment variables
    ///
    /// # Returns
    ///
    /// Returns the result of the action execution
    async fn run(
        &self,
        in_channels: TypedInChannels<Self::I>,
        out_channels: TypedOutChannels<Self::O>,
        env: Arc<EnvVar>,
    ) -> Output;
}

#[async_trait]
impl<T: TypedAction> Action for T {
    async fn run(
        &self,
        in_channels: &mut InChannels,
        out_channels: &mut OutChannels,
        env: Arc<EnvVar>,
    ) -> Output {
        let in_channels = self.make_typed_in_channels(in_channels);
        let out_channels = self.make_typed_out_channels(out_channels);
        self.run(in_channels, out_channels, env).await
    }
}