113 lines
3.3 KiB
Rust
113 lines
3.3 KiB
Rust
// Copyright 2015, 2016 Ethcore (UK) Ltd.
|
|
// This file is part of Parity.
|
|
|
|
// Parity is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Parity is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! Ethcore Webapplications for Parity
|
|
#![warn(missing_docs)]
|
|
#![cfg_attr(feature="nightly", plugin(clippy))]
|
|
|
|
#[macro_use]
|
|
extern crate log;
|
|
extern crate url;
|
|
extern crate hyper;
|
|
extern crate jsonrpc_core;
|
|
extern crate jsonrpc_http_server;
|
|
extern crate ethcore_rpc as rpc;
|
|
extern crate parity_webapp;
|
|
|
|
use std::sync::Arc;
|
|
use self::jsonrpc_core::{IoHandler, IoDelegate};
|
|
use jsonrpc_http_server::ServerHandler;
|
|
|
|
mod apps;
|
|
mod page;
|
|
mod router;
|
|
|
|
use router::auth::{Authorization, NoAuth, HttpBasicAuth};
|
|
|
|
/// Http server.
|
|
pub struct WebappServer {
|
|
handler: Arc<IoHandler>,
|
|
}
|
|
|
|
impl WebappServer {
|
|
/// Construct new http server object
|
|
pub fn new() -> Self {
|
|
WebappServer {
|
|
handler: Arc::new(IoHandler::new()),
|
|
}
|
|
}
|
|
|
|
/// Add io delegate.
|
|
pub fn add_delegate<D>(&self, delegate: IoDelegate<D>) where D: Send + Sync + 'static {
|
|
self.handler.add_delegate(delegate);
|
|
}
|
|
|
|
/// Asynchronously start server with no authentication,
|
|
/// return result with `Listening` handle on success or an error.
|
|
pub fn start_unsecure_http(&self, addr: &str, threads: usize) -> Result<Listening, WebappServerError> {
|
|
self.start_http(addr, threads, NoAuth)
|
|
}
|
|
|
|
/// Asynchronously start server with `HTTP Basic Authentication`,
|
|
/// return result with `Listening` handle on success or an error.
|
|
pub fn start_basic_auth_http(&self, addr: &str, threads: usize, username: &str, password: &str) -> Result<Listening, WebappServerError> {
|
|
self.start_http(addr, threads, HttpBasicAuth::single_user(username, password))
|
|
}
|
|
|
|
fn start_http<A: Authorization + 'static>(&self, addr: &str, threads: usize, authorization: A) -> Result<Listening, WebappServerError> {
|
|
let addr = addr.to_owned();
|
|
let handler = self.handler.clone();
|
|
|
|
let cors_domain = jsonrpc_http_server::AccessControlAllowOrigin::Null;
|
|
let rpc = ServerHandler::new(handler, cors_domain);
|
|
let router = router::Router::new(rpc, apps::main_page(), apps::all_pages(), authorization);
|
|
|
|
try!(hyper::Server::http(addr.as_ref() as &str))
|
|
.handle_threads(router, threads)
|
|
.map(|l| Listening { listening: l })
|
|
.map_err(WebappServerError::from)
|
|
}
|
|
}
|
|
|
|
/// Listening handle
|
|
pub struct Listening {
|
|
listening: hyper::server::Listening
|
|
}
|
|
|
|
impl Drop for Listening {
|
|
fn drop(&mut self) {
|
|
self.listening.close().unwrap();
|
|
}
|
|
}
|
|
|
|
/// Webapp Server startup error
|
|
#[derive(Debug)]
|
|
pub enum WebappServerError {
|
|
/// Wrapped `std::io::Error`
|
|
IoError(std::io::Error),
|
|
/// Other `hyper` error
|
|
Other(hyper::error::Error),
|
|
}
|
|
|
|
impl From<hyper::error::Error> for WebappServerError {
|
|
fn from(err: hyper::error::Error) -> Self {
|
|
match err {
|
|
hyper::error::Error::Io(e) => WebappServerError::IoError(e),
|
|
e => WebappServerError::Other(e),
|
|
}
|
|
}
|
|
}
|