pub type PayloadEnv = Envelope<Vec<u8>, Vec<u8>>;\

pub type PayloadEnv = Envelope<Vec<u8>, Vec<u8>>;\

use std::thread::JoinHandle;

    /// How many executors are currently active.
    n_executors: usize,

        if self.n_executors < self.max_executors {

        if self.executors.len() < self.max_executors {

        // Let's try evicting the first free executor we find, then.

        // No? Let's try evicting the first free executor we find, then.

        // Check if any executors have become free.
        for each in self.executors.iter_mut() {
            each.check_status();
        }

                trace!("WasmPool decided to spawn a new executor #{} for the current invocation.", self.n_executors);

                trace!("WasmPool decided to spawn a new executor #{} for the current invocation.", self.executors.len());
                warn!("Not actually doing anything, zhur_apst hasn't been implemented yet.");

                    self.n_executors,

                    self.executors.len(),

                self.n_executors += 1;

                self.executors.last_mut()
                .unwrap()
                .invoke((env.0.payload, env.1));

                warn!("Not actually doing anything, zhur_apst hasn't been implemented yet.");

}\

    pub fn new(max_executors: usize, invoc_env_rx: Receiver<InvocEnv>) -> Self {
        Self {
            max_executors,
            invoc_env_rx,
            outstanding_invocations: Vec::new(),
            executors: Vec::new()
        }
    }
    /// Runs the `WasmPool` in a background thread.
    pub fn run_as_thread(self) -> JoinHandle<()> {
        std::thread::Builder::new()
        .name("wasm_pool".to_owned())
        .spawn(move || {
            let mut pool = self;
            loop {
                let env = match pool.invoc_env_rx.recv() {
                    Ok(env) => env,
                    Err(_) => {
                        let text = "WasmPool could not receive incoming invocation envelope!";
                        error!("{}", text);
                        panic!("{}", text);
                    }
                };
                pool.handle(env);
            }
        })
        .expect("Could not launch WasmPool thread!")
    }
}\

    pub fn check_status(&mut self) {
        match self.done_rx.try_recv() {
            Ok(_) => self.free = true,
            Err(_) => ()
        }
    }

    pub fn invoke(&self, envelope: PayloadEnv) {

    pub fn invoke(&mut self, envelope: PayloadEnv) {
        self.free = false;

}\

}\

                trace!("Not actually doing anything, WASM not implemented yet.");

                warn!("Not actually doing anything, WASM not implemented yet.");

                trace!("Not actually doing anything, WASM not implemented yet.");

                warn!("Not actually doing anything, WASM not implemented yet.");

                    Ok(_) => (),

                    Ok(_) => {
                        trace!("Inner WASM executor #{} responded!", self.id);
                    },

                    Ok(_) => (),

                    Ok(_) => {
                        trace!("Inner WASM executor #{} done!", self.id);
                    },

}\

}\

use zhur_core::CoreServer;
use zhur_common::zmq::Context;

use zhur_core::{CoreServer, WasmPool};
use zhur_common::{flume::unbounded, zmq::Context};

    let server = CoreServer::new(&zmq_ctx);

    let (invoc_env_tx, invoc_env_rx) = unbounded();
    let wasm_pool = WasmPool::new(3, invoc_env_rx).run_as_thread();
    let server = CoreServer::new(&zmq_ctx, invoc_env_tx);

}\

}\

use zhur_common::bincode::{deserialize, serialize};

use wasm::InvocEnv;
use zhur_common::{bincode::{deserialize, serialize}, flume::{Receiver, Sender, unbounded}};

/// The ZMQ server that takes invocations incoming from the gateway and sends back HttpReses or InvocationErrors.

pub use wasm::pool::WasmPool;
/// The ZMQ server that takes invocations incoming from the gateway and sends back bytes.

    rep_socket: Socket

    rep_socket: Socket,
    invoc_env_tx: Sender<InvocEnv>,
    reply_tx: Sender<Vec<u8>>,
    reply_rx: Receiver<Vec<u8>>

    pub fn new(zmq_ctx: &Context) -> Self {

    pub fn new(zmq_ctx: &Context, invoc_env_tx: Sender<InvocEnv>) -> Self {
        let (reply_tx, reply_rx) = unbounded();

            }

            },
            reply_tx,
            reply_rx,
            invoc_env_tx,

        let response = handle_invoke_bytes(&bytes);

        let response = self.handle_invoke_bytes(&bytes);

        let res_bytes = match serialize(&response) {
            Ok(b) => b,
            Err(_) => panic!("Could not serialize a response.")
        };

        let res_bytes = serialize(&response).expect("Could not serialize a response.");
        

}
fn handle_invoke_bytes(bytes: &[u8]) -> Result<HttpRes, InvocationError> {
    match deserialize::<Invocation>(bytes) {
        Ok(i) => handle_invocation(&i),
        Err(_) => Err(InvocationError::MalformedRequest)

    fn handle_invoke_bytes(&self, bytes: &[u8]) -> Result<Vec<u8>, InvocationError> {
        let inv = match deserialize::<Invocation>(bytes) {
            Ok(i) => i,
            Err(_) => {
                warn!("The bytes we got could not be deserialized to an Invocation.");
                return Err(InvocationError::MalformedRequest)
            }
        };
        trace!("Got an invocation for {}:{}", &inv.owner, &inv.app_name);
        let env = (inv, self.reply_tx.clone());
        self.invoc_env_tx.send(env)
        .expect("Expected to be able to send an invocation envelope from the CoreServer");
        let reply = self.reply_rx.recv().expect("Expected to be able to receive a Vec<u8> back from the WasmPool in the CoreServer");
        Ok(reply)

}
fn handle_invocation(i: &Invocation) -> Result<HttpRes, InvocationError> {
    trace!("Got an invocation for {}:{}", &i.owner, &i.app_name);
    let mut res = HttpRes::default();
    res.body = b"Hello world from Zhur!".to_vec();
    Ok(res)
}\

}\