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

#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate log;
extern crate colored;
extern crate env_logger;
extern crate failure;
#[macro_use]
extern crate futures;
extern crate bytes;
extern crate nitox;
extern crate nom;
extern crate serde_json;
extern crate tokio;
extern crate tokio_codec;
extern crate tokio_core;
extern crate tokio_io;
extern crate tokio_timer;
extern crate unicode_segmentation;
extern crate uuid;
extern crate ws;

extern crate epicboxlib;

mod broker;
mod server;

use broker::Broker;
use server::AsyncServer;
use std::net::ToSocketAddrs;

fn main() {
    env_logger::init();

    info!("hello, world!");

    let broker_uri = std::env::var("BROKER_URI")
        .unwrap_or_else(|_| "127.0.0.1:61613".to_string())
        .to_socket_addrs()
        .unwrap()
        .next();

    let username = std::env::var("BROKER_USERNAME").unwrap_or("guest".to_string());
    let password = std::env::var("BROKER_PASSWORD").unwrap_or("guest".to_string());

    let epicbox_domain = std::env::var("EPICBOX_DOMAIN").unwrap_or("127.0.0.1".to_string());
    let epicbox_port = std::env::var("EPICBOX_PORT").unwrap_or("13420".to_string());
    let epicbox_port = u16::from_str_radix(&epicbox_port, 10).expect("invalid EPICBOX_PORT given!");
    let epicbox_protocol_unsecure = std::env::var("EPICBOX_PROTOCOL_UNSECURE")
        .map(|_| true)
        .unwrap_or(false);

    if broker_uri.is_none() {
        error!("could not resolve broker uri!");
        panic!();
    }

    let broker_uri = broker_uri.unwrap();

    let bind_address =
        std::env::var("BIND_ADDRESS").unwrap_or_else(|_| "0.0.0.0:13420".to_string());

    info!("Broker URI: {}", broker_uri);
    info!("Bind address: {}", bind_address);

    let mut broker = Broker::new(broker_uri, username, password);
    let sender = broker.start().expect("failed initiating broker session");
    let response_handlers_sender = AsyncServer::init();

    ws::Builder::new()
        .build(|out| {
            AsyncServer::new(
                out,
                sender.clone(),
                response_handlers_sender.clone(),
                &epicbox_domain,
                epicbox_port,
                epicbox_protocol_unsecure,
            )
        })
        .unwrap()
        .listen(&bind_address[..])
        .unwrap();
}