aion-rs 0.10.0

Transport-agnostic Aion workflow engine with durability, replay, timers, and supervision.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Test-only helpers for runtime-backed activity modules.

use beamr::loader::Instruction;
use beamr::loader::decode::compact::Operand;
use beamr::module::{Module, ResolvedImport, ResolvedImportTarget};
use beamr::term::Term;

use super::{EngineError, Mfa, NifRegistration, RuntimeHandle, RuntimeInput};

impl RuntimeInput {
    pub(crate) fn from_payloads_for_test(
        payloads: &[aion_core::Payload],
    ) -> Result<Self, EngineError> {
        let mut combined = Self::default();
        for payload in payloads {
            let input = Self::from_payload(payload)?;
            combined.terms.extend(input.terms);
            combined.heaps.extend(input.heaps);
        }
        Ok(combined)
    }
}

impl RuntimeHandle {
    pub(crate) fn install_test_activity_nif(
        &self,
        module: &str,
        function: &str,
        dirty: bool,
        succeeds: bool,
    ) -> Result<(), EngineError> {
        let mut registration = NifRegistration::new();
        let native = if succeeds {
            test_activity_answer
        } else {
            test_activity_fail
        };
        let entry = if dirty {
            super::super::nif::NifEntry::dirty(Mfa::new(module, function, 1), native)
        } else {
            super::super::nif::NifEntry::new(Mfa::new(module, function, 1), native)
        };
        registration.add_host_nifs([entry]);
        self.install_nifs(registration)
    }

    pub(crate) fn register_native_call_module_for_test(
        &self,
        module_name: &str,
        function_name: &str,
        native_module: &str,
        native_function: &str,
    ) {
        let module = self.atom_table.intern(module_name);
        let function = self.atom_table.intern(function_name);
        let target_module = self.atom_table.intern(native_module);
        let target_function = self.atom_table.intern(native_function);
        let native_entry = self.lookup_native_for_test(native_module, native_function, 1);
        let label = 1;
        let code = vec![
            Instruction::Label { label },
            Instruction::CallExt {
                arity: Operand::Unsigned(1),
                import: Operand::Unsigned(0),
            },
            Instruction::Return,
        ];
        let mut module_data = Module {
            name: module,
            generation: 0,
            origin: beamr::module::ModuleOrigin::Preloaded,
            exports: std::collections::HashMap::from([((function, 1), label)]),
            label_index: std::collections::HashMap::from([(label, 0)]),
            code,
            function_table: Vec::new(),
            line_table: Vec::new(),
            literals: Vec::new(),
            constant_pool: beamr::constant_pool::ConstantPool::new(),
            resolved_imports: Vec::new(),
            lambdas: Vec::new(),
            string_table: Vec::new(),
            line_info: Vec::new(),
        };
        if let Some(native_entry) = native_entry {
            module_data.resolved_imports.push(ResolvedImport {
                module: target_module,
                function: target_function,
                arity: 1,
                target: ResolvedImportTarget::Native(native_entry),
            });
        }
        self.module_registry.insert(module_data);
    }

    /// Register a test module whose exported function waits indefinitely.
    pub fn register_waiting_test_module(&self, deployed_name: &str, function: &str) {
        let module = self.atom_table.intern(deployed_name);
        let function = self.atom_table.intern(function);
        let label = 10;
        self.module_registry.insert(Module {
            name: module,
            generation: 0,
            origin: beamr::module::ModuleOrigin::Preloaded,
            exports: std::collections::HashMap::from([((function, 1), label)]),
            label_index: std::collections::HashMap::from([(label, 0)]),
            code: vec![
                Instruction::Label { label },
                Instruction::Wait {
                    fail: Operand::Label(label),
                },
            ],
            function_table: Vec::new(),
            line_table: Vec::new(),
            literals: Vec::new(),
            constant_pool: beamr::constant_pool::ConstantPool::new(),
            resolved_imports: Vec::new(),
            lambdas: Vec::new(),
            string_table: Vec::new(),
            line_info: Vec::new(),
        });
    }
}

fn test_activity_answer(
    args: &[Term],
    _: &mut beamr::native::ProcessContext,
) -> Result<Term, Term> {
    if args.len() > 255 {
        return Err(Term::small_int(0));
    }
    Ok(Term::small_int(42))
}

fn test_activity_fail(args: &[Term], _: &mut beamr::native::ProcessContext) -> Result<Term, Term> {
    if args.len() > 255 {
        return Ok(Term::NIL);
    }
    Err(Term::atom(beamr::atom::Atom::ERROR))
}