aika 0.2.1

Multi-agent coordination framework in Rust with single and multi-threaded execution engines.
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

use std::{
    fs::File,
    io::Write,
    sync::{
        atomic::{AtomicBool, Ordering},
        Arc,
    },
    time::{Duration, Instant},
};

use bytemuck::{Pod, Zeroable};
use mesocarp::comms::buses::ThreadedMessenger;
use mesocarp::MesoError;

use crate::{objects::Transfer, AikaError};

pub struct MessageBus<const MSG_BW: usize, MessageType: Pod + Zeroable + Clone> {
    pub(crate) messenger: ThreadedMessenger<MSG_BW, Transfer<MessageType>>,
    pub(crate) terminal_flag: Arc<AtomicBool>,
    pub(crate) log: Option<File>,
    pub(crate) start: Instant,
}

impl<const MSG_BW: usize, MessageType: Pod + Zeroable + Clone> MessageBus<MSG_BW, MessageType> {
    pub(crate) fn from_substrate(
        messenger: ThreadedMessenger<MSG_BW, Transfer<MessageType>>,
        log: Option<File>,
        start: Instant,
        terminal_flag: Arc<AtomicBool>,
    ) -> Self {
        Self {
            messenger,
            terminal_flag,
            log,
            start,
        }
    }

    pub(crate) fn deliver_the_mail(&mut self) -> Result<(), AikaError> {
        match self.messenger.poll() {
            Ok(msgs) => {
                if let Some(file) = &mut self.log {
                    writeln!(
                        file,
                        "[{}] Found {:?} messages in-transit.",
                        self.start.elapsed().as_micros(),
                        msgs.len()
                    )
                    .map_err(|_| AikaError::LoggingWriteError)?;
                }
                self.messenger.deliver(msgs)?;
                Ok(())
            }
            Err(err) => {
                if let MesoError::NoDirectCommsToShare = err {
                    Ok(())
                } else {
                    if let Some(file) = &mut self.log {
                        writeln!(
                            file,
                            "[{}] Error delivering mail!",
                            self.start.elapsed().as_micros(),
                        )
                        .map_err(|_| AikaError::LoggingWriteError)?;
                    }
                    Err(AikaError::MesoError(err))
                }
            }
        }
    }

    pub fn master(mut self) -> Result<Self, AikaError> {
        if let Some(log) = &mut self.log {
            writeln!(
                log,
                "[{}] Starting Master",
                self.start.elapsed().as_micros()
            )
            .map_err(|_| AikaError::LoggingWriteError)?;
        }
        loop {
            let flag = self.terminal_flag.load(Ordering::SeqCst);
            if flag {
                if let Some(log) = &mut self.log {
                    writeln!(
                        log,
                        "[{}] Flag closing Master",
                        self.start.elapsed().as_micros()
                    )
                    .map_err(|_| AikaError::LoggingWriteError)?;
                }
                break;
            }
            if let Some(log) = &mut self.log {
                writeln!(log, "[{}] looping master", self.start.elapsed().as_micros())
                    .map_err(|_| AikaError::LoggingWriteError)?;
            }
            for _ in 0..100 {
                self.deliver_the_mail()?;
            }
            std::thread::sleep(Duration::from_nanos(1));
        }
        if let Some(log) = &mut self.log {
            writeln!(log, "[{}] Closing Master", self.start.elapsed().as_micros())
                .map_err(|_| AikaError::LoggingWriteError)?;
        }
        Ok(self)
    }
}