iocaine 2.2.0

The deadliest poison known to AI
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

// SPDX-FileCopyrightText: 2025 Gergely Nagy
// SPDX-FileContributor: Gergely Nagy
//
// SPDX-License-Identifier: MIT

#![allow(clippy::needless_pass_by_value)]

mod context;
mod error;
mod json;
mod log;
mod network;
mod outcome;
mod request;
mod string_list;
mod tests;
mod version;

pub use context::IocaineContext;
pub use error::Error;
pub use outcome::Outcome;
pub use request::Request;
pub use string_list::MutableStringList;

use axum::http::HeaderMap;
use roto::{FileTree, Runtime, TypedFunc, Val, Verdict};
use std::path::Path;
use std::sync::Arc;

pub type DecideFunc =
    TypedFunc<IocaineContext, fn(Val<Request>) -> Verdict<Val<Outcome>, Val<Outcome>>>;

#[derive(Debug)]
pub struct MeansOfProduction {
    pub decider: DecideFunc,
    pub context: IocaineContext,
}

impl MeansOfProduction {
    pub fn new_runtime() -> Result<Runtime, Error> {
        let mut runtime = Runtime::new();

        string_list::register_string_list(&mut runtime)?;
        request::register_request_type(&mut runtime)?;
        context::register_context(&mut runtime)?;
        outcome::register_outcome(&mut runtime)?;
        version::register_version(&mut runtime)?;
        log::register_log(&mut runtime)?;
        json::register_json(&mut runtime)?;
        network::register_network_type(&mut runtime)?;

        Ok(runtime)
    }

    pub fn run_init(path: &str) -> Result<IocaineContext, Error> {
        let runtime = Self::new_runtime()?;
        let mut compiled = FileTree::directory(Path::new(&path)).compile(runtime)?;
        let init = compiled.get_function::<IocaineContext, fn() -> Verdict<(), Arc<str>>>("init");
        let mut context = IocaineContext::default();

        if let Ok(init) = init {
            init.call(&mut context)
                .into_result()
                .map_err(|e| Error::String(format!("init script failed: {e}")))?;
        }

        Ok(context)
    }

    pub fn new(path: &str) -> Result<Self, Error> {
        let context = Self::run_init(path)?;

        let runtime = Self::new_runtime()?;

        let mut compiled = FileTree::directory(Path::new(path)).compile(runtime)?;
        let decider = compiled
            .get_function::<IocaineContext, fn(Val<Request>) -> Verdict<Val<Outcome>, Val<Outcome>>>(
                "decide",
            )
            .map_err(|e| e.to_string())?;

        Ok(Self { decider, context })
    }

    pub fn decide(
        &self,
        headers: HeaderMap,
        path: Option<String>,
        method: &str,
    ) -> Result<Outcome, Outcome> {
        let request = Request {
            method: method.to_owned(),
            path: path.unwrap_or_default(),
            headers,
        };

        self.decider
            .call(&mut self.context.clone(), Val(request))
            .into_result()
            .map(|a| a.0)
            .map_err(|r| r.0)
    }
}