#[macro_use]
extern crate log;
#[macro_use]
extern crate hyper;
extern crate case;
extern crate crypto;
extern crate serde;
extern crate serde_json;
extern crate hex;
mod hook;
mod events;
pub use events::Event;
pub use hook::{AuthenticateHook, Hook};
use hyper::server::{Handler, Request, Response};
use std::collections::HashMap;
use std::io::Read;
header! {(XHubSignature, "X-Hub-Signature") => [String]}
header! {(XGithubEvent, "X-Github-Event") => [String]}
header! {(XGithubDelivery, "X-Github-Delivery") => [String]}
#[derive(Debug)]
pub struct Delivery<'a> {
pub id: &'a str,
pub event: &'a str,
pub payload: Event,
pub unparsed_payload: &'a str,
pub signature: Option<&'a str>,
}
impl<'a> Delivery<'a> {
pub fn new(id: &'a str,
event: &'a str,
payload: &'a str,
signature: Option<&'a str>)
-> Option<Delivery<'a>> {
let patched = events::patch_payload_json(event, payload);
match serde_json::from_str::<Event>(&patched) {
Ok(parsed) => {
Some(Delivery {
id: id,
event: event,
payload: parsed,
unparsed_payload: payload,
signature: signature,
})
}
Err(e) => {
error!("failed to parse json {:?}\n{:#?}", e, patched);
None
}
}
}
}
#[derive(Default)]
pub struct Hub {
hooks: HashMap<String, Vec<Box<Hook>>>,
}
impl Hub {
pub fn new() -> Hub {
Hub { ..Default::default() }
}
pub fn handle_authenticated<H, S>(&mut self, event: &str, secret: S, hook: H)
where H: Hook + 'static,
S: Into<String>
{
self.handle(event, AuthenticateHook::new(secret, hook))
}
pub fn handle<H>(&mut self, event: &str, hook: H)
where H: Hook + 'static
{
self.hooks
.entry(event.to_owned())
.or_insert(vec![])
.push(Box::new(hook));
}
pub fn hooks(&self, event: &str) -> Option<Vec<&Box<Hook>>> {
let explicit = self.hooks.get(event);
let implicit = self.hooks.get("*");
let combined = match (explicit, implicit) {
(Some(ex), Some(im)) => {
Some(ex.iter().chain(im.iter()).into_iter().collect::<Vec<_>>())
}
(Some(ex), _) => Some(ex.into_iter().collect::<Vec<_>>()),
(_, Some(im)) => Some(im.into_iter().collect::<Vec<_>>()),
_ => None,
};
combined
}
}
impl Handler for Hub {
fn handle(&self, mut req: Request, res: Response) {
let headers = req.headers.clone();
if let (Some(&XGithubEvent(ref event)), Some(&XGithubDelivery(ref delivery))) =
(headers.get::<XGithubEvent>(), headers.get::<XGithubDelivery>()) {
let signature = headers.get::<XHubSignature>();
info!("recv '{}' event with signature '{:?}'", event, signature);
if let Some(hooks) = self.hooks(event) {
let mut payload = String::new();
if let Ok(_) = req.read_to_string(&mut payload) {
match Delivery::new(delivery,
event,
payload.as_ref(),
signature.map(|s| s.as_ref())) {
Some(delivery) => {
for hook in hooks {
hook.handle(&delivery);
}
}
_ => {
error!("failed to parse event {:?} for delivery {:?}",
event,
delivery)
}
}
}
}
}
let _ = res.send(b"ok");
()
}
}
#[cfg(test)]
mod tests {
use super::{Delivery, Hub};
#[test]
fn hub_hooks() {
let mut hub = Hub::new();
hub.handle("push", |_: &Delivery| {});
hub.handle("*", |_: &Delivery| {});
assert_eq!(Some(2),
hub.hooks("push").map(|hooks| hooks.into_iter().count()))
}
}