unki/bin/u_server/src/main.rs

mod handlers;
mod db;
mod errors;

use warp::{
    Filter,
    Rejection,
    Reply,
    body
};

extern crate log;
extern crate env_logger;

use u_lib::{
    MASTER_PORT,
    api::Paths,
    models::*
};
use db::*;
use serde::{
    de::DeserializeOwned
};
use uuid::Uuid;

fn get_content<M>()
        -> impl Filter<Extract = (BaseMessage<'static, M>,),
        Error = Rejection> + Clone
where
    M: ToMsg + Sync + Send + DeserializeOwned + 'static
{
    body::content_length_limit(1024*64)
        .and(body::json::<BaseMessage<M>>())
}


#[tokio::main]
async fn main() {
    env_logger::init();

    let base_db = UDB::new().unwrap();
    let db = warp::any().map(move || base_db.clone());
    let infallible_none = |_| async {
        Ok::<(Option<Uuid>,), std::convert::Infallible>((None,))
    };

    let new_agent = warp::post()
        .and(warp::path(Paths::init))
        .and(get_content::<IAgent>())
        .and(db.clone())
        .and_then(handlers::add_agent);

    let get_agents = warp::get()
        .and(warp::path(Paths::get_agents))
        .and(warp::path::param::<Uuid>().map(Some).or_else(infallible_none))
        .and(db.clone())
        .and_then(handlers::get_agents);

    let upload_jobs = warp::post()
        .and(warp::path(Paths::upload_jobs))
        .and(get_content::<Vec<JobMeta>>())
        .and(db.clone())
        .and_then(handlers::upload_jobs);

    let get_jobs = warp::get()
        .and(warp::path(Paths::get_jobs))
        .and(warp::path::param::<Uuid>().map(Some).or_else(infallible_none))
        .and(db.clone())
        .and_then(handlers::get_jobs);

    let get_agent_jobs = warp::get()
        .and(warp::path(Paths::get_agent_jobs))
        .and(warp::path::param::<Uuid>().map(Some).or_else(infallible_none))
        .and(db.clone())
        .and_then(|uid, db| handlers::get_agent_jobs(uid, db, false));

    let get_personal_jobs = warp::get()
        .and(warp::path(Paths::get_agent_jobs))
        .and(warp::path::param::<Uuid>().map(Some).or_else(infallible_none))
        .and(db.clone())
        .and_then(|uid, db| handlers::get_agent_jobs(uid, db, true));

    let del = warp::get()
        .and(warp::path(Paths::del))
        .and(warp::path::param::<Uuid>())
        .and(db.clone())
        .and_then(handlers::del);

    let set_jobs = warp::post()
        .and(warp::path(Paths::set_jobs))
        .and(warp::path::param::<Uuid>())
        .and(get_content::<Vec<Uuid>>())
        .and(db.clone())
        .and_then(handlers::set_jobs);

    let report = warp::post()
        .and(warp::path(Paths::report))
        .and(get_content::<Vec<JobResult>>())
        .and(db.clone())
        .and_then(handlers::report);

    let get_results = warp::get()
        .and(warp::path(Paths::get_results))
        .and(warp::path::param::<Uuid>().map(Some).or_else(infallible_none))
        .and(db.clone())
        .and_then(handlers::get_results);

    let auth_token = warp::header::exact("authorization", "Bearer 123qwe");

    let agent_zone = new_agent
        .or(get_personal_jobs)
        .or(report)
        ;

    let auth_zone = auth_token
        .and(
            get_agents
                .or(get_jobs)
                .or(upload_jobs)
                .or(del)
                .or(set_jobs)
                .or(get_agent_jobs)
                .or(get_results)
        );

    let routes = agent_zone
        .or(auth_zone);
    warp::serve(routes.with(warp::log("warp")))
        .run(([0,0,0,0], MASTER_PORT)).await;
}


#[cfg(test)]
mod tests {
    use super::*;
/*
    #[tokio::test]
    async fn test_gather() {
    }
*/
}