micro_traffic_sim 0.1.12

gRPC interface for microscopic traffic simulation via cellular automata
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

use std::sync::{Arc, Mutex};
use std::time::Duration;
use tonic::{Code, Request, Response, Status};
use uuid::Uuid;

use micro_traffic_sim::pb;
use micro_traffic_sim_core::geom::SRID;
use micro_traffic_sim_core::simulation::session::Session;
use micro_traffic_sim_core::simulation::sessions_storage::SessionsStorage;
use micro_traffic_sim_core::verbose::VerboseLevel;

pub async fn new_session(
    sessions: Arc<Mutex<SessionsStorage>>,
    session_verbose: VerboseLevel,
    request: Request<pb::SessionReq>,
) -> Result<Response<pb::NewSessionResponse>, Status> {
    let srid = match request.into_inner().srid {
        4326 => Some(SRID::WGS84),
        0 => Some(SRID::Euclidean),
        _ => None, // defaults inside Session::default
    };

    let mut session = Session::default(srid);
    session.set_verbose_level(session_verbose);
    let sid = session.get_id();

    let ttl = Some(Duration::from_secs(4 * 60));
    let mut guard = sessions.lock().map_err(|_| Status::internal("storage poisoned"))?;
    let _ = guard.register_session(sid, session, ttl);
    drop(guard);

    let resp = pb::NewSessionResponse {
        code: Code::Ok as u32,
        text: Code::Ok.to_string(),
        id: Some(pb::UuiDv4 { value: sid.to_string() }),
    };
    Ok(Response::new(resp))
}

pub async fn info_session(
    sessions: Arc<Mutex<SessionsStorage>>,
    request: Request<pb::UuiDv4>,
) -> Result<Response<pb::InfoSessionResponse>, Status> {
    let id = request.into_inner().value;
    let sid = Uuid::parse_str(&id).map_err(|_| Status::invalid_argument("invalid UUID"))?;

    let mut guard = sessions.lock().map_err(|_| Status::internal("storage poisoned"))?;
    // with_session_mut extends TTL; we just check presence
    let found = guard.with_session_mut(&sid, |sess| sess.get_id()).is_some();
    drop(guard);

    if !found {
        let resp = pb::InfoSessionResponse {
            code: Code::NotFound as u32,
            text: Code::NotFound.to_string(),
            data: None,
        };
        return Ok(Response::new(resp));
    }

    let resp = pb::InfoSessionResponse {
        code: Code::Ok as u32,
        text: Code::Ok.to_string(),
        data: Some(pb::Session { id: Some(pb::UuiDv4 { value: sid.to_string() }) }),
    };
    Ok(Response::new(resp))
}