argos 0.1.0

Argos makes it easy to create a stand-alone web application backend server.
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

use std::fmt::Display;
use argos_macros::{route, register};
use serde_json;
use serde::{Deserialize, Serialize};
use argos::{server::Server, request::HttpRequest, error::ReturnError};

#[derive(Serialize, Deserialize)]
pub struct Hello {
    name: String,
    greeting: String,
}

#[derive(Serialize, Deserialize, Clone)]
pub struct MyError {
    code: u32,
    msg: String,
}

impl Display for MyError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{{code:{}, msg:{}}}", self.code, self.msg)
    }
}

#[route(GET, path = "/api/hello", formatter = "json")]
pub fn hello(req: HttpRequest) -> Result<Hello, ReturnError<MyError>> {
    let url_params = req.url_params();
    let name = url_params.get("name");
    // let path_params = req.path_params();
    use std::{thread, time};
    let millis = time::Duration::from_millis(800);
    thread::sleep(millis);
    match name {
        Some(name) => Ok(Hello { name: name.to_string(), greeting: "hello".to_string() }),
        None => Err(
            ReturnError::new(
                400,
                MyError { code: 1, msg: "name is required".to_string() },
            ),
        )
    }
}

#[tokio::main]
async fn main() {
    let server = Server::builder(([127, 0, 0, 1], 3000).into())
        .h2()
        .ssl(
            "core/examples/rsa_private.key", 
            "core/examples/cert.crt", 
            argos::server::SslFiletype::PEM,
        ).unwrap()
        .build()
        .await
        .unwrap();
    server.start().await.unwrap();
}