path: root/rust/src/web.rs

use actix_web::{middleware::Logger, post, web, App, HttpResponse, HttpServer, Responder};
use clap::Parser;
use futures::lock::Mutex;
use log::info;
use proptest::test_runner::{Config, RngAlgorithm, TestRng, TestRunner};
use rand::Rng;
use serde::{Deserialize, Serialize};
use std::time::Duration;
use std::{collections::HashMap, sync::Arc};
use tokio::task;
use uuid::Uuid;

use lambda::lambda::{eval_all, eval_whnf, generate_expr, Environment};
use lambda::parser::parse;

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
struct Registration {
    url: String,
}

trait AppState: Send + Sync {
    fn register(&mut self, registration: &Registration) -> RegistrationResult;
}

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
enum RegistrationResult {
    RegistrationSuccess { id: String, url: String },
    UrlAlreadyRegistered { url: String },
}

#[derive(Debug, Clone)]
struct Client {
    id: Uuid,
    url: String,
    grade: u8,
    runner: TestRunner,
    results: Vec<TestResult>,
    delay: std::time::Duration,
}

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
enum TestResult {
    TestFailed(String),
    ErrorSendingTest(String),
    TestSucceeded,
}

impl Client {
    fn new(url: String) -> Self {
        let id = Uuid::new_v4();
        let runner = TestRunner::new_with_rng(
            Config::default(),
            TestRng::from_seed(RngAlgorithm::XorShift, &id.to_bytes_le()),
        );
        Self {
            id,
            url,
            grade: 1,
            runner,
            results: Vec::new(),
            delay: Duration::from_secs(10),
        }
    }

    fn time_to_next_test(&self) -> Duration {
        self.delay
    }

    fn generate_expr(&mut self) -> (String, String) {
        let input = generate_expr(self.grade.into(), &mut self.runner);
        let expected = eval_whnf(&input, &mut Environment::new());
        (input.to_string(), expected.to_string())
    }

    fn check_result(
        &mut self,
        expected: &String,
        response: &Result<String, TestResult>,
    ) -> TestResult {
        let result = match response {
            Ok(expr) => {
                let vals = parse(expr);
                let actual = eval_all(&vals)
                    .iter()
                    .map(|v| format!("{}", v))
                    .collect::<Vec<_>>()
                    .join("\n");
                if actual == *expected {
                    self.grade += 1;
                    self.delay = Duration::from_secs_f64(self.delay.as_secs_f64() * 0.8);
                    TestResult::TestSucceeded
                } else {
                    self.delay = Duration::from_secs_f64(self.delay.as_secs_f64() * 1.2);
                    if self.delay.as_secs() > 30 {
                        self.delay = Duration::from_secs(30);
                    }
                    TestResult::TestFailed(actual)
                }
            }
            Err(res) => res.clone(),
        };
        self.results.push(result.clone());
        result
    }
}

#[derive(Debug)]
struct State {
    clients: HashMap<String, Arc<Mutex<Client>>>,
}

impl State {
    fn new() -> Self {
        Self {
            clients: HashMap::new(),
        }
    }
}

impl AppState for State {
    fn register(&mut self, registration: &Registration) -> RegistrationResult {
        if self.clients.contains_key(&registration.url) {
            RegistrationResult::UrlAlreadyRegistered {
                url: registration.url.clone(),
            }
        } else {
            let client = Client::new(registration.url.clone());
            let id = client.id.to_string();
            let client_ref = Arc::new(Mutex::new(client));
            let client_s = client_ref.clone();
            self.clients.insert(registration.url.clone(), client_ref);
            // let it run in the background
            // FIXME: should find a way to handle graceful termination
            task::spawn(async move { send_tests(client_s).await });

            RegistrationResult::RegistrationSuccess {
                id,
                url: registration.url.clone(),
            }
        }
    }
}

#[post("/register")]
async fn register(
    app_state: web::Data<Arc<Mutex<dyn AppState>>>,
    registration: web::Json<Registration>,
) -> impl Responder {
    let result = app_state.lock().await.register(&registration);
    match result {
        RegistrationResult::RegistrationSuccess { .. } => HttpResponse::Ok().json(result),
        RegistrationResult::UrlAlreadyRegistered { .. } => HttpResponse::BadRequest().json(result),
    }
}

#[post("/eval")]
async fn eval(input: String) -> impl Responder {
    let mut env = Environment::new();
    match parse(&input).first() {
        Some(expr) => {
            let output = eval_whnf(expr, &mut env);
            HttpResponse::Ok().body(format!("{}", output))
        }
        None => HttpResponse::BadRequest().finish(),
    }
}

#[derive(Parser, Debug)]
struct Options {
    /// The port to listen on
    /// Defaults to 8080
    #[arg(short, long, default_value_t = 8080)]
    port: u16,
    /// The host to bind the server to
    /// Defaults to 127.0.0.1
    #[arg(long, default_value = "127.0.0.1")]
    host: String,
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let options = Options::parse();
    let app_state = Arc::new(Mutex::new(State::new()));
    let http_state: Arc<Mutex<dyn AppState>> = app_state;
    env_logger::init();
    HttpServer::new(move || {
        App::new()
            .wrap(Logger::default())
            .app_data(web::Data::new(http_state.clone()))
            .service(register)
            .service(eval)
    })
    .bind((options.host, options.port))?
    .run()
    .await
}

async fn send_tests(client_m: Arc<Mutex<Client>>) {
    loop {
        let mut client = client_m.lock().await;
        tokio::time::sleep(client.time_to_next_test()).await;

        let (input, expected) = client.generate_expr();
        let response = send_test(&input, &client.url).await;

        client.check_result(&expected, &response);
    }
}

async fn send_test(input: &String, url: &String) -> Result<String, TestResult> {
    info!("Sending {} to {}", input, url);
    let body = input.clone();
    let response = reqwest::Client::new()
        .post(url)
        .header("content-type", "text/plain")
        .body(body)
        .send()
        .await;
    match response {
        Ok(response) => {
            let body = response.text().await.unwrap();
            Ok(body)
        }
        Err(e) => {
            info!("Error sending test: {}", e);
            Err(TestResult::ErrorSendingTest(e.to_string()))
        }
    }
}

#[cfg(test)]
mod app_tests {
    use std::sync::Arc;

    use actix_web::http::header::TryIntoHeaderValue;
    use actix_web::{body, http::header::ContentType, middleware::Logger, test, App};
    use lambda::ast::Value;

    use super::*;

    struct DummyAppState {
        id: String,
    }

    impl DummyAppState {
        fn new(id: String) -> Self {
            Self { id }
        }
    }

    impl AppState for DummyAppState {
        fn register(&mut self, registration: &Registration) -> RegistrationResult {
            if self.id.is_empty() {
                RegistrationResult::UrlAlreadyRegistered {
                    url: registration.url.clone(),
                }
            } else {
                RegistrationResult::RegistrationSuccess {
                    id: self.id.clone(),
                    url: registration.url.clone(),
                }
            }
        }
    }

    #[actix_web::test]
    async fn post_registration_returns_success_with_unique_id() {
        let id = "0123456789abcdef0123456789abcdef".to_string();
        let dummy_state: Arc<Mutex<dyn AppState>> =
            Arc::new(Mutex::new(DummyAppState::new(id.clone())));
        // FIXME should only be called once, move to setup
        env_logger::init();

        let app = test::init_service(
            App::new()
                .wrap(Logger::default())
                .app_data(web::Data::new(dummy_state))
                .service(register),
        )
        .await;
        let url = "http://192.168.1.1".to_string();
        let req = test::TestRequest::post()
            .uri("/register")
            .set_json(Registration { url: url.clone() })
            .insert_header(ContentType::json())
            .to_request();

        let resp = test::call_service(&app, req).await;

        assert!(resp.status().is_success());

        let body = resp.into_body();
        let bytes = body::to_bytes(body).await;
        assert_eq!(
            RegistrationResult::RegistrationSuccess { id, url },
            serde_json::from_slice(&bytes.unwrap()).unwrap()
        );
    }

    #[actix_web::test]
    async fn post_registration_returns_400_when_register_fails() {
        let dummy_state: Arc<Mutex<dyn AppState>> =
            Arc::new(Mutex::new(DummyAppState::new("".to_string())));

        let app = test::init_service(
            App::new()
                .wrap(Logger::default())
                .app_data(web::Data::new(dummy_state))
                .service(register),
        )
        .await;
        let url = "http://192.168.1.1".to_string();

        let req = test::TestRequest::post()
            .uri("/register")
            .set_json(Registration { url: url.clone() })
            .insert_header(ContentType::json())
            .to_request();

        let resp = test::call_service(&app, req).await;

        assert!(resp.status().is_client_error());
        assert_eq!(
            ContentType::json().try_into_value().unwrap(),
            resp.headers().get("content-type").unwrap()
        );
    }

    #[actix_web::test]
    async fn post_expression_returns_evaluation() {
        let app = test::init_service(App::new().wrap(Logger::default()).service(eval)).await;

        let req = test::TestRequest::post()
            .uri("/eval")
            .set_payload("((lam (x y) x) 1 2)")
            .insert_header(ContentType::plaintext())
            .to_request();

        let resp = test::call_service(&app, req).await;

        assert!(resp.status().is_success());

        let body = resp.into_body();
        let bytes = body::to_bytes(body).await.unwrap();
        assert_eq!(bytes, "1".to_string().into_bytes());
    }

    #[test]
    async fn app_does_not_register_same_url_twice() {
        let mut app_state = State::new();
        let registration = Registration {
            url: "http://1.2.3.4".to_string(),
        };

        app_state.register(&registration);
        let result = app_state.register(&registration);

        assert_eq!(
            RegistrationResult::UrlAlreadyRegistered {
                url: "http://1.2.3.4".to_string()
            },
            result
        );
    }

    fn client() -> Client {
        Client::new("http://1.2.3.4".to_string())
    }

    #[test]
    async fn client_generates_constant_at_level_1() {
        let mut client = client();

        let (input, _) = client.generate_expr();

        match parse(&input)[..] {
            [Value::Num(_)] => (),
            _ => panic!("Expected constant 3"),
        }
    }

    #[test]
    async fn client_generates_different_inputs_on_each_call() {
        let mut client = client();

        let (input1, _) = client.generate_expr();
        let (input2, _) = client.generate_expr();

        assert_ne!(input1, input2);
    }

    #[test]
    async fn client_generates_ascii_variables_at_level_2() {
        let mut client = client();
        client.grade = 2;

        let (input, _) = client.generate_expr();

        let parsed = parse(&input);
        match &parsed[..] {
            [Value::Sym(name)] => {
                println!("{}", name);
                assert!(name.chars().all(|c| c.is_ascii_alphanumeric()));
            }
            _ => panic!("Expected symbol, got {:?}", parsed),
        }
    }

    #[test]
    async fn client_generates_unicode_variables_at_level_3() {
        let mut client = client();
        client.grade = 3;

        let (input, _) = client.generate_expr();

        let parsed = parse(&input);
        match &parsed[..] {
            [Value::Sym(_)] => (),
            _ => panic!("Expected symbol, got {:?}", parsed),
        }
    }

    #[test]
    async fn client_generates_binary_application_at_level_4() {
        let mut client = client();
        client.grade = 4;

        let (input, _) = client.generate_expr();

        let parsed = parse(&input);
        match &parsed[..] {
            [Value::App(_, _)] => (),
            _ => panic!("Expected symbol, got {:?}", parsed),
        }
    }

    #[test]
    async fn client_generates_nested_applications_and_constants_at_level_5() {
        let mut client = client();
        client.grade = 5;

        let (input, _) = client.generate_expr();

        let parsed = parse(&input);
        match &parsed[..] {
            [Value::App(_, _)] => (),
            [Value::Sym(_)] => (),
            [Value::Num(_)] => (),
            _ => panic!("Expected symbol, got {:?}", parsed),
        }
    }

    #[test]
    async fn client_generates_lambda_terms_at_level_6() {
        let mut client = client();
        client.grade = 6;

        let (input, _) = client.generate_expr();

        let parsed = parse(&input);
        match &parsed[..] {
            [Value::Lam(_, _)] => (),
            _ => panic!("Expected symbol, got {:?}", parsed),
        }
    }

    #[test]
    async fn client_generates_application_with_lambda_terms_at_level_7() {
        let mut client = client();
        client.grade = 7;

        let (input, _) = client.generate_expr();

        let parsed = parse(&input);
        match &parsed[..] {
            [Value::App(t1, _)] if matches!(**t1, Value::Lam(_, _)) => (),
            _ => panic!("Expected symbol, got {:?}", parsed),
        }
    }

    #[test]
    async fn client_generates_applications_with_more_than_2_terms_at_level_8() {
        let mut client = client();
        client.grade = 8;

        let (input, _) = client.generate_expr();

        assert!(input.split(' ').count() > 2);
    }

    #[test]
    async fn client_generates_more_complex_terms_at_level_9() {
        let mut client = client();
        client.grade = 9;

        let (input, _) = client.generate_expr();

        let parsed = parse(&input);
        match &parsed[..] {
            _ => panic!("Expected term, got {:?}", parsed),
        }
    }

    #[test]
    async fn client_increases_grade_on_successful_test() {
        let mut client = client();
        let expected = "1".to_string();
        let response = Ok("1".to_string());

        let result = client.check_result(&expected, &response);

        assert_eq!(TestResult::TestSucceeded, result);
        assert_eq!(2, client.grade);
    }

    #[test]
    async fn client_does_not_increase_grade_on_failed_test() {
        let mut client = client();
        let expected = "1".to_string();
        let response = Ok("2".to_string());

        let result = client.check_result(&expected, &response);

        assert_eq!(TestResult::TestFailed("2".to_string()), result);
        assert_eq!(1, client.grade);
    }

    #[test]
    async fn client_starts_delay_to_next_test_at_10s() {
        let client = client();

        let delay = client.time_to_next_test();

        assert_eq!(std::time::Duration::from_secs(10), delay);
    }

    #[test]
    async fn client_increases_delay_to_next_upon_failed_test() {
        let mut client = client();
        let expected = "1".to_string();
        let response = Ok("2".to_string());
        let delay_before = client.time_to_next_test();

        client.check_result(&expected, &response);

        assert!(delay_before < client.time_to_next_test());
    }

    #[test]
    async fn client_increases_delay_to_maximum_of_30s() {
        let mut client = client();
        let expected = "1".to_string();
        let response = Ok("2".to_string());

        for _ in 0..100 {
            client.check_result(&expected, &response);
        }

        assert_eq!(Duration::from_secs(30), client.time_to_next_test());
    }

    #[test]
    async fn client_decreases_delay_to_next_upon_successful_test() {
        let mut client = client();
        let expected = "1".to_string();
        let response = Ok("1".to_string());
        let delay_before = client.time_to_next_test();

        client.check_result(&expected, &response);

        assert!(delay_before > client.time_to_next_test());
    }
}