session 0.1.8

iron session implementation based on redis
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

extern crate iron;
extern crate session;
extern crate rustc_serialize;
use iron::prelude::*;
use session::*;

// To run, $ cargo run --example complex
// to use, $ curl "http://localhost:3000/login"
//         $ curl "http://localhost:3000/show_count"
//         $ curl "http://localhost:3000/reset_count"
//         $ curl "http://localhost:3000/clear_allA"

#[derive(Debug,RustcEncodable, RustcDecodable)]
struct Account {
    id: usize,
    name: Option<String>,
    email: Option<String>,
}

fn main() {
    let mut chain = Chain::new(handle);
    let signing_key = "key-123456";
    let expire_seconds = 3600;
    let connect_str = "redis://localhost";
    chain.around(session::Session::new(signing_key, expire_seconds, connect_str));
    Iron::new(chain).http("localhost:3000").unwrap();
}

fn get_action(req: &Request) -> String {
    String::from(req.url.path()[0])
}


fn handle(req: &mut Request) -> IronResult<Response> {
    let action = get_action(req);
    match action.as_str() {
        "login" => login(req),
        "clear_all" => clear_all(req),
        "show_count" => show_count(req),
        "reset_count" => reset_count(req),
        _ => Ok(Response::with((iron::status::Ok, "login,logout,show_count,reset_count"))),
    }
}

fn login(req: &mut Request) -> IronResult<Response> {
    let account = match req.get_session::<Account>("account") {
        Ok(a) => a,
        Err(_) => {
            let account = Account {
                id: 1,
                name: Some("alex".to_owned()),
                email: None,
            };
            req.set_session("account", &account).unwrap();
            account
        }
    };
    let content = format!("user:{:?}", &account);
    Ok(Response::with((iron::status::Ok, content)))
}

fn clear_all(req: &mut Request) -> IronResult<Response> {
    req.clear_session().unwrap();
    Ok(Response::with((iron::status::Ok, "clear all")))
}

fn show_count(req: &mut Request) -> IronResult<Response> {
    let mut count = req.get_session::<usize>("count").unwrap_or(0);
    count += 1;
    req.set_session("count", &count).unwrap();
    Ok(Response::with((iron::status::Ok, format!("count:{}", &count))))
}

fn reset_count(req: &mut Request) -> IronResult<Response> {
    req.remove_session("count").unwrap();
    Ok(Response::with((iron::status::Ok, "count reset")))
}