nightfly 0.1.6

higher level HTTP client library for the lunatic runtime
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

use lunatic::Tag;
use serde::{Deserialize, Serialize};

// TODO: remove once done converting to new support server?
#[allow(unused)]
pub static DEFAULT_USER_AGENT: &str =
    concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));

// fn ensure_server(server: Fn(req: RequestContext) -> submillisecond::response::Response) {
//     if let Some(_) = Process::<Process<()>>::lookup("__server__") {
//         return;
//     }
//     ServerSup::start("__server__".to_owned(), None);
// }

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct DummyError;
pub struct DummyProcess;

#[lunatic::abstract_process]
impl DummyProcess {
    #[init]
    fn init(_: lunatic::ap::Config<Self>, _: ()) -> Result<Self, DummyError> {
        Ok(Self)
    }

    #[terminate]
    fn terminate(self) {
        println!("Shutdown process");
    }

    #[handle_link_death]
    fn handle_link_trapped(&self, _: Tag) {
        println!("Link trapped");
    }
}

#[macro_export]
macro_rules! wrap_server {
    ($name:ident, $router:ident, $addr:ident) => {
        mod $name {

            use lunatic::{
                abstract_process, spawn_link,
                supervisor::{Supervisor, SupervisorStrategy},
                AbstractProcess, Process, Tag,
            };
            use submillisecond::Application;

            struct ServerProcess(Process<()>);
            struct ServerSup;

            #[abstract_process]
            impl ServerProcess {
                #[init]
                fn init(
                    _: lunatic::ap::Config<Self>,
                    _: (),
                ) -> Result<Self, crate::support::DummyError> {
                    Ok(Self(spawn_link!(|| {
                        Application::new(super::$router)
                            .serve(super::$addr)
                            .unwrap();
                    })))
                }

                #[terminate]
                fn terminate(self) {
                    println!("Shutdown process");
                }

                #[handle_link_death]
                fn handle_link_trapped(&self, _: Tag) {
                    println!("Link trapped");
                }
            }

            impl Supervisor for ServerSup {
                type Arg = String;
                type Children = (ServerProcess, crate::support::DummyProcess);

                fn init(config: &mut lunatic::supervisor::SupervisorConfig<Self>, name: Self::Arg) {
                    // If a child fails, just restart it.
                    config.set_strategy(SupervisorStrategy::OneForOne);
                    // Start One `ServerProcess`
                    config.children_args((((), None), ((), None)));
                }
            }

            pub fn ensure_server() {
                let name = format!("__{}__", stringify!($name));
                if let Some(_) = Process::<Process<()>>::lookup(&name) {
                    return;
                }
                ServerSup::start(name.to_owned()).expect("should have started server");
            }
        }
    };
}

pub type RouterFn =
    fn() -> fn(req: ::submillisecond::RequestContext) -> ::submillisecond::response::Response;