use zhur_common::msg::chan::HandleRequest;
use zhur_common::log::*;
use zhur_invk::{HttpRes, Invocation, InvocationError};
/// Wasm executor pool.
pub mod pool;\

use zhur_common::flume::Receiver;
use zhur_common::msg::chan::Envelope;
use zhur_invk::{HttpRes, Invocation, InvocationError};
type InvocEnv = Envelope<Invocation, Result<HttpRes, InvocationError>>;
/// The "WASM executor pool" keeps track of WASM executors and distributes invocations among them.
pub struct WasmPool {
    /// This receiver handles incoming invocations to be passed out to executors.
    invoc_env_rx: Receiver<InvocEnv>,
    /// This is where invocations that can't be handled right away get put.
    outstanding_invocations: Vec<InvocEnv>,
    /// How many executors are currently active.
    n_executors: usize,
    /// How many executors can be running at one time.
    max_executors: usize,
}\

mod wasm;

mod wasm;

/// Abstraction for an "envelope" pattern, in which we send some type `T` to another thread and expect to get a `U` back.
/// `T` and `U` must be `Send`.
pub type Envelope<T, U> = (T, Sender<U>);
/// Shorthand for generating a pair of `Envelope` channels.
pub fn envelope_pair<U: Send, T: Send>() -> (Sender<Envelope<T, U>>, Receiver<Envelope<T, U>>) {
    unbounded()
}

    request_rx: Receiver<(T, Sender<U>)>,

    request_rx: Receiver<Envelope<T, U>>,

    request_tx: Sender<(T, Sender<U>)>

    request_tx: Sender<Envelope<T, U>>

    let (request_tx, request_rx) = unbounded::<(T, Sender<U>)>();

    let (request_tx, request_rx) = unbounded::<Envelope<T,U>>();