Merge branch 'master' of github.com:ethcore/parity into eth_call

rpc/Cargo.toml

@@ -26,7 +26,7 @@ clippy = { version = "0.0.54", optional = true }
 
 [build-dependencies]
 serde_codegen = { version = "0.7.0", optional = true }
-syntex = "0.29.0"
+syntex = "0.30.0"
 
 [features]
 default = ["serde_codegen"]

rpc/rpctest/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+description = "Rpc test client."
+name = "rpctest"
+version = "1.1.0"
+license = "GPL-3.0"
+authors = ["Ethcore <admin@ethcore.io>"]
+
+[dependencies]
+ctrlc = { git = "https://github.com/tomusdrw/rust-ctrlc.git" }
+docopt = "0.6"
+rustc-serialize = "0.3"
+ethcore = { path = "../../ethcore" }
+ethcore-devtools = { path = "../../devtools" }
+ethcore-rpc = { path = ".." }
+ethcore-util = { path = "../../util" }
+ethjson = { path = "../../json" }
+serde_json = "0.7.0"

rpc/rpctest/src/main.rs

@@ -0,0 +1,148 @@
+// 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/>.
+
+extern crate ctrlc;
+extern crate docopt;
+extern crate rustc_serialize;
+extern crate serde_json;
+extern crate ethjson;
+extern crate ethcore_util as util;
+extern crate ethcore;
+extern crate ethcore_devtools as devtools;
+extern crate ethcore_rpc as rpc;
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex, Condvar};
+use std::process;
+use std::fs::File;
+use std::path::Path;
+use docopt::Docopt;
+use ctrlc::CtrlC;
+use ethcore::spec::Genesis;
+use ethcore::pod_state::PodState;
+use ethcore::ethereum;
+use ethcore::client::{BlockChainClient, Client, ClientConfig};
+use devtools::RandomTempPath;
+use util::IoChannel;
+use rpc::v1::tests::helpers::{TestSyncProvider, Config as SyncConfig, TestMinerService, TestAccountProvider, TestAccount};
+use rpc::v1::{Eth, EthClient, EthFilter, EthFilterClient};
+use util::panics::MayPanic;
+use util::hash::Address;
+
+const USAGE: &'static str = r#"
+Parity rpctest client.
+  By Wood/Paronyan/Kotewicz/Drwięga/Volf.
+  Copyright 2015, 2016 Ethcore (UK) Limited
+
+Usage:
+  rpctest --json <test-file> --name <test-name> [options]
+  rpctest --help
+
+Options:
+  --jsonrpc-addr HOST      Specify the hostname portion of the JSONRPC API
+                           server [default: 127.0.0.1].
+  --jsonrpc-port PORT      Specify the port portion of the JSONRPC API server
+                           [default: 8545].
+"#;
+
+#[derive(Debug, RustcDecodable)]
+struct Args {
+	arg_test_file: String,
+	arg_test_name: String,
+	flag_jsonrpc_addr: String,
+	flag_jsonrpc_port: u16,
+}
+
+struct Configuration {
+	args: Args,
+}
+
+impl Configuration {
+	fn parse() -> Self {
+		Configuration {
+			args: Docopt::new(USAGE).and_then(|d| d.decode()).unwrap_or_else(|e| e.exit())
+		}
+	}
+
+	fn execute(&self) {
+		println!("file path: {:?}", self.args.arg_test_file);
+		println!("test name: {:?}", self.args.arg_test_name);
+
+		let path = Path::new(&self.args.arg_test_file);
+		let file = File::open(path).unwrap_or_else(|_| {
+			println!("Cannot open file.");
+			process::exit(1);
+		});
+
+		let	tests: ethjson::blockchain::Test = serde_json::from_reader(file).unwrap_or_else(|err| {
+			println!("Invalid json file.");
+			println!("{:?}", err);
+			process::exit(2);
+		});
+
+		let blockchain = tests.get(&self.args.arg_test_name).unwrap_or_else(|| {
+			println!("Invalid test name.");
+			process::exit(3);
+		});
+
+		let genesis = Genesis::from(blockchain.genesis());
+		let state = PodState::from(blockchain.pre_state.clone());
+		let mut spec = ethereum::new_frontier_test();
+		spec.set_genesis_state(state);
+		spec.overwrite_genesis_params(genesis);
+		assert!(spec.is_state_root_valid());
+
+		let temp = RandomTempPath::new();
+		{
+			let client: Arc<Client> = Client::new(ClientConfig::default(), spec, temp.as_path(), IoChannel::disconnected()).unwrap();
+			for b in &blockchain.blocks_rlp() {
+				let _ = client.import_block(b.clone());
+				client.flush_queue();
+				client.import_verified_blocks(&IoChannel::disconnected());
+			}
+			let sync = Arc::new(TestSyncProvider::new(SyncConfig {
+				protocol_version: 65,
+				num_peers: 120
+			}));
+
+			let miner = Arc::new(TestMinerService::default());
+			let mut accs = HashMap::new();
+			accs.insert(Address::from(1), TestAccount::new("test"));
+			let accounts = Arc::new(TestAccountProvider::new(accs));
+			let server = rpc::RpcServer::new();
+			server.add_delegate(EthClient::new(&client, &sync, &accounts, &miner).to_delegate());
+			server.add_delegate(EthFilterClient::new(&client, &miner).to_delegate());
+
+			let url = format!("{}:{}", self.args.flag_jsonrpc_addr, self.args.flag_jsonrpc_port);
+			let panic_handler = server.start_http(url.as_ref(), "*", 1);
+			let exit = Arc::new(Condvar::new());
+
+			let e = exit.clone();
+			CtrlC::set_handler(move || { e.notify_all(); });
+
+			let e = exit.clone();
+			panic_handler.on_panic(move |_reason| { e.notify_all(); });
+
+			let mutex = Mutex::new(());
+			let _ = exit.wait(mutex.lock().unwrap()).unwrap();
+		}
+
+	}
+}
+
+fn main() {
+	Configuration::parse().execute();
+}