shors 0.13.0

Transport layer for cartridge + tarantool-module projects.
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

use super::Response;
use crate::tarantool::tlua;
use crate::tarantool::tlua::AnyLuaValue::LuaAnyString;
use crate::tarantool::tlua::{AnyLuaString, AnyLuaValue};
use crate::transport::http::Request;
use std::cell::RefCell;
use std::collections::HashMap;
use std::str::from_utf8;

const LUA_HTTP_SERVER: &str =
    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/lua/http_server.lua"));

pub trait LuaHttpHandler {
    fn handle(&self, req: Request) -> Response;
    fn method(&self) -> &str;
    fn path(&self) -> &str;
}

/// HTTP server route registry.
pub struct Server {
    /// Used to register and unregister HTTP routes
    /// associated with the current service instance
    registered_routes: RefCell<Vec<String>>,
}

impl Drop for Server {
    fn drop(&mut self) {
        self.unregister_all();
    }
}

#[allow(clippy::new_without_default)]
impl Server {
    pub fn new() -> Self {
        let lua = tarantool::lua_state();

        lua.exec(LUA_HTTP_SERVER).unwrap();

        Self {
            registered_routes: RefCell::new(vec![]),
        }
    }

    /// Unregister all routes previously registered by this server instance.
    ///
    /// This should be called during service shutdown or reload
    /// to ensure stale handlers  are removed and no longer accessible.
    pub fn unregister_all(&self) {
        let lua = tarantool::lua_state();
        let delete_handler = lua
            .get::<tlua::LuaFunction<_>, _>("delete_handler")
            .expect("delete_handler not found");

        for route_name in self.registered_routes.borrow().iter() {
            delete_handler
                .call_with_args::<(), _>((route_name.clone(),))
                .ok();
        }
        self.registered_routes.borrow_mut().clear();
    }

    /// Register http route as prepared for serve.
    pub fn register(&self, route: Box<dyn LuaHttpHandler>) {
        let lua = tarantool::lua_state();

        let path = route.path().to_string();
        let method = route.method().to_string();
        let lua_handler = tlua::function8(
            move |method: String,
                  path: String,
                  query: String,
                  headers: HashMap<String, String>,
                  stash: HashMap<String, String>,
                  proto: Vec<i32>,
                  peer: HashMap<String, AnyLuaValue>,
                  body: AnyLuaString| {
                let proto: [i32; 2] = proto.try_into().unwrap_or_default();
                let lpeer: HashMap<String, String> = peer
                    .into_iter()
                    .filter_map(|(k, v)| match v {
                        AnyLuaValue::LuaString(s) => Some((k, s)),
                        AnyLuaValue::LuaAnyString(s) => {
                            Some((k, from_utf8(s.as_bytes()).ok().map(|s| s.to_owned())?))
                        }
                        AnyLuaValue::LuaNumber(f) => Some((k, format!("{}", f))),
                        _ => None,
                    })
                    .collect();

                let res = route.handle(Request {
                    method,
                    path,
                    query,
                    headers,
                    stash,
                    body: body.as_bytes().to_vec(),
                    proto: proto.into(),
                    peer: lpeer.into(),
                });
                (
                    res.status,
                    LuaAnyString(AnyLuaString(res.body)),
                    res.headers,
                )
            },
        );

        let route_name = format!("{}:{}", method, path);
        lua.get::<tlua::LuaFunction<_>, _>("register_handler")
            .unwrap()
            .call_with_args::<(), _>((path, method, lua_handler))
            .expect("register route fail");
        self.registered_routes.borrow_mut().push(route_name);
    }
}