swindon 0.7.8

An HTTP edge (frontend) server with smart websockets support 
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

use std::thread::spawn;
use std::sync::Arc;
use std::time::Instant;
use std::sync::mpsc::{channel, Sender};
use futures::sync::mpsc::{UnboundedSender as ChannelSender};


use intern::SessionPoolName;
use config;
use super::{Event, Action, PoolMessage};
use super::main;


#[derive(Clone)]
pub struct Processor {
    queue: Sender<Event>,
}

#[derive(Clone)]
pub struct ProcessorPool {
    pool_name: SessionPoolName,
    queue: Sender<Event>,
}


impl Processor {
    pub fn new() -> Processor {
        let (tx, rx) = channel();
        spawn(move || {
            main::run(rx)
        });
        return Processor {
            queue: tx,
        }
    }

    pub fn create_pool(&self, name: &SessionPoolName,
        config: &Arc<config::SessionPool>, channel: ChannelSender<PoolMessage>)
    {
        self.queue.send(Event {
            pool: name.clone(),
            timestamp: Instant::now(),
            action: Action::NewSessionPool {
                config: config.clone(),
                channel: channel,
            },
        }).map_err(|e| panic!("Processor loop send error: {}", e)).ok();
    }

    pub fn destroy_pool(&self, name: &SessionPoolName) {
        self.queue.send(Event {
            pool: name.clone(),
            timestamp: Instant::now(),
            action: Action::StopSessionPool,
        }).map_err(|e| panic!("Processor loop send error: {}", e)).ok();
    }

    pub fn pool(&self, name: &SessionPoolName)
        -> ProcessorPool
    {
        ProcessorPool {
            pool_name: name.clone(),
            // TODO(tailhook) Should we reference Processor instead
            queue: self.queue.clone(),
        }
    }

    /// Send directly without getting pool
    #[allow(dead_code)]
    pub fn send(&self, pool: &SessionPoolName, action: Action) {
        debug!("Sending pool action {:?} {:?}", pool, action);
        self.queue.send(Event {
            pool: pool.clone(),
            timestamp: Instant::now(),
            action: action,
        }).map_err(|e| panic!("Error invoking processor: {}", e)).ok();
    }
}

impl ProcessorPool {
    pub fn send(&self, action: Action) {
        debug!("Sending pool action {:?} {:?}", self.pool_name, action);
        self.queue.send(Event {
            pool: self.pool_name.clone(),
            timestamp: Instant::now(),
            action: action,
        }).map_err(|e| panic!("Error invoking processor: {}", e)).ok();
    }
}