Merge branch 'master' into lightsync

parity/dapps.rs

@@ -21,6 +21,8 @@ use ethcore::client::Client;
 use ethsync::SyncProvider;
 use helpers::replace_home;
 use dir::default_data_path;
+use hash_fetch::fetch::Client as FetchClient;
+use parity_reactor::Remote;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct Configuration {
@@ -53,6 +55,8 @@ pub struct Dependencies {
 	pub apis: Arc<rpc_apis::Dependencies>,
 	pub client: Arc<Client>,
 	pub sync: Arc<SyncProvider>,
+	pub remote: Remote,
+	pub fetch: FetchClient,
 }
 
 pub fn new(configuration: Configuration, deps: Dependencies) -> Result<Option<WebappServer>, String> {
@@ -128,10 +132,12 @@ mod server {
 
 		let mut server = dapps::ServerBuilder::new(
 			dapps_path,
-			Arc::new(Registrar { client: deps.client.clone() })
+			Arc::new(Registrar { client: deps.client.clone() }),
+			deps.remote.clone(),
 		);
 		let sync = deps.sync.clone();
 		let client = deps.client.clone();
+		server.with_fetch(deps.fetch.clone());
 		server.with_sync_status(Arc::new(move || is_major_importing(Some(sync.status().state), client.queue_info())));
 		server.with_signer_address(signer_address);
 

parity/main.rs

@@ -56,6 +56,7 @@ extern crate regex;
 extern crate isatty;
 extern crate toml;
 extern crate app_dirs;
+extern crate parity_reactor;
 
 #[macro_use]
 extern crate ethcore_util as util;
@@ -203,7 +204,7 @@ fn updates_path(name: &str) -> PathBuf {
 fn latest_exe_path() -> Option<PathBuf> {
 	File::open(updates_path("latest")).ok()
 		.and_then(|mut f| { let mut exe = String::new(); f.read_to_string(&mut exe).ok().map(|_| updates_path(&exe)) })
-} 
+}
 
 // Starts ~/.parity-updates/parity and returns the code it exits with.
 fn run_parity() -> Option<i32> {
@@ -220,7 +221,7 @@ fn run_parity() -> Option<i32> {
 const PLEASE_RESTART_EXIT_CODE: i32 = 69;
 
 // Run our version of parity.
-// Returns the exit error code. 
+// Returns the exit error code.
 fn main_direct(can_restart: bool) -> i32 {
 	let mut alt_mains = HashMap::new();
 	sync_main(&mut alt_mains);
@@ -271,9 +272,9 @@ fn main() {
 	trace_main!("Starting up {} (force-direct: {}, development: {}, same-name: {}, have-update: {}, non-updated-current: {})", std::env::current_exe().map(|x| format!("{}", x.display())).unwrap_or("<unknown>".to_owned()), force_direct, development, same_name, have_update, is_non_updated_current);
 	if !force_direct && !development && same_name && have_update && is_non_updated_current {
 		// looks like we're not running ~/.parity-updates/parity when the user is expecting otherwise.
-		// Everything run inside a loop, so we'll be able to restart from the child into a new version seamlessly. 
+		// Everything run inside a loop, so we'll be able to restart from the child into a new version seamlessly.
 		loop {
-			// If we fail to run the updated parity then fallback to local version. 
+			// If we fail to run the updated parity then fallback to local version.
 			trace_main!("Attempting to run latest update ({})...", latest_exe.as_ref().expect("guarded by have_update; latest_exe must exist for have_update; qed").display());
 			let exit_code = run_parity().unwrap_or_else(|| { trace_main!("Falling back to local..."); main_direct(true) });
 			trace_main!("Latest exited with {}", exit_code);

parity/rpc_apis.rs

@@ -28,6 +28,8 @@ use ethsync::{ManageNetwork, SyncProvider};
 use ethcore_rpc::{Extendable, NetworkSettings};
 pub use ethcore_rpc::SignerService;
 use updater::Updater;
+use hash_fetch::fetch::Client as FetchClient;
+use parity_reactor::Remote;
 
 #[derive(Debug, PartialEq, Clone, Eq, Hash)]
 pub enum Api {
@@ -122,6 +124,8 @@ pub struct Dependencies {
 	pub geth_compatibility: bool,
 	pub dapps_interface: Option<String>,
 	pub dapps_port: Option<u16>,
+	pub fetch: FetchClient,
+	pub remote: Remote,
 }
 
 fn to_modules(apis: &[Api]) -> BTreeMap<String, String> {
@@ -242,7 +246,14 @@ pub fn setup_rpc<T: Extendable>(server: T, deps: Arc<Dependencies>, apis: ApiSet
 				server.add_delegate(ParityAccountsClient::new(&deps.secret_store, &deps.client).to_delegate());
 			},
 			Api::ParitySet => {
-				server.add_delegate(ParitySetClient::new(&deps.client, &deps.miner, &deps.updater, &deps.net_service).to_delegate())
+				server.add_delegate(ParitySetClient::new(
+					&deps.client,
+					&deps.miner,
+					&deps.updater,
+					&deps.net_service,
+					deps.fetch.clone(),
+					deps.remote.clone(),
+				).to_delegate())
 			},
 			Api::Traces => {
 				server.add_delegate(TracesClient::new(&deps.client, &deps.miner).to_delegate())

parity/run.rs

@@ -32,6 +32,8 @@ use ethcore::verification::queue::VerifierSettings;
 use ethsync::SyncConfig;
 use informant::Informant;
 use updater::{UpdatePolicy, Updater};
+use parity_reactor::EventLoop;
+use hash_fetch::fetch::Client as FetchClient;
 
 use rpc::{HttpConfiguration, IpcConfiguration};
 use params::{
@@ -365,10 +367,23 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc<RotatingLogger>) -> R
 		chain_notify.start();
 	}
 
+	// spin up event loop
+	let event_loop = EventLoop::spawn();
+
+	// fetch service
+	let fetch = try!(FetchClient::new().map_err(|e| format!("Error starting fetch client: {:?}", e)));
+
 	// the updater service
-	let updater = Updater::new(Arc::downgrade(&(service.client() as Arc<BlockChainClient>)), Arc::downgrade(&sync_provider), update_policy);
+	let updater = Updater::new(
+		Arc::downgrade(&(service.client() as Arc<BlockChainClient>)),
+		Arc::downgrade(&sync_provider),
+		update_policy,
+		fetch.clone(),
+		event_loop.remote(),
+	);
 	service.add_notify(updater.clone());
 
+
 	// set up dependencies for rpc servers
 	let signer_path = cmd.signer_conf.signer_path.clone();
 	let deps_for_rpc_apis = Arc::new(rpc_apis::Dependencies {
@@ -395,6 +410,8 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc<RotatingLogger>) -> R
 			true => Some(cmd.dapps_conf.port),
 			false => None,
 		},
+		fetch: fetch.clone(),
+		remote: event_loop.remote(),
 	});
 
 	let dependencies = rpc::Dependencies {
@@ -412,6 +429,8 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc<RotatingLogger>) -> R
 		apis: deps_for_rpc_apis.clone(),
 		client: client.clone(),
 		sync: sync_provider.clone(),
+		remote: event_loop.remote(),
+		fetch: fetch.clone(),
 	};
 	let dapps_server = try!(dapps::new(cmd.dapps_conf.clone(), dapps_deps));
 
@@ -473,7 +492,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc<RotatingLogger>) -> R
 	let restart = wait_for_exit(panic_handler, Some(updater), can_restart);
 
 	// drop this stuff as soon as exit detected.
-	drop((http_server, ipc_server, dapps_server, signer_server));
+	drop((http_server, ipc_server, dapps_server, signer_server, event_loop));
 
 	info!("Finishing work, please wait...");
 

parity/user_defaults.rs

@@ -77,24 +77,24 @@ impl Visitor for UserDefaultsVisitor {
 	fn visit_map<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
 	where V: MapVisitor {
 		let mut map: BTreeMap<String, Value> = try!(BTreeMapVisitor::new().visit_map(visitor));
-		let pruning: Value = try!(map.remove("pruning".into()).ok_or_else(|| Error::custom("missing pruning")));
+		let pruning: Value = try!(map.remove("pruning").ok_or_else(|| Error::custom("missing pruning")));
 		let pruning = try!(pruning.as_str().ok_or_else(|| Error::custom("invalid pruning value")));
 		let pruning = try!(pruning.parse().map_err(|_| Error::custom("invalid pruning method")));
-		let tracing: Value = try!(map.remove("tracing".into()).ok_or_else(|| Error::custom("missing tracing")));
+		let tracing: Value = try!(map.remove("tracing").ok_or_else(|| Error::custom("missing tracing")));
 		let tracing = try!(tracing.as_bool().ok_or_else(|| Error::custom("invalid tracing value")));
-		let fat_db: Value = map.remove("fat_db".into()).unwrap_or_else(|| Value::Bool(false));
+		let fat_db: Value = map.remove("fat_db").unwrap_or_else(|| Value::Bool(false));
 		let fat_db = try!(fat_db.as_bool().ok_or_else(|| Error::custom("invalid fat_db value")));
 
-		let mode: Value = map.remove("mode".into()).unwrap_or_else(|| Value::String("active".to_owned()));
+		let mode: Value = map.remove("mode").unwrap_or_else(|| Value::String("active".to_owned()));
 		let mode = match try!(mode.as_str().ok_or_else(|| Error::custom("invalid mode value"))) {
 			"offline" => Mode::Off,
 			"dark" => {
-				let timeout = try!(map.remove("mode.timeout".into()).and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value")));
+				let timeout = try!(map.remove("mode.timeout").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value")));
 				Mode::Dark(Duration::from_secs(timeout))
 			},
 			"passive" => {
-				let timeout = try!(map.remove("mode.timeout".into()).and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value")));
-				let alarm = try!(map.remove("mode.alarm".into()).and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.alarm value")));
+				let timeout = try!(map.remove("mode.timeout").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value")));
+				let alarm = try!(map.remove("mode.alarm").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.alarm value")));
 				Mode::Passive(Duration::from_secs(timeout), Duration::from_secs(alarm))
 			},
 			"active" => Mode::Active,