move repos into monorepo

bin/coordinator/src/models/actor.rs

@@ -0,0 +1,15 @@
+use std::net::IpAddr;
+
+use serde::{Deserialize, Serialize};
+
+use crate::time::Timestamp;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Actor {
+    id: u32,
+    pubkey: String,
+    /// IP where the actor is reachable, can be mycelium but that is not mandatory
+    address: Vec<IpAddr>,
+    created_at: Timestamp,
+    updated_at: Timestamp,
+}

bin/coordinator/src/models/context.rs

@@ -0,0 +1,17 @@
+use serde::{Deserialize, Serialize};
+
+use crate::time::Timestamp;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Context {
+    /// Redis DB to use
+    pub id: u32,
+    /// Actor ids which have admin rights on this context
+    pub admins: Vec<u32>,
+    /// Actor ids which can read the context info
+    pub readers: Vec<u32>,
+    /// Actor ids which can execute jobs in this context
+    pub executors: Vec<u32>,
+    pub created_at: Timestamp,
+    pub updated_at: Timestamp,
+}

bin/coordinator/src/models/flow.rs

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::time::Timestamp;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Flow {
+    /// Job Id set tby the actor which created it
+    pub id: u32,
+    /// Actor Id who created this job
+    pub caller_id: u32,
+    /// The context in which this job is executed
+    pub context_id: u32,
+    /// List of jobs which make up the flow
+    pub jobs: Vec<u32>,
+    /// Environment variables, passed to every job when executed
+    pub env_vars: HashMap<String, String>,
+    /// The result of the flow
+    pub result: HashMap<String, String>,
+    pub created_at: Timestamp,
+    pub updated_at: Timestamp,
+    pub status: FlowStatus,
+}
+
+/// The status of a flow
+#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
+pub enum FlowStatus {
+    Created,
+    Dispatched,
+    Started,
+    Error,
+    Finished,
+}
+
+impl Flow {
+    pub fn id(&self) -> u32 {
+        self.id
+    }
+    pub fn caller_id(&self) -> u32 {
+        self.caller_id
+    }
+    pub fn context_id(&self) -> u32 {
+        self.context_id
+    }
+    pub fn jobs(&self) -> &[u32] {
+        &self.jobs
+    }
+}

bin/coordinator/src/models/job.rs

@@ -0,0 +1,62 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{models::ScriptType, time::Timestamp};
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct Job {
+    /// Job Id, this is given by the actor who created the job
+    pub id: u32,
+    /// Actor ID which created this job
+    pub caller_id: u32,
+    /// Context in which the job is executed
+    pub context_id: u32,
+    pub script: String,
+    pub script_type: ScriptType,
+    /// Timeout in seconds for this job
+    pub timeout: u32,
+    /// Max amount of times to retry this job
+    pub retries: u8,
+    pub env_vars: HashMap<String, String>,
+    pub result: HashMap<String, String>,
+    pub prerequisites: Vec<String>,
+    /// Ids of jobs this job depends on, i.e. this job can't start until those have finished
+    pub depends: Vec<u32>,
+    pub created_at: Timestamp,
+    pub updated_at: Timestamp,
+    pub status: JobStatus,
+}
+
+#[derive(Clone, Serialize, Deserialize, PartialEq, Eq, Debug)]
+pub enum JobStatus {
+    Dispatched,
+    WaitingForPrerequisites,
+    Started,
+    Error,
+    Finished,
+}
+
+impl Job {
+    pub fn id(&self) -> u32 {
+        self.id
+    }
+    pub fn caller_id(&self) -> u32 {
+        self.caller_id
+    }
+    pub fn context_id(&self) -> u32 {
+        self.context_id
+    }
+    pub fn depends(&self) -> &[u32] {
+        &self.depends
+    }
+    pub fn prerequisites(&self) -> &[String] {
+        &self.prerequisites
+    }
+    pub fn script_type(&self) -> ScriptType {
+        self.script_type.clone()
+    }
+    pub fn status(&self) -> JobStatus {
+        self.status.clone()
+    }
+}

bin/coordinator/src/models/message.rs

@@ -0,0 +1,81 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    models::{Job, ScriptType},
+    time::Timestamp,
+};
+
+#[derive(Clone, Serialize, Deserialize)]
+pub struct Message {
+    /// Unique ID for the message, set by the caller
+    pub id: u32,
+    /// Id of the actor who sent this message
+    pub caller_id: u32,
+    /// Id of the context in which this message was sent
+    pub context_id: u32,
+    pub message: String,
+    pub message_type: ScriptType,
+    pub message_format_type: MessageFormatType,
+    /// Seconds for the message to arrive at the destination
+    pub timeout: u32,
+    /// Seconds for the receiver to acknowledge receipt of the message
+    pub timeout_ack: u32,
+    /// Seconds for the receiver to send us a reply
+    pub timeout_result: u32,
+
+    /// Outbound transport id returned by Mycelium on push
+    pub transport_id: Option<String>,
+    /// Latest transport status as reported by Mycelium
+    pub transport_status: Option<TransportStatus>,
+
+    pub job: Vec<Job>,
+    pub logs: Vec<Log>,
+    pub created_at: Timestamp,
+    pub updated_at: Timestamp,
+    pub status: MessageStatus,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum MessageType {
+    Job,
+    Chat,
+    Mail,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum MessageStatus {
+    Dispatched,
+    Acknowledged,
+    Error,
+    Processed,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum TransportStatus {
+    Queued,
+    Sent,
+    Delivered,
+    Read,
+    Failed,
+}
+
+impl std::fmt::Display for TransportStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TransportStatus::Queued => f.write_str("queued"),
+            TransportStatus::Sent => f.write_str("sent"),
+            TransportStatus::Delivered => f.write_str("delivered"),
+            TransportStatus::Read => f.write_str("read"),
+            TransportStatus::Failed => f.write_str("failed"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum MessageFormatType {
+    Html,
+    Text,
+    Md,
+}
+
+type Log = String;

bin/coordinator/src/models/runner.rs

@@ -0,0 +1,25 @@
+use std::net::IpAddr;
+
+use serde::{Deserialize, Serialize};
+
+use crate::models::ScriptType;
+use crate::time::Timestamp;
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Runner {
+    pub id: u32,
+    /// Mycelium public key
+    pub pubkey: String,
+    /// Mycelium address
+    pub address: IpAddr,
+    /// Needs to be set by the runner, usually `runner<runnerid`
+    pub topic: String,
+    /// The script type this runner can execute; used for routing
+    pub script_type: ScriptType,
+    /// If this is true, the runner also listens on a local redis queue
+    pub local: bool,
+    /// Optional secret used for authenticated supervisor calls (if required)
+    pub secret: Option<String>,
+    pub created_at: Timestamp,
+    pub updated_at: Timestamp,
+}

bin/coordinator/src/models/script_type.rs

@@ -0,0 +1,9 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
+pub enum ScriptType {
+    Osis,
+    Sal,
+    V,
+    Python,
+}