malstrom 0.1.0

Malstrom is a distributed, stateful stream processing framework written in Rust.
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

use crate::{
    runtime::OperatorOperatorComm,
    types::{OperatorId, WorkerId},
};

use super::{traits::Operator, BuildContext, OperatorContext};

pub struct RunnableOperator {
    worker_id: WorkerId,
    operator_id: OperatorId,
    operator: Box<dyn Operator>,
    name: String,
}

impl RunnableOperator {
    pub fn new(operator: impl Operator + 'static, context: &mut BuildContext) -> Self {
        RunnableOperator {
            worker_id: context.worker_id,
            operator_id: context.operator_id,
            operator: Box::new(operator),
            name: context.operator_name.clone(),
        }
    }

    pub fn step(&mut self, communication: &mut dyn OperatorOperatorComm) {
        let mut context = OperatorContext {
            worker_id: self.worker_id,
            operator_id: self.operator_id,
            communication,
        };
        self.operator.step(&mut context)
    }
    pub fn has_queued_work(&self) -> bool {
        self.operator.has_queued_work()
    }

    /// check if this operator will ever emit a message again
    pub fn is_finalized(&self) -> bool {
        self.operator.is_finalized()
    }

    pub(crate) fn is_suspended(&self) -> bool {
        self.operator.is_suspended()
    }

    pub(crate) fn name(&self) -> &str {
        &self.name
    }
}