iocaine 3.0.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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

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

use anyhow::Result;
use axum::{
    extract::{Query, Request, State},
    handler::Handler,
    http::StatusCode,
    response::IntoResponse,
};
use serde::Serialize;
use std::collections::BTreeMap;
use std::path;
use std::sync::Arc;
use tokio_listener::Listener;

use crate::{
    morgue::{Decay, StateOfDecay, shutdown_signal},
    sex_dungeon::{self, Language, Request as SDRequest, SharedRequest},
    tenx_programmer::TenXProgrammer,
};

#[derive(Clone)]
pub struct Bruce {
    pub state: StateOfDecay,
}

impl Bruce {
    pub fn new<P: AsRef<path::Path>, C: AsRef<path::Path>, S: Serialize>(
        language: Language,
        compiler: Option<C>,
        path: &Option<P>,
        initial_seed: &str,
        metrics: &TenXProgrammer,
        config: Option<S>,
    ) -> Result<Self> {
        let request_handler = Arc::new(sex_dungeon::create(
            language,
            compiler,
            path.as_ref(),
            initial_seed,
            metrics,
            config,
        )?);

        if !request_handler.can_output() {
            let path = path
                .as_ref()
                .map_or_else(|| "(default)".into(), |p| p.as_ref().display().to_string());
            tracing::error!({ path }, "At least an output() function is required");
            anyhow::bail!("Requires at least output()");
        }

        let state = Decay {
            metrics: metrics.clone(),
            request_handler,
        }
        .into();

        Ok(Self { state })
    }

    #[allow(clippy::significant_drop_tightening)]
    pub fn run_tests(self) -> anyhow::Result<()> {
        let mut state = self.state.write().unwrap();
        let handler = Arc::get_mut(&mut state.request_handler).unwrap();
        handler.run_tests()
    }

    pub async fn serve(self, listener: Listener) -> Result<()> {
        let app = handler
            .layer(tower_http::trace::TraceLayer::new_for_http())
            .with_state(self.state);

        Ok(axum::serve(listener, app.into_make_service())
            .with_graceful_shutdown(shutdown_signal(None))
            .await?)
    }
}

async fn handler(
    State(state): State<StateOfDecay>,
    Query(params): Query<BTreeMap<String, String>>,
    request: Request,
) -> impl IntoResponse {
    let request: SharedRequest = SDRequest {
        method: request.method().to_string(),
        path: request.uri().path().to_owned(),
        headers: request.headers().clone(),
        params,
    }
    .into();

    let state = state.read().unwrap();
    let decision = if state.request_handler.can_decide() {
        match state.request_handler.decide(request.clone()) {
            Ok(v) => Some(v),
            Err(e) => {
                tracing::error!("Error running decide(): {e}");
                return server_error().into_response();
            }
        }
    } else {
        None
    };
    state.request_handler.output(request, decision).map_or_else(
        |e| {
            tracing::error!("Error running output(): {e}");
            server_error().into_response()
        },
        IntoResponse::into_response,
    )
}

fn server_error() -> impl IntoResponse {
    (StatusCode::INTERNAL_SERVER_ERROR, "")
}