antimony 0.0.1

A topology builder crate for Antimony.
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

pub mod spout;
pub mod bolt;

use rustc_serialize::json;
use tokio_core::net::TcpStream;
use tokio_io;
use futures::Future;
use std;
use tokio_uds::UnixStream;


pub struct ComponentConfig{
    pub sock_file: String,
    pub component_id: String
}

#[derive(Debug)]
#[derive(RustcEncodable, RustcDecodable)]
pub enum Message{
    Tuple(String, String), //stream, data
    Local(String), //local instances' ids (sent to SM)
    Ready,
    Metrics,
    HeartBeat
}

impl Message{
    pub fn from_tcp(stream: TcpStream) -> Box<Future<Item = (Self), Error = std::io::Error >> {
        let buf = [0; 4];
        Box::new(tokio_io::io::read(stream, buf).and_then(|x| {
            let len = usize::from_str_radix(&String::from_utf8(x.1.to_vec()).unwrap(), 16).unwrap();
            let buf = vec![0; len];
            tokio_io::io::read_exact(x.0, buf).and_then(|x| {
                Ok(json::decode(&String::from_utf8(x.1.to_vec()).unwrap()).unwrap())
            })
        }))
    }

    pub fn from_half_uds(stream: tokio_io::io::ReadHalf<UnixStream>) -> Box<Future<Item = ((Self, tokio_io::io::ReadHalf<UnixStream>)), Error = std::io::Error > + Send>{
        let buf = [0; 4];
        Box::new(tokio_io::io::read(stream, buf).and_then(|x| {
            let len = usize::from_str_radix(&String::from_utf8(x.1.to_vec()).unwrap(), 16).unwrap();
            let buf = vec![0; len];
            tokio_io::io::read_exact(x.0, buf).and_then(|x| {
                Ok((json::decode(&String::from_utf8(x.1.to_vec()).unwrap()).unwrap(), x.0))
            })
        }))
    }

    pub fn to_uds(&self, stream: UnixStream) -> Box<Future<Item = (UnixStream), Error = std::io::Error > + Send> {
            Box::new(tokio_io::io::write_all(stream, self.encoded()).and_then(|c| Ok(c.0)))
    }

    pub fn to_half_uds(&self, stream: tokio_io::io::WriteHalf<UnixStream>) -> Box<Future<Item = (tokio_io::io::WriteHalf<UnixStream>), Error = std::io::Error > + Send> {
            Box::new(tokio_io::io::write_all(stream, self.encoded()).and_then(|c| Ok(c.0)))
    }

    pub fn encoded(&self) -> Vec<u8>{
        let message = json::encode(&self).unwrap();
        let message = format!("{:04x}{}", message.len(), message);
        message.as_bytes().to_vec()
    }

    pub fn decoded(){
        unimplemented!();
    }

    pub fn tuple(stream: &str, value: &str) -> Self{
        Message::Tuple(stream.to_string(), value.to_string())
    }
}