Merge branch 'master' of github.com:ethcore/parity into cli-rpc

parity/blockchain.rs

@@ -25,7 +25,7 @@ use io::{PanicHandler, ForwardPanic};
 use util::{ToPretty, Uint, U256, H256, Address, Hashable};
 use rlp::PayloadInfo;
 use ethcore::service::ClientService;
-use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, BlockImportError, BlockChainClient, BlockID};
+use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, BlockImportError, BlockChainClient, BlockId};
 use ethcore::error::ImportError;
 use ethcore::miner::Miner;
 use ethcore::verification::queue::VerifierSettings;
@@ -101,8 +101,8 @@ pub struct ExportBlockchain {
 	pub wal: bool,
 	pub fat_db: Switch,
 	pub tracing: Switch,
-	pub from_block: BlockID,
-	pub to_block: BlockID,
+	pub from_block: BlockId,
+	pub to_block: BlockId,
 	pub check_seal: bool,
 }
 
@@ -119,7 +119,7 @@ pub struct ExportState {
 	pub wal: bool,
 	pub fat_db: Switch,
 	pub tracing: Switch,
-	pub at: BlockID,
+	pub at: BlockId,
 	pub storage: bool,
 	pub code: bool,
 	pub min_balance: Option<U256>,
@@ -384,7 +384,7 @@ fn execute_export(cmd: ExportBlockchain) -> Result<String, String> {
 		if i % 10000 == 0 {
 			info!("#{}", i);
 		}
-		let b = try!(client.block(BlockID::Number(i)).ok_or("Error exporting incomplete chain"));
+		let b = try!(client.block(BlockId::Number(i)).ok_or("Error exporting incomplete chain"));
 		match format {
 			DataFormat::Binary => { out.write(&b).expect("Couldn't write to stream."); }
 			DataFormat::Hex => { out.write_fmt(format_args!("{}", b.pretty())).expect("Couldn't write to stream."); }

parity/cli/config.full.toml

@@ -32,6 +32,7 @@ warp = true
 allow_ips = "all"
 snapshot_peers = 0
 max_pending_peers = 64
+serve_light = true
 
 reserved_only = false
 reserved_peers = "./path_to_file"

parity/cli/mod.rs

@@ -138,6 +138,8 @@ usage! {
 		flag_reserved_only: bool = false,
 			or |c: &Config| otry!(c.network).reserved_only.clone(),
 		flag_no_ancient_blocks: bool = false, or |_| None,
+		flag_serve_light: bool = false,
+			or |c: &Config| otry!(c.network).serve_light.clone(),
 
 		// -- API and Console Options
 		// RPC
@@ -343,6 +345,7 @@ struct Network {
 	node_key: Option<String>,
 	reserved_peers: Option<String>,
 	reserved_only: Option<bool>,
+	serve_light: Option<bool>,
 }
 
 #[derive(Default, Debug, PartialEq, RustcDecodable)]
@@ -558,6 +561,7 @@ mod tests {
 			flag_reserved_peers: Some("./path_to_file".into()),
 			flag_reserved_only: false,
 			flag_no_ancient_blocks: false,
+			flag_serve_light: true,
 
 			// -- API and Console Options
 			// RPC
@@ -731,6 +735,7 @@ mod tests {
 				node_key: None,
 				reserved_peers: Some("./path/to/reserved_peers".into()),
 				reserved_only: Some(true),
+				serve_light: None,
 			}),
 			rpc: Some(Rpc {
 				disable: Some(true),

parity/cli/usage.txt

@@ -100,6 +100,7 @@ Networking Options:
   --max-pending-peers NUM  Allow up to NUM pending connections. (default: {flag_max_pending_peers})
   --no-ancient-blocks      Disable downloading old blocks after snapshot restoration
                            or warp sync. (default: {flag_no_ancient_blocks})
+  --serve-light            Experimental: Serve light client peers. (default: {flag_serve_light})
 
 API and Console Options:
   --no-jsonrpc             Disable the JSON-RPC API server. (default: {flag_no_jsonrpc})

parity/configuration.rs

@@ -324,6 +324,7 @@ impl Configuration {
 				no_periodic_snapshot: self.args.flag_no_periodic_snapshot,
 				check_seal: !self.args.flag_no_seal_check,
 				download_old_blocks: !self.args.flag_no_ancient_blocks,
+				serve_light: self.args.flag_serve_light,
 				verifier_settings: verifier_settings,
 			};
 			Cmd::Run(run_cmd)
@@ -774,7 +775,7 @@ mod tests {
 	use super::*;
 	use cli::Args;
 	use ethcore_rpc::NetworkSettings;
-	use ethcore::client::{VMType, BlockID};
+	use ethcore::client::{VMType, BlockId};
 	use ethcore::miner::{MinerOptions, PrioritizationStrategy};
 	use helpers::{replace_home, default_network_config};
 	use run::RunCmd;
@@ -883,8 +884,8 @@ mod tests {
 			wal: true,
 			tracing: Default::default(),
 			fat_db: Default::default(),
-			from_block: BlockID::Number(1),
-			to_block: BlockID::Latest,
+			from_block: BlockId::Number(1),
+			to_block: BlockId::Latest,
 			check_seal: true,
 		})));
 	}
@@ -905,7 +906,7 @@ mod tests {
 			wal: true,
 			tracing: Default::default(),
 			fat_db: Default::default(),
-			at: BlockID::Latest,
+			at: BlockId::Latest,
 			storage: true,
 			code: true,
 			min_balance: None,
@@ -929,8 +930,8 @@ mod tests {
 			wal: true,
 			tracing: Default::default(),
 			fat_db: Default::default(),
-			from_block: BlockID::Number(1),
-			to_block: BlockID::Latest,
+			from_block: BlockId::Number(1),
+			to_block: BlockId::Latest,
 			check_seal: true,
 		})));
 	}
@@ -987,6 +988,7 @@ mod tests {
 			no_periodic_snapshot: false,
 			check_seal: true,
 			download_old_blocks: true,
+			serve_light: false,
 			verifier_settings: Default::default(),
 		}));
 	}

parity/dapps.rs

@@ -106,7 +106,7 @@ mod server {
 	use util::{Bytes, Address, U256};
 
 	use ethcore::transaction::{Transaction, Action};
-	use ethcore::client::{Client, BlockChainClient, BlockID};
+	use ethcore::client::{Client, BlockChainClient, BlockId};
 
 	use rpc_apis;
 	use ethcore_rpc::is_major_importing;
@@ -182,7 +182,7 @@ mod server {
 				data: data,
 			}.fake_sign(from);
 
-			self.client.call(&transaction, BlockID::Latest, Default::default())
+			self.client.call(&transaction, BlockId::Latest, Default::default())
 				.map_err(|e| format!("{:?}", e))
 				.map(|executed| {
 					executed.output

parity/helpers.rs

@@ -20,7 +20,7 @@ use std::time::Duration;
 use std::fs::File;
 use util::{clean_0x, U256, Uint, Address, path, CompactionProfile};
 use util::journaldb::Algorithm;
-use ethcore::client::{Mode, BlockID, VMType, DatabaseCompactionProfile, ClientConfig, VerifierType};
+use ethcore::client::{Mode, BlockId, VMType, DatabaseCompactionProfile, ClientConfig, VerifierType};
 use ethcore::miner::{PendingSet, GasLimit, PrioritizationStrategy};
 use cache::CacheConfig;
 use dir::DatabaseDirectories;
@@ -62,13 +62,13 @@ pub fn to_mode(s: &str, timeout: u64, alarm: u64) -> Result<Mode, String> {
 	}
 }
 
-pub fn to_block_id(s: &str) -> Result<BlockID, String> {
+pub fn to_block_id(s: &str) -> Result<BlockId, String> {
 	if s == "latest" {
-		Ok(BlockID::Latest)
+		Ok(BlockId::Latest)
 	} else if let Ok(num) = s.parse() {
-		Ok(BlockID::Number(num))
+		Ok(BlockId::Number(num))
 	} else if let Ok(hash) = s.parse() {
-		Ok(BlockID::Hash(hash))
+		Ok(BlockId::Hash(hash))
 	} else {
 		Err("Invalid block.".into())
 	}
@@ -327,7 +327,7 @@ mod tests {
 	use std::io::Write;
 	use devtools::RandomTempPath;
 	use util::{U256};
-	use ethcore::client::{Mode, BlockID};
+	use ethcore::client::{Mode, BlockId};
 	use ethcore::miner::PendingSet;
 	use super::{to_duration, to_mode, to_block_id, to_u256, to_pending_set, to_address, to_addresses, to_price, geth_ipc_path, to_bootnodes, password_from_file};
 
@@ -361,13 +361,13 @@ mod tests {
 
 	#[test]
 	fn test_to_block_id() {
-		assert_eq!(to_block_id("latest").unwrap(), BlockID::Latest);
-		assert_eq!(to_block_id("0").unwrap(), BlockID::Number(0));
-		assert_eq!(to_block_id("2").unwrap(), BlockID::Number(2));
-		assert_eq!(to_block_id("15").unwrap(), BlockID::Number(15));
+		assert_eq!(to_block_id("latest").unwrap(), BlockId::Latest);
+		assert_eq!(to_block_id("0").unwrap(), BlockId::Number(0));
+		assert_eq!(to_block_id("2").unwrap(), BlockId::Number(2));
+		assert_eq!(to_block_id("15").unwrap(), BlockId::Number(15));
 		assert_eq!(
 			to_block_id("9fc84d84f6a785dc1bd5abacfcf9cbdd3b6afb80c0f799bfb2fd42c44a0c224e").unwrap(),
-			BlockID::Hash("9fc84d84f6a785dc1bd5abacfcf9cbdd3b6afb80c0f799bfb2fd42c44a0c224e".parse().unwrap())
+			BlockId::Hash("9fc84d84f6a785dc1bd5abacfcf9cbdd3b6afb80c0f799bfb2fd42c44a0c224e".parse().unwrap())
 		);
 	}
 

parity/informant.rs

@@ -184,12 +184,12 @@ impl ChainNotify for Informant {
 		let ripe = Instant::now() > *last_import + Duration::from_secs(1) && !importing;
 		let txs_imported = imported.iter()
 			.take(imported.len() - if ripe {1} else {0})
-			.filter_map(|h| self.client.block(BlockID::Hash(*h)))
+			.filter_map(|h| self.client.block(BlockId::Hash(*h)))
 			.map(|b| BlockView::new(&b).transactions_count())
 			.sum();
 
 		if ripe {
-			if let Some(block) = imported.last().and_then(|h| self.client.block(BlockID::Hash(*h))) {
+			if let Some(block) = imported.last().and_then(|h| self.client.block(BlockId::Hash(*h))) {
 				let view = BlockView::new(&block);
 				let header = view.header();
 				let tx_count = view.transactions_count();

parity/main.rs

@@ -43,6 +43,7 @@ extern crate serde;
 extern crate serde_json;
 extern crate rlp;
 extern crate ethcore_hash_fetch as hash_fetch;
+extern crate ethcore_light as light;
 
 extern crate ethcore_ipc_hypervisor as hypervisor;
 extern crate ethcore_rpc;

parity/modules.rs

@@ -15,16 +15,22 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::sync::Arc;
+use std::path::Path;
+
 use ethcore::client::BlockChainClient;
 use hypervisor::Hypervisor;
-use ethsync::{SyncConfig, NetworkConfiguration, NetworkError};
+use ethsync::{SyncConfig, NetworkConfiguration, NetworkError, Params};
 use ethcore::snapshot::SnapshotService;
+use light::Provider;
+
 #[cfg(not(feature="ipc"))]
 use self::no_ipc_deps::*;
+
+#[cfg(not(feature="ipc"))]
+use ethcore_logger::Config as LogConfig;
+
 #[cfg(feature="ipc")]
 use self::ipc_deps::*;
-use ethcore_logger::Config as LogConfig;
-use std::path::Path;
 
 #[cfg(feature="ipc")]
 pub mod service_urls {
@@ -36,6 +42,8 @@ pub mod service_urls {
 	pub const SYNC_NOTIFY: &'static str = "parity-sync-notify.ipc";
 	pub const NETWORK_MANAGER: &'static str = "parity-manage-net.ipc";
 	pub const SYNC_CONTROL: &'static str = "parity-sync-control.ipc";
+	pub const LIGHT_PROVIDER: &'static str = "parity-light-provider.ipc";
+
 	#[cfg(feature="stratum")]
 	pub const STRATUM: &'static str = "parity-stratum.ipc";
 	#[cfg(feature="stratum")]
@@ -75,6 +83,7 @@ mod ipc_deps {
 	pub use nanoipc::{GuardedSocket, NanoSocket, generic_client, fast_client};
 	pub use ipc::IpcSocket;
 	pub use ipc::binary::serialize;
+	pub use light::remote::LightProviderClient;
 }
 
 #[cfg(feature="ipc")]
@@ -124,6 +133,7 @@ pub fn sync
 		net_cfg: NetworkConfiguration,
 		_client: Arc<BlockChainClient>,
 		_snapshot_service: Arc<SnapshotService>,
+		_provider: Arc<Provider>,		
 		log_settings: &LogConfig,
 	)
 	-> Result<SyncModules, NetworkError>
@@ -141,7 +151,9 @@ pub fn sync
 		&service_urls::with_base(&hypervisor.io_path, service_urls::SYNC_NOTIFY)).unwrap();
 	let manage_client = generic_client::<NetworkManagerClient<_>>(
 		&service_urls::with_base(&hypervisor.io_path, service_urls::NETWORK_MANAGER)).unwrap();
-
+	let provider_client = generic_client::<LightProviderClient<_>>(
+		&service_urls::with_base(&hypervisor.io_path, service_urls::LIGHT_PROVIDER)).unwrap();
+		
 	*hypervisor_ref = Some(hypervisor);
 	Ok((sync_client, manage_client, notify_client))
 }
@@ -154,10 +166,18 @@ pub fn sync
 		net_cfg: NetworkConfiguration,
 		client: Arc<BlockChainClient>,
 		snapshot_service: Arc<SnapshotService>,
+		provider: Arc<Provider>,		
 		_log_settings: &LogConfig,
 	)
 	-> Result<SyncModules, NetworkError>
 {
-	let eth_sync = try!(EthSync::new(sync_cfg, client, snapshot_service, net_cfg));
+	let eth_sync = try!(EthSync::new(Params {
+		config: sync_cfg, 
+		chain: client,
+		provider: provider,
+		snapshot_service: snapshot_service, 
+		network_config: net_cfg,
+	}));
+
 	Ok((eth_sync.clone() as Arc<SyncProvider>, eth_sync.clone() as Arc<ManageNetwork>, eth_sync.clone() as Arc<ChainNotify>))
 }

parity/run.rs

@@ -93,6 +93,7 @@ pub struct RunCmd {
 	pub no_periodic_snapshot: bool,
 	pub check_seal: bool,
 	pub download_old_blocks: bool,
+	pub serve_light: bool,
 	pub verifier_settings: VerifierSettings,
 }
 
@@ -187,6 +188,11 @@ pub fn execute(cmd: RunCmd, logger: Arc<RotatingLogger>) -> Result<(), String> {
 	);
 	info!("Operating mode: {}", Colour::White.bold().paint(format!("{}", mode)));
 
+	if cmd.serve_light {
+		info!("Configured to serve light client peers. Please note this feature is {}.",
+			Colour::White.bold().paint("experimental".to_string()));
+	}
+
 	// display warning about using experimental journaldb alorithm
 	if !algorithm.is_stable() {
 		warn!("Your chosen strategy is {}! You can re-run with --pruning to change.", Colour::Red.bold().paint("unstable"));
@@ -206,6 +212,7 @@ pub fn execute(cmd: RunCmd, logger: Arc<RotatingLogger>) -> Result<(), String> {
 	sync_config.fork_block = spec.fork_block();
 	sync_config.warp_sync = cmd.warp_sync;
 	sync_config.download_old_blocks = cmd.download_old_blocks;
+	sync_config.serve_light = cmd.serve_light;
 
 	let passwords = try!(passwords_from_files(&cmd.acc_conf.password_files));
 
@@ -283,7 +290,13 @@ pub fn execute(cmd: RunCmd, logger: Arc<RotatingLogger>) -> Result<(), String> {
 
 	// create sync object
 	let (sync_provider, manage_network, chain_notify) = try!(modules::sync(
-		&mut hypervisor, sync_config, net_conf.into(), client.clone(), snapshot_service.clone(), &cmd.logger_config,
+		&mut hypervisor, 
+		sync_config, 
+		net_conf.into(), 
+		client.clone(), 
+		snapshot_service.clone(), 
+		client.clone(), 
+		&cmd.logger_config,
 	).map_err(|e| format!("Sync error: {}", e)));
 
 	service.add_notify(chain_notify.clone());

parity/snapshot.rs

@@ -26,7 +26,7 @@ use ethcore::snapshot::service::Service as SnapshotService;
 use ethcore::service::ClientService;
 use ethcore::client::{Mode, DatabaseCompactionProfile, VMType};
 use ethcore::miner::Miner;
-use ethcore::ids::BlockID;
+use ethcore::ids::BlockId;
 
 use cache::CacheConfig;
 use params::{SpecType, Pruning, Switch, tracing_switch_to_bool, fatdb_switch_to_bool};
@@ -60,7 +60,7 @@ pub struct SnapshotCommand {
 	pub file_path: Option<String>,
 	pub wal: bool,
 	pub kind: Kind,
-	pub block_at: BlockID,
+	pub block_at: BlockId,
 }
 
 // helper for reading chunks from arbitrary reader and feeding them into the

parity/sync.rs

@@ -22,6 +22,7 @@ use hypervisor::{SYNC_MODULE_ID, HYPERVISOR_IPC_URL, ControlService};
 use ethcore::client::ChainNotify;
 use ethcore::client::remote::RemoteClient;
 use ethcore::snapshot::remote::RemoteSnapshotService;
+use light::remote::LightProviderClient;
 use ethsync::{SyncProvider, EthSync, ManageNetwork, ServiceConfiguration};
 use modules::service_urls;
 use boot;
@@ -48,8 +49,15 @@ pub fn main() {
 
 	let remote_client = dependency!(RemoteClient, &service_urls::with_base(&service_config.io_path, service_urls::CLIENT));
 	let remote_snapshot = dependency!(RemoteSnapshotService, &service_urls::with_base(&service_config.io_path, service_urls::SNAPSHOT));
+	let remote_provider = dependency!(LightProviderClient, &service_urls::with_base(&service_config.io_path, service_urls::LIGHT_PROVIDER));
 
-	let sync = EthSync::new(service_config.sync, remote_client.service().clone(), remote_snapshot.service().clone(), service_config.net).unwrap();
+	let sync = EthSync::new(Params {
+		config: service_config.sync, 
+		chain: remote_client.service().clone(), 
+		snapshot_service: remote_snapshot.service().clone(), 
+		provider: remote_provider.service().clone(),
+		network_config: service_config.net
+	}).unwrap();
 
 	let _ = boot::main_thread();
 	let service_stop = Arc::new(AtomicBool::new(false));