chalkydri/api/

mod.rs

//!
//! JSON API used by the web UI and possibly third-party applications
//!

use actix_web::{
    App, HttpResponse, HttpServer, Responder, get,
    http::{
        StatusCode,
        header::{self, CacheDirective},
    },
    post, put,
    web::{self, Data},
};
use mime_guess::from_path;
use rust_embed::Embed;
use rustix::system::RebootCommand;
use sysinfo::System;
use utopia::{OpenApi, ToSchema};

use crate::{
    Cfg,
    cameras::CamManager,
    config::{self, Config},
};

#[derive(OpenApi)]
#[openapi(
    info(
        title = "Chalkydri Manager API",
        version = env!("CARGO_PKG_VERSION"),
    ),
    paths(
        info,
        configuration,
        configure,
        save_configuration,
        calibration_intrinsics,
        calibration_status,
        calibration_step,
        restart,
        sys_reboot,
        sys_shutdown,
    )
)]
#[allow(dead_code)]
struct ApiDoc;

#[derive(rust_embed::Embed)]
#[folder = "../../ui/build/"]
struct Assets;

fn handle_embedded_file(path: &str) -> HttpResponse {
    match <Assets as Embed>::get(path) {
        Some(content) => HttpResponse::Ok()
            .content_type(from_path(path).first_or_octet_stream().as_ref())
            .body(content.data.into_owned()),
        None => HttpResponse::NotFound().body("404 Not Found"),
    }
}

#[get("/")]
async fn index() -> impl Responder {
    handle_embedded_file("index.html")
}

#[get("/api/openapi.json")]
async fn openapi_json() -> impl Responder {
    web::Json(ApiDoc::openapi())
}

#[get("/{_:.*}")]
async fn dist(path: web::Path<String>) -> impl Responder {
    if Assets::get(path.as_str()).is_some() {
        handle_embedded_file(path.as_str()).map_into_boxed_body()
    } else {
        HttpResponse::TemporaryRedirect()
            .insert_header(("Location", "/"))
            .body(())
            .map_into_boxed_body()
    }
}

/// Run the API server
pub async fn run_api(cam_man: CamManager) {
    HttpServer::new(move || {
        App::new()
            .app_data(Data::new(cam_man.clone()))
            .service(index)
            .service(info)
            .service(configuration)
            .service(configure)
            .service(save_configuration)
            .service(calibration_intrinsics)
            .service(calibration_status)
            .service(calibration_step)
            .service(restart)
            .service(sys_reboot)
            .service(sys_shutdown)
            .service(openapi_json)
            .service(stream)
            .service(dist)
    })
    .bind(("0.0.0.0", 6942))
    .unwrap()
    .run()
    .await
    .unwrap();
}

#[derive(Serialize, ToSchema)]
pub struct Info {
    pub version: &'static str,
    pub cpu_usage: u8,
    pub mem_usage: u8,
    pub new_cams: Vec<config::Camera>,
}

/// Get Chalkydri's version and system information
#[utopia::path(
    responses(
        (status = 200, body = Info),
    ),
)]
#[get("/api/info")]
pub(super) async fn info(data: web::Data<CamManager>) -> impl Responder {
    let mut system = System::new();
    system.refresh_cpu_usage();
    system.refresh_memory();

    let cpu_usage = (system.global_cpu_usage() * 100.0) as u8;
    let mem_usage = ((system.used_memory() as f64 / system.total_memory() as f64) * 100.0) as u8;

    let mut new_cams = Vec::new();
    while let Ok(cam) = data.new_dev_rx.lock().await.try_recv() {
        new_cams.push(cam);
    }

    web::Json(Info {
        version: env!("CARGO_PKG_VERSION"),
        cpu_usage,
        mem_usage,
        new_cams,
    })
}

/// List possible configurations
#[utopia::path(
    responses(
        (status = 200, body = Config),
    ),
)]
#[get("/api/configuration")]
pub(super) async fn configuration(data: web::Data<CamManager>) -> impl Responder {
    let cam_man = data.get_ref();

    cam_man.refresh_devices().await;

    let cfgg = Cfg.read().await.clone();

    //for cam in cam_man.devices() {
    //    if let Some(cameras) = &mut cfgg.cameras {
    //        if cameras.iter().filter(|c| c.id == cam.id).next().is_none() {
    //            cameras.push(cam);
    //        }
    //    } else {
    //        cfgg.cameras = Some(Vec::new());
    //        if let Some(cameras) = &mut cfgg.cameras {
    //            cameras.push(cam);
    //        }
    //    }
    //}

    web::Json(cfgg)
}

/// Set the configuration without saving it to the disk
#[utopia::path(
    responses(
        (status = 200, body = Config),
    ),
)]
#[post("/api/configuration")]
pub(super) async fn configure(
    data: web::Data<CamManager>,
    web::Json(cfgg): web::Json<Config>,
) -> impl Responder {
    let cam_man = data.get_ref();

    *Cfg.write().await = cfgg;
    cam_man.refresh_devices().await;

    let cfgg = Cfg.read().await.clone();
    if let Some(cams) = cfgg.cameras {
        for cam in cams {
            cam_man.update_pipeline(cam.id.clone()).await;
        }
    }

    web::Json(Cfg.read().await.clone())
}

/// Save the configuration to disk
#[utopia::path(
    responses(
        (status = 200, body = Config),
    ),
)]
#[put("/api/configuration")]
pub(super) async fn save_configuration(web::Json(cfgg): web::Json<Config>) -> impl Responder {
    let old_config = Cfg.read().await.clone();

    if cfgg.device_name != old_config.device_name {
        rustix::system::sethostname(cfgg.device_name.clone().unwrap().as_bytes()).unwrap();
    }

    cfgg.save("chalkydri.toml").await.unwrap();

    web::Json(cfgg)
}

/// Calibrate the given camera's intrinsic parameters
#[utopia::path(
    responses(
        (status = 200),
    ),
)]
#[get("/api/calibrate/{cam_name}/intrinsics")]
pub(super) async fn calibration_intrinsics(
    path: web::Path<String>,
    data: web::Data<CamManager>,
) -> impl Responder {
    let cam_name = path.to_string();

    //let cam_man = data.get_ref();
    //let calibrated_model = cam_man
    //    .calibrators()
    //    .await
    //    .get_mut(&cam_name)
    //    .unwrap()
    //    .calibrate()
    //    .unwrap();
    //{
    //    let json = serde_json::to_value(calibrated_model).unwrap();
    //    let cfgg = &mut (*Cfg.write().await);
    //    if let Some(cams) = &mut cfgg.cameras {
    //        (*cams)
    //            .iter_mut()
    //            .filter(|cam| cam.id == cam_name)
    //            .next()
    //            .unwrap()
    //            .calib = Some(json);
    //    }
    //}

    HttpResponse::new(StatusCode::OK)
}

#[derive(Serialize, ToSchema)]
struct CalibrationStatus {
    width: u32,
    height: u32,
    current_step: usize,
    total_steps: usize,
}

#[utopia::path(
    responses(
        (status = 200, body = CalibrationStatus),
    ),
)]
#[get("/api/calibrate/status")]
pub(super) async fn calibration_status(data: web::Data<CamManager>) -> impl Responder {
    let cam_man = data.get_ref();

    web::Json(CalibrationStatus {
        width: 1280,
        height: 720,
        current_step: 0,
        total_steps: 200,
    })
}

/// Complete a calibration step for the given camera
#[utopia::path(
    responses(
        (status = 200),
    ),
)]
#[get("/api/calibrate/{cam_name}/step")]
pub(super) async fn calibration_step(
    path: web::Path<String>,
    data: web::Data<CamManager>,
) -> impl Responder {
    let cam_name = path.to_string();

    let cam_man = data.get_ref();
    let current_step = 0; //cam_man.calib_step(cam_name).await;

    web::Json(CalibrationStatus {
        width: 1280,
        height: 720,
        current_step,
        total_steps: 200,
    })
}

/// Restart Chalkydri
#[utopia::path(
    responses(
        (status = 200),
    )
)]
#[post("/api/restart")]
pub(super) async fn restart(data: web::Data<CamManager>) -> impl Responder {
    //data.restart().await;

    HttpResponse::Ok().await.unwrap()
}

/// Restart the system
#[utopia::path(
    responses(
        (status = 200),
    )
)]
#[post("/api/sys/reboot")]
pub(super) async fn sys_reboot() -> impl Responder {
    rustix::system::reboot(RebootCommand::Restart).unwrap();

    web::Json(())
}

/// Power off the system
#[utopia::path(
    responses(
        (status = 200),
    )
)]
#[post("/api/sys/shutdown")]
pub(super) async fn sys_shutdown() -> impl Responder {
    rustix::system::reboot(RebootCommand::PowerOff).unwrap();

    web::Json(())
}

#[derive(Serialize)]
struct SysInfo {
    uptime: u64,
    mem_usage: u8,
}

/// Get system information
#[utopia::path(
    responses(
        (status = 200),
    )
)]
#[get("/api/sys/info")]
pub(super) async fn sys_info() -> impl Responder {
    let sysinfo = rustix::system::sysinfo();
    let mut system = sysinfo::System::new();
    system.refresh_cpu_usage();

    let uptime = sysinfo.uptime as u64;
    let mem_usage =
        (((sysinfo.totalram - sysinfo.freeram) as f32 / sysinfo.totalram as f32) * 100.0) as u8;

    web::Json(SysInfo { uptime, mem_usage })
}

/// Get an MJPEG camera stream for the given camera
#[get("/stream/{cam_name}")]
pub(super) async fn stream(path: web::Path<String>, data: web::Data<CamManager>) -> impl Responder {
    let cam_name = path.clone();

    println!("{cam_name}");

    let mjpeg_stream = data.pipelines.read().await.get(&cam_name).unwrap().mjpeg_preproc.inner().clone();
        drop(data);

        HttpResponse::Ok()
            .append_header(header::CacheControl(vec![CacheDirective::NoCache]))
            .append_header((header::PRAGMA, "no-cache"))
            .append_header((header::EXPIRES, 0))
            .append_header((header::CONNECTION, "close"))
            .append_header((
                header::CONTENT_TYPE,
                "multipart/x-mixed-replace; boundary=frame",
            ))
            .streaming(mjpeg_stream.clone())
}