starlane 0.3.21

Starlane -- An Orchestration and Infrastructure Framework for WebAssembly Components (https://starlane.io) This packaged manages `HyperSpace` which provides infrastructure for `Space` Apis (WebAssembly & external programs meant to provide custom behaviors in Starlane), This package references the `starlane-space` package and reuses of it to run the infrastructure and it also contains mechanisms (Drivers) for extending the Starlane Type system
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::hyperspace::executor::cli::os::CliOsExecutor;
use crate::hyperspace::executor::cli::{CliIn, CliOut, HostEnv};
use crate::hyperspace::executor::{ExeConf, Executor};
use crate::hyperspace::host::err::HostErr;
use crate::hyperspace::service::ServiceErr;
use clap::CommandFactory;
use itertools::Itertools;
use nom::AsBytes;
use crate::space::wave::exchange::asynch::DirectedHandler;
use std::fmt::Write;
use std::hash::{Hash, Hasher};
use std::io::Read;
use std::ops::{Deref, DerefMut};
use tokio::io::AsyncWriteExt;

pub mod err;

#[derive(Clone, Eq, PartialEq, Hash)]
pub struct ExtKey<B>
where
    B: Hash + Eq + PartialEq,
{
    bin: B,
    env: HostEnv,
}

impl<B> ExtKey<B>
where
    B: Clone + Hash + Eq + PartialEq,
{
    pub fn new(bin: B, env: HostEnv) -> Self {
        Self { bin, env }
    }
}

pub trait Proc {
    type StdOut;
    type StdErr;
    type StdIn;
    fn stderr(&self) -> Option<&Self::StdErr>;
    fn stdout(&self) -> Option<&Self::StdOut>;

    fn stdin(&mut self) -> Option<&Self::StdIn>;
}

#[derive(Clone, Hash, Eq, PartialEq)]
pub struct ExeStub {
    pub loc: String,
    pub env: HostEnv,
    pub args: Vec<String>,
}

impl ExeStub {
    pub fn new(loc: String, env: HostEnv) -> Self {
        let args = vec![];
        Self::new_with_args(loc, env, args)
    }

    pub fn new_with_args(loc: String, env: HostEnv, args: Vec<String>) -> Self {
        Self { loc, env, args }
    }
}

pub fn stringify_args(args: Vec<&str>) -> Vec<String> {
    args.iter().map(|arg| arg.to_string()).collect()
}

#[derive(Clone, Hash, Eq, PartialEq)]
pub enum Host {
    Cli(HostCli),
}

impl Host {
    pub fn env(&self, key: &str) -> Option<&String> {
        match self {
            Host::Cli(cli) => cli.env(key),
        }
    }
    pub fn create<D>(&self) -> Result<D, HostErr>
    where
        D: TryFrom<CliOsExecutor, Error = HostErr>,
    {
        match self {
            Host::Cli(host) => host.create(),
        }
    }

    pub fn with_env(&self, key: &str, value: &str) -> Self {
        match self {
            Host::Cli(cli) => Host::Cli(cli.with_env(key, value)),
        }
    }
}

#[derive(Clone, Hash, Eq, PartialEq)]
pub enum HostCli {
    Os(ExeStub),
}

impl HostCli {
    pub fn env(&self, key: &str) -> Option<&String> {
        let key = key.to_string();
        match self {
            HostCli::Os(stub) => stub.env.env.get(&key),
        }
    }

    pub fn create<D>(&self) -> Result<D, HostErr>
    where
        D: TryFrom<CliOsExecutor, Error = HostErr>,
    {
        match self {
            HostCli::Os(stub) => Ok(D::try_from(CliOsExecutor::new(stub.clone()))?),
        }
    }

    pub fn with_env(&self, key: &str, value: &str) -> Self {
        match self {
            HostCli::Os(stub) => {
                let mut stub = stub.clone();
                stub.env.env.insert(key.to_string(), value.to_string());
                HostCli::Os(stub)
            }
        }
    }
}