bronze 0.1.0

A rust coap server framework. (Early, but functional.)
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

extern crate mio;

use message::Message;

use mio::*;
use mio::udp::{UdpSocket};
use std::net::SocketAddr;

const SERVER: Token = Token(0);

pub struct Endpoint {
    local_addr: SocketAddr,
}

impl Endpoint {
    pub fn new(local_addr: SocketAddr) -> Endpoint {
        Endpoint{local_addr: local_addr}
    }

/*
    pub fn run_raw(self, handler: fn(&[u8], SocketAddr) -> Option<Vec<u8>>) {
        let server = UdpSocket::bound(&self.local_addr).unwrap();

        let mut event_loop = EventLoop::new().unwrap();
        event_loop.register(&server, SERVER, EventSet::readable(), PollOpt::edge()).unwrap();
        event_loop.run(&mut ServerHandler::new(server, handler)).unwrap();
    }
*/

    pub fn run<H: RequestHandler>(self, handler: H) {
        //Self::run_raw(self, (handler).handle_request);
        let server = UdpSocket::bound(&self.local_addr).unwrap();

        let mut event_loop = EventLoop::new().unwrap();
        event_loop.register(&server, SERVER, EventSet::readable(), PollOpt::edge()).unwrap();
        event_loop.run(&mut ServerHandler::new(server, handler)).unwrap();
    }
}

pub trait RequestHandler {
    fn handle_request(&self, SocketAddr, &[u8]) -> Option<Vec<u8>>;
}

struct ServerHandler<H>{
    sock: UdpSocket,
    handler: H
}

impl<H: RequestHandler>  ServerHandler<H> {
    fn new(sock: UdpSocket, handler: H) -> ServerHandler<H> {
        ServerHandler{
            sock: sock,
            handler: handler
        }
    }
}

impl<H: RequestHandler> Handler for ServerHandler<H> {
    type Timeout = ();
    type Message = ();

    fn ready(&mut self, _event_loop: &mut EventLoop<ServerHandler<H>>, token: Token, _: EventSet) {
        match token {
            SERVER => {
                let mut buf: [u8; 2048] = [0; 2048];
                let (len, addr) = self.sock.recv_from(&mut buf).unwrap().unwrap();

                let pkt = &buf[..len];

                match (self.handler).handle_request(addr, pkt) {
                    Some(resp) => {
                        self.sock.send_to(&resp, &addr).unwrap_or(None); // UDP is best-effort, right?
                    },
                    None => ()
                }
            }
            _ => panic!("unexpected token"),
        }
    }

    fn notify(&mut self, _event_loop: &mut EventLoop<Self>, _msg: Self::Message) {
        println!("notify");
    }

    fn interrupted(&mut self, _event_loop: &mut EventLoop<Self>) {
        println!("interrupted");
    }
}