xobs/revealjs-hosting
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rewrite using actix

Browse Source 
actix supports websocket, which iron does not.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2019-01-10 21:15:33 +08:00
parent 0f9110b36c
commit 881599d031
3 changed files with 901 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1037
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

20
Cargo.toml
View File

@ -4,22 +4,10 @@ version = "0.1.0"
authors = ["Sean Cross <sean@xobs.io>"]
edition = "2018"
#[dependencies]
#clap = "2.25"
#error-type = "0.1"
#futures = "0.1"
#futures-cpupool = "0.1"
#git2 = "0.8"
#http = "0.1"
#hyper = "0.12"
##hyper-staticfile = "0.3"
#serde_json = "1.0"
#websocket = "0.22"
[dependencies]
actix = "0.7"
actix-web = "0.7"
env_logger = "0.5"
git2 = "0.8"
iron = "0.6"
mount = "0.4"
http = "0.1"
serde_json = "1.0"
staticfile = "0.5"
websocket = "0.22"

118
src/main.rs
View File

@ -1,8 +1,11 @@
extern crate actix;
extern crate actix_web;
extern crate git2;
extern crate iron;
extern crate mount;
extern crate http;
extern crate serde_json;
extern crate staticfile;
extern crate env_logger;
// This example serves the docs from target/doc/staticfile at /doc/
//
@ -11,12 +14,12 @@ extern crate staticfile;
use std::path::{Path, PathBuf};
use std::error::Error;
use std::env;
use std::sync::{Arc, Mutex};
use iron::prelude::{Chain, Request, Response};
use iron::{status, Iron, IronResult};
use mount::Mount;
use staticfile::Static;
use actix_web::{
fs, middleware, server, App, HttpMessage, HttpRequest, HttpResponse
};
use git2::Repository;
struct WebHookConfig {
@ -42,44 +45,61 @@ fn redeploy_repo(url: &str, path: &Path, name: &str) -> Result<(), git2::Error>
};
repo.set_head("FETCH_HEAD")?;
// repo.checkout_tree(&branch.into_reference(), Some(git2::build::CheckoutBuilder::new().force().use_theirs(true)))?;
repo.checkout_head(Some(git2::build::CheckoutBuilder::new().force().use_theirs(true)))?;
Ok(())
}
fn webhook(req: &mut Request, config: &WebHookConfig) -> IronResult<Response> {
eprintln!("Webhook Request: {:?}", req);
let wh: serde_json::Value = serde_json::from_reader(&mut req.body).unwrap();
fn webhook_handler((contents, req): (String, HttpRequest<Arc<Mutex<WebHookConfig>>>)) -> HttpResponse {
let config = req.state().lock().unwrap();
// Ensure there's a "Push" event
if let Some(v) = req.headers().get("X-GitHub-Event") {
match v.to_str() {
Err(_) => return HttpResponse::BadRequest().body("invalid X-Github-Event header"),
Ok(o) => {
if o != "push" {
return HttpResponse::Ok().body("Ok");
}
}
}
} else {
return HttpResponse::Ok().body("Ok");
}
// Parse the JSON
let wh: serde_json::Value = match serde_json::from_str(&contents) {
Ok(o) => o,
Err(e) => return HttpResponse::BadRequest().body(format!("invalid json data: {}", e.description())),
};
// Ensure we have a "Secret" parameter, and that it matches the config.
let found_secret = wh.get("secret");
if found_secret.is_none() {
return Ok(Response::with(status::Unauthorized));
return HttpResponse::Unauthorized().body("invalid secret");
}
let found_secret = found_secret.unwrap();
if found_secret != &config.secret {
return Ok(Response::with(status::Unauthorized));
return HttpResponse::Unauthorized().body("invalid secret");
}
// Ensure the repo is valid.
let repository = wh.get("repository");
if repository.is_none() {
eprintln!("No 'repository' key found");
return Ok(Response::with(status::PreconditionRequired));
return HttpResponse::PreconditionFailed().body("no 'repository' key found");
}
let repository = repository.unwrap();
// Ensure there's an HTML URL that's a valid string
let html_url = match repository.get("html_url") {
None => {
eprintln!("No HTML URL found");
return Ok(Response::with(status::PreconditionRequired));
return HttpResponse::PreconditionFailed().body("no repository html_url found");
}
Some(s) => match s.as_str() {
None => {
eprintln!("HTML URL isn't a string");
return Ok(Response::with(status::PreconditionRequired));
return HttpResponse::PreconditionFailed().body("html_url is not a string");
}
Some(s) => s,
},
@ -95,32 +115,32 @@ fn webhook(req: &mut Request, config: &WebHookConfig) -> IronResult<Response> {
}
if !found_match {
eprintln!("URL doesn't start with match");
return Ok(Response::with(status::PreconditionRequired));
return HttpResponse::PreconditionFailed().body("url doesn't start with a recognized prefix");
}
// And ensure the URL is a string
let website_url = match repository.get("website") {
let website_url: http::uri::Uri = match repository.get("website") {
None => {
eprintln!("The website isn't configured for this repo");
return Ok(Response::with(status::PreconditionRequired));
return HttpResponse::PreconditionFailed().body("this repo has no website configured");
}
Some(s) => match s.as_str() {
None => {
eprintln!("Website URL isn't a string");
return Ok(Response::with(status::PreconditionRequired));
return HttpResponse::PreconditionFailed().body("repo's website url is not a string");
}
Some(s) => match iron::Url::parse(s) {
Some(s) => match s.parse() {
Ok(u) => u,
Err(e) => {
eprintln!("Unable to parse URL: {:?}", e);
return Ok(Response::with(status::PreconditionFailed));
return HttpResponse::PreconditionFailed().body("repo's url is unparseable");
}
},
},
};
let target_path = match website_url.path().last() {
let target_path = match website_url.path().split("/").last() {
Some(s) => {
if s.is_empty() {
if s.is_empty() || s == "." || s == ".." {
eprintln!("No website URL path was found -- defaulting to \"current\"");
"current".to_owned()
} else {
@ -129,21 +149,24 @@ fn webhook(req: &mut Request, config: &WebHookConfig) -> IronResult<Response> {
}
None => {
eprintln!("No website URL path was found");
return Ok(Response::with(status::PreconditionFailed));
return HttpResponse::PreconditionFailed().body("no website url path could be found");
}
};
eprintln!("Final path: {:?} / {:?}", config.repo_root, target_path);
if let Err(e) = redeploy_repo(html_url, &config.repo_root, &target_path) {
eprintln!("unable to clone/update repo: {}", e.description());
return Ok(Response::with(status::NotModified));
return HttpResponse::NotModified().body("unable to clone/update repo");
}
Ok(Response::with(status::Ok))
HttpResponse::Ok().body("Ok") // <- send response
}
fn main() {
let mut mount = Mount::new();
env::set_var("RUST_LOG", "actix_web=debug");
env::set_var("RUST_BACKTRACE", "1");
env_logger::init();
let hostaddr = "0.0.0.0:9119".to_owned();
let config = WebHookConfig {
secret: "1234".to_owned(),
@ -151,16 +174,31 @@ fn main() {
repo_prefixes: vec!["https://git.xobs.io/xobs".to_owned()],
};
// Serve the shared JS/CSS at /
mount.mount("/", Static::new(config.repo_root.clone()));
// Listen for calls to "/webhook" and process accordingly
mount.mount(
"/webhook",
Chain::new(move |req: &mut Request| webhook(req, &config)),
);
println!("Doc server running on http://{}", hostaddr);
Iron::new(mount).http(hostaddr).unwrap();
let repo_root_copy = Arc::new(Mutex::new(config.repo_root.clone()));
let config = Arc::new(Mutex::new(config));
let sys = actix::System::new("basic-example");
server::new(move || {
App::with_state(config.clone())
// enable logger
.middleware(middleware::Logger::default())
// Our webhook
.resource("/webhook", |r|
r.method(actix_web::http::Method::POST)
.with_config(webhook_handler, |((cfg, _),)| {
cfg.limit(16384);
})
)
// static files
.handler("/", fs::StaticFiles::new(&*repo_root_copy.lock().unwrap().clone()).unwrap().index_file("index.html"))
})
.bind(hostaddr.clone()).expect(&format!("Can not bind to {}", hostaddr))
.shutdown_timeout(0) // <- Set shutdown timeout to 0 seconds (default 60s)
.start();
let _ = sys.run();
}