}\

}\

use zhur_common::msg::chan::HandleRequest;

use zhur_common::msg::chan::{Envelope, HandleRequest};

pub mod executor;\

pub mod executor;
pub type InvocEnv = Envelope<Invocation, Vec<u8>>;
pub type PayloadEnv = Envelope<Vec<u8>, Vec<u8>>;\

use crate::wasm::InvocEnv;

type InvocEnv = Envelope<Invocation, Result<HttpRes, InvocationError>>;

use super::executor::Executor;

}\

    /// The actual executors.
    executors: Vec<Executor>,
}
/// These are the possible decisions the `WasmPool` can make when receiving an invocation.
enum RunDecision {
    /// The invocation can't be run right away, as there are no free executors, and needs to be put on hold.
    PutAway,
    /// Forward the invocation to the executor at the given index, which already has the relevant code.
    Forward(usize),
    /// Forward the invocation to the executor at the given index, but make it load the relevant code first.
    Replace(usize),
    /// Spawn a new executor to handle this invocation.
    SpawnNew,
}
impl WasmPool {
    /// Decides what to do with an incoming `Invocation`.
    fn decide(&self, i: &Invocation) -> RunDecision {
        // Do we have a free executor with the necessary app?
        for (index, each) in self.executors.iter().enumerate() {
            if each.owner == i.owner && each.app_name == i.app_name && each.free {
                return RunDecision::Forward(index)
            }
        }
        // If not, can we spawn another to handle it?
        if self.n_executors < self.max_executors {
            return RunDecision::SpawnNew
        }
        // Let's try evicting the first free executor we find, then.
        for (index, each) in self.executors.iter().enumerate() {
            if each.free {
                return RunDecision::Replace(index)
            }
        }
        // If there are no free executors and we can't spawn more, we can only wait.
        RunDecision::PutAway
    }
}\

use zhur_common::{flume::{Receiver, Sender}, log::*, msg::chan::Envelope};
use super::{InvocEnv, PayloadEnv};

use zhur_common::{flume::Sender, log::*, msg::chan::Envelope};
use zhur_invk::{HttpRes, Invocation, InvocationError};

mod inner;

    /// Whether or not the executor can handle an invocation right now.
    pub free: bool,

    /// Receiver for "done" messages from the inner thread.
    done_rx: Receiver<()>,

    /// Self-explanatory. We're only passing in a payload and a serialized reply which the core won't need to deserialize, thus we use `Vec<u8>` rather than complex types.
    Invoke(Envelope<Vec<u8>, Vec<u8>>),

    /// Self-explanatory. We're only passing in a payload and expecting a serialized reply which the core won't need to deserialize, thus we use `Vec<u8>` rather than complex types.
    Invoke(PayloadEnv),

    pub fn load_code(&self, code: Vec<u8>) {
        self.msg_tx.send(ExecutorMsg::LoadCode(code))
        .expect("Could not pass WASM code down to inner executor.");
    }
    pub fn invoke(&self, envelope: PayloadEnv) {
        self.msg_tx.send(ExecutorMsg::Invoke(envelope))
        .expect("Could not pass invocation down to inner executor.");
    }

}\

}\

use std::thread::JoinHandle;
use zhur_common::flume::{Receiver, Sender};
use zhur_common::log::*;
use super::ExecutorMsg;
/// This struct contains the actual code engine used to run user-provided apps.
pub struct InnerExecutor {
    /// Inner executor's numeral ID. Inherited from the outer `Executor` struct.
    id: usize,
    msg_rx: Receiver<ExecutorMsg>,
    done_tx: Sender<()>,
}
impl InnerExecutor {
    pub fn new(id: usize, msg_rx: Receiver<ExecutorMsg>, done_tx: Sender<()>) -> Self {
        Self {id, msg_rx, done_tx}
    }
    /// Handles incoming `ExecutorMsg`s and decides whether or not the executor's loop should continue to run by returning a `bool`.
    fn handle(&mut self) -> bool {
        let msg = match self.msg_rx.recv() {
            Ok(msg) => msg,
            Err(_) => {
                let text = format!("Inner WASM executor #1 could not receive a message from its outer executor thread!");
                error!("{}", &text);
                panic!("{}", &text);
            }
        };
        match msg {
            ExecutorMsg::LoadCode(_v) => {
                trace!("Inner WASM executor #{} was requested to reload its code.", self.id);
                trace!("Not actually doing anything, WASM not implemented yet.");
            },
            ExecutorMsg::Invoke(_env) => {
                trace!("Inner WASM executor #{} received an invocation.", self.id);
                trace!("Not actually doing anything, WASM not implemented yet.");
                match _env.1.send(b"PLACEHOLDER".to_vec()) {
                    Ok(_) => (),
                    Err(_) => {
                        let text = format!("Inner WASM executor #{} could not respond to the invocation it got!", self.id);
                        error!("{}", &text);
                        panic!("{}", &text);
                    }
                }
                match self.done_tx.send(()) {
                    Ok(_) => (),
                    Err(_) => {
                        let text = format!("Inner WASM executor #{} could not report a successful execution!", self.id);
                        error!("{}", &text);
                        panic!("{}", &text);
                    }
                }
            },
            ExecutorMsg::Shutdown => {
                trace!("Inner WASM executor #{} was told to shut down.", self.id);
                return false // quit thread loop
            }
        }
        true
    }
    /// Runs the executor in a background thread and returns a join handle to said thread.
    pub fn run_as_thread(self) -> JoinHandle<()> {
        let id = self.id;
        let builder = std::thread::Builder::new();
        match builder
        .name(format!("inner_executor_{}", self.id))
        .spawn(move || {
            let mut exec = self;
            loop {
                if !exec.handle() {
                    break;
                }
            }
        }) {
            Ok(h) => h,
            Err(_) => {
                let text = format!("Inner WASM executor #{} could not be launched as a thread!", id);
                error!("{}", &text);
                panic!("{}", &text);
            }
        }
    }
}\

}\

}\

}\

}\

zhur_invk = { path = "../zhur_invk" }\

zhur_invk = { path = "../zhur_invk" }\