slacker 0.1.3

Slacker server built on top of tokio.
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
116
117

#![allow(dead_code, unused_must_use)]
#[macro_use]
extern crate log;
#[macro_use]
extern crate nom;

extern crate tokio_io as tio;
extern crate tokio_core as tcore;
extern crate tokio_proto as tproto;
extern crate tokio_service as tservice;
extern crate futures;
extern crate futures_cpupool;
extern crate serde;
extern crate serde_json;
extern crate bytes;
extern crate byteorder;

mod codecs;
mod parser;
mod service;
mod serializer;
mod client;
mod json;

use tproto::TcpServer;
use tproto::multiplex::{ClientProto, ServerProto};
use tio::AsyncRead;
use tio::codec::Framed;
use tcore::net::TcpStream;

use std::collections::BTreeMap;
use std::io;
use std::sync::Arc;
use std::net::SocketAddr;

use codecs::*;
use serializer::*;
use parser::*;
use service::*;
use json::*;
pub use json::{JsonRpcFn, JsonRpcFnSync};
pub use client::{Client, ClientManager};

impl ServerProto<TcpStream> for JsonSlacker {
    type Request = SlackerPacket;
    type Response = SlackerPacket;
    type Transport = Framed<TcpStream, SlackerCodec>;
    type BindTransport = io::Result<Self::Transport>;

    fn bind_transport(&self, io: TcpStream) -> Self::BindTransport {
        io.set_nodelay(true);
        Ok(io.framed(SlackerCodec))
    }
}

pub struct Server {
    addr: SocketAddr,
    funcs: Arc<BTreeMap<String, JsonRpcFn>>,
}

impl Server {
    pub fn new(addr: SocketAddr, funcs: BTreeMap<String, JsonRpcFn>) -> Self {
        Server {
            addr,
            funcs: Arc::new(funcs),
        }
    }

    pub fn serve(&self) {
        let serializer = Arc::new(JsonSerializer);
        let funcs_ref = self.funcs.clone();
        TcpServer::new(JsonSlacker, self.addr).serve(move || {
            Ok(SlackerService::new(funcs_ref.clone(), serializer.clone()))
        });
    }
}

pub struct ThreadPoolServer {
    addr: SocketAddr,
    funcs: Arc<BTreeMap<String, JsonRpcFnSync>>,
    threads: usize,
}

impl ThreadPoolServer {
    pub fn new(addr: SocketAddr, funcs: BTreeMap<String, JsonRpcFnSync>, threads: usize) -> Self {
        ThreadPoolServer {
            addr,
            funcs: Arc::new(funcs),
            threads,
        }
    }

    pub fn serve(&self) {
        let serializer = Arc::new(JsonSerializer);
        let funcs_ref = self.funcs.clone();
        let threads = self.threads;
        TcpServer::new(JsonSlacker, self.addr).serve(move || {
            Ok(SlackerServiceSync::new(
                funcs_ref.clone(),
                serializer.clone(),
                threads,
            ))
        });
    }
}

impl ClientProto<TcpStream> for JsonSlacker {
    type Request = SlackerPacket;
    type Response = SlackerPacket;
    type Transport = Framed<TcpStream, SlackerCodec>;
    type BindTransport = io::Result<Self::Transport>;

    fn bind_transport(&self, io: TcpStream) -> Self::BindTransport {
        io.set_nodelay(true);
        Ok(io.framed(SlackerCodec))
    }
}