diff --git a/dapps/src/handlers/async.rs b/dapps/src/handlers/async.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d68c55cce169772bf0eb9afe5b687f39db7ff088
--- /dev/null
+++ b/dapps/src/handlers/async.rs
@@ -0,0 +1,112 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Async Content Handler
+//! Temporary solution until we switch to future-based server.
+//! Wraps a future and converts it to hyper::server::Handler;
+
+use std::{mem, time};
+use std::sync::mpsc;
+use futures::Future;
+use hyper::{server, Decoder, Encoder, Next, Control};
+use hyper::net::HttpStream;
+
+use handlers::ContentHandler;
+use parity_reactor::Remote;
+
+const TIMEOUT_SECS: u64 = 15;
+
+enum State {
+ Initial(F, M, Remote, Control),
+ Waiting(mpsc::Receiver>, M),
+ Done(ContentHandler),
+ Invalid,
+}
+
+pub struct AsyncHandler {
+ state: State,
+}
+
+impl AsyncHandler {
+ pub fn new(future: F, map: M, remote: Remote, control: Control) -> Self {
+ AsyncHandler {
+ state: State::Initial(future, map, remote, control),
+ }
+ }
+}
+
+impl server::Handler for AsyncHandler, M> where
+ F: Future + Send + 'static,
+ M: FnOnce(Result, ()>) -> ContentHandler,
+ T: Send + 'static,
+ E: Send + 'static,
+{
+ fn on_request(&mut self, _request: server::Request) -> Next {
+ if let State::Initial(future, map, remote, control) = mem::replace(&mut self.state, State::Invalid) {
+ let (tx, rx) = mpsc::sync_channel(1);
+ let control2 = control.clone();
+ let tx2 = tx.clone();
+ remote.spawn_with_timeout(move || future.then(move |result| {
+ // Send a result (ignore errors if the connection was dropped)
+ let _ = tx.send(Ok(result));
+ // Resume handler
+ let _ = control.ready(Next::read());
+
+ Ok(())
+ }), time::Duration::from_secs(TIMEOUT_SECS), move || {
+ // Notify about error
+ let _ = tx2.send(Err(()));
+ // Resume handler
+ let _ = control2.ready(Next::read());
+ });
+
+ self.state = State::Waiting(rx, map);
+ }
+
+ Next::wait()
+ }
+
+ fn on_request_readable(&mut self, _decoder: &mut Decoder) -> Next {
+ if let State::Waiting(rx, map) = mem::replace(&mut self.state, State::Invalid) {
+ match rx.try_recv() {
+ Ok(result) => {
+ self.state = State::Done(map(result));
+ },
+ Err(err) => {
+ warn!("Resuming handler in incorrect state: {:?}", err);
+ }
+ }
+ }
+
+ Next::write()
+ }
+
+ fn on_response(&mut self, res: &mut server::Response) -> Next {
+ if let State::Done(ref mut handler) = self.state {
+ handler.on_response(res)
+ } else {
+ Next::end()
+ }
+ }
+
+ fn on_response_writable(&mut self, encoder: &mut Encoder) -> Next {
+ if let State::Done(ref mut handler) = self.state {
+ handler.on_response_writable(encoder)
+ } else {
+ Next::end()
+ }
+ }
+}
diff --git a/dapps/src/url.rs b/dapps/src/url.rs
new file mode 100644
index 0000000000000000000000000000000000000000..23dbfb4fcc3043380def50f963a81a49277d98bf
--- /dev/null
+++ b/dapps/src/url.rs
@@ -0,0 +1,150 @@
+// Copyright 2015-2017 Parity Technologies (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/HTTPS URL type. Based on URL type from Iron library.
+
+use url_lib::{self};
+pub use url_lib::Host;
+
+/// HTTP/HTTPS URL type for Iron.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct Url {
+ /// Raw url of url
+ pub raw: url_lib::Url,
+
+ /// The host field of the URL, probably a domain.
+ pub host: Host,
+
+ /// The connection port.
+ pub port: u16,
+
+ /// The URL path, the resource to be accessed.
+ ///
+ /// A *non-empty* vector encoding the parts of the URL path.
+ /// Empty entries of `""` correspond to trailing slashes.
+ pub path: Vec,
+
+ /// The URL query.
+ pub query: Option,
+
+ /// The URL username field, from the userinfo section of the URL.
+ ///
+ /// `None` if the `@` character was not part of the input OR
+ /// if a blank username was provided.
+ /// Otherwise, a non-empty string.
+ pub username: Option,
+
+ /// The URL password field, from the userinfo section of the URL.
+ ///
+ /// `None` if the `@` character was not part of the input OR
+ /// if a blank password was provided.
+ /// Otherwise, a non-empty string.
+ pub password: Option,
+}
+
+impl Url {
+ /// Create a URL from a string.
+ ///
+ /// The input must be a valid URL with a special scheme for this to succeed.
+ ///
+ /// HTTP and HTTPS are special schemes.
+ ///
+ /// See: http://url.spec.whatwg.org/#special-scheme
+ pub fn parse(input: &str) -> Result {
+ // Parse the string using rust-url, then convert.
+ match url_lib::Url::parse(input) {
+ Ok(raw_url) => Url::from_generic_url(raw_url),
+ Err(e) => Err(format!("{}", e))
+ }
+ }
+
+ /// Create a `Url` from a `rust-url` `Url`.
+ pub fn from_generic_url(raw_url: url_lib::Url) -> Result {
+ // Map empty usernames to None.
+ let username = match raw_url.username() {
+ "" => None,
+ username => Some(username.to_owned())
+ };
+
+ // Map empty passwords to None.
+ let password = match raw_url.password() {
+ Some(password) if !password.is_empty() => Some(password.to_owned()),
+ _ => None,
+ };
+
+ let port = raw_url.port_or_known_default().ok_or_else(|| format!("Unknown port for scheme: `{}`", raw_url.scheme()))?;
+ let host = raw_url.host().ok_or_else(|| "Valid host, because only data:, mailto: protocols does not have host.".to_owned())?.to_owned();
+ let path = raw_url.path_segments().ok_or_else(|| "Valid path segments. In HTTP we won't get cannot-be-a-base URLs".to_owned())?
+ .map(|part| part.to_owned()).collect();
+ let query = raw_url.query().map(|x| x.to_owned());
+
+ Ok(Url {
+ port: port,
+ host: host,
+ path: path,
+ query: query,
+ raw: raw_url,
+ username: username,
+ password: password,
+ })
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::Url;
+
+ #[test]
+ fn test_default_port() {
+ assert_eq!(Url::parse("http://example.com/wow").unwrap().port, 80u16);
+ assert_eq!(Url::parse("https://example.com/wow").unwrap().port, 443u16);
+ }
+
+ #[test]
+ fn test_explicit_port() {
+ assert_eq!(Url::parse("http://localhost:3097").unwrap().port, 3097u16);
+ }
+
+ #[test]
+ fn test_empty_username() {
+ assert!(Url::parse("http://@example.com").unwrap().username.is_none());
+ assert!(Url::parse("http://:password@example.com").unwrap().username.is_none());
+ }
+
+ #[test]
+ fn test_not_empty_username() {
+ let user = Url::parse("http://john:pass@example.com").unwrap().username;
+ assert_eq!(user.unwrap(), "john");
+
+ let user = Url::parse("http://john:@example.com").unwrap().username;
+ assert_eq!(user.unwrap(), "john");
+ }
+
+ #[test]
+ fn test_empty_password() {
+ assert!(Url::parse("http://michael@example.com").unwrap().password.is_none());
+ assert!(Url::parse("http://:@example.com").unwrap().password.is_none());
+ }
+
+ #[test]
+ fn test_not_empty_password() {
+ let pass = Url::parse("http://michael:pass@example.com").unwrap().password;
+ assert_eq!(pass.unwrap(), "pass");
+
+ let pass = Url::parse("http://:pass@example.com").unwrap().password;
+ assert_eq!(pass.unwrap(), "pass");
+ }
+}
diff --git a/ethcore/build.rs b/ethcore/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8fe38e757f8ddca6c9c910fae5f8f219b10d1b66
--- /dev/null
+++ b/ethcore/build.rs
@@ -0,0 +1,23 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+extern crate ethcore_ipc_codegen;
+
+fn main() {
+ ethcore_ipc_codegen::derive_ipc_cond("src/client/traits.rs", cfg!(feature="ipc")).unwrap();
+ ethcore_ipc_codegen::derive_ipc_cond("src/snapshot/snapshot_service_trait.rs", cfg!(feature="ipc")).unwrap();
+ ethcore_ipc_codegen::derive_ipc_cond("src/client/chain_notify.rs", cfg!(feature="ipc")).unwrap();
+}
diff --git a/ethcore/light/build.rs b/ethcore/light/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b9c79f77888ea5e0e226bdcb91d37c44b5906629
--- /dev/null
+++ b/ethcore/light/build.rs
@@ -0,0 +1,27 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+#[cfg(feature = "ipc")]
+extern crate ethcore_ipc_codegen;
+
+#[cfg(feature = "ipc")]
+fn main() {
+ ethcore_ipc_codegen::derive_binary("src/types/mod.rs.in").unwrap();
+ ethcore_ipc_codegen::derive_ipc_cond("src/provider.rs", true).unwrap();
+}
+
+#[cfg(not(feature = "ipc"))]
+fn main() { }
\ No newline at end of file
diff --git a/ethcore/light/src/types/mod.rs.in b/ethcore/light/src/types/mod.rs.in
new file mode 100644
index 0000000000000000000000000000000000000000..eba551b533c396d027c868f893165caba2d8315e
--- /dev/null
+++ b/ethcore/light/src/types/mod.rs.in
@@ -0,0 +1,17 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+pub mod request;
diff --git a/ethcore/light/src/types/request/builder.rs b/ethcore/light/src/types/request/builder.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74503f54fd942d86ebc7ef181c8d84bd392a5f02
--- /dev/null
+++ b/ethcore/light/src/types/request/builder.rs
@@ -0,0 +1,258 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Request chain builder utility.
+//! Push requests with `push`. Back-references and data required to verify responses must be
+//! supplied as well.
+
+use std::collections::HashMap;
+use std::ops::{Deref, DerefMut};
+use request::{
+ IncompleteRequest, OutputKind, Output, NoSuchOutput, ResponseError, ResponseLike,
+};
+
+/// Build chained requests. Push them onto the series with `push`,
+/// and produce a `Requests` object with `build`. Outputs are checked for consistency.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RequestBuilder {
+ output_kinds: HashMap<(usize, usize), OutputKind>,
+ requests: Vec,
+}
+
+impl Default for RequestBuilder {
+ fn default() -> Self {
+ RequestBuilder {
+ output_kinds: HashMap::new(),
+ requests: Vec::new(),
+ }
+ }
+}
+
+impl RequestBuilder {
+ /// Attempt to push a request onto the request chain. Fails if the request
+ /// references a non-existent output of a prior request.
+ pub fn push(&mut self, request: T) -> Result<(), NoSuchOutput> {
+ request.check_outputs(|req, idx, kind| {
+ match self.output_kinds.get(&(req, idx)) {
+ Some(k) if k == &kind => Ok(()),
+ _ => Err(NoSuchOutput),
+ }
+ })?;
+ let req_idx = self.requests.len();
+ request.note_outputs(|idx, kind| { self.output_kinds.insert((req_idx, idx), kind); });
+ self.requests.push(request);
+ Ok(())
+ }
+
+ /// Get a reference to the output kinds map.
+ pub fn output_kinds(&self) -> &HashMap<(usize, usize), OutputKind> {
+ &self.output_kinds
+ }
+
+ /// Convert this into a "requests" object.
+ pub fn build(self) -> Requests {
+ Requests {
+ outputs: HashMap::new(),
+ requests: self.requests,
+ answered: 0,
+ }
+ }
+}
+
+/// Requests pending responses.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Requests {
+ outputs: HashMap<(usize, usize), Output>,
+ requests: Vec,
+ answered: usize,
+}
+
+impl Requests {
+ /// Get access to the underlying slice of requests.
+ // TODO: unimplemented -> Vec, // do we _have to_ allocate?
+ pub fn requests(&self) -> &[T] { &self.requests }
+
+ /// Get the number of answered requests.
+ pub fn num_answered(&self) -> usize { self.answered }
+
+ /// Whether the batch is complete.
+ pub fn is_complete(&self) -> bool {
+ self.answered == self.requests.len()
+ }
+
+ /// Map requests from one type into another.
+ pub fn map_requests(self, f: F) -> Requests
+ where F: FnMut(T) -> U, U: IncompleteRequest
+ {
+ Requests {
+ outputs: self.outputs,
+ requests: self.requests.into_iter().map(f).collect(),
+ answered: self.answered,
+ }
+ }
+}
+
+impl Requests {
+ /// Get the next request as a filled request. Returns `None` when all requests answered.
+ pub fn next_complete(&self) -> Option {
+ if self.is_complete() {
+ None
+ } else {
+ Some(self.requests[self.answered].clone()
+ .complete()
+ .expect("All outputs checked as invariant of `Requests` object; qed"))
+ }
+ }
+
+ /// Sweep through all unanswered requests, filling them as necessary.
+ pub fn fill_unanswered(&mut self) {
+ let outputs = &mut self.outputs;
+
+ for req in self.requests.iter_mut().skip(self.answered) {
+ req.fill(|req_idx, out_idx| outputs.get(&(req_idx, out_idx)).cloned().ok_or(NoSuchOutput))
+ }
+ }
+
+ /// Supply a response, asserting its correctness.
+ /// Fill outputs based upon it.
+ pub fn supply_response_unchecked(&mut self, response: &R) {
+ if self.is_complete() { return }
+
+ let outputs = &mut self.outputs;
+ let idx = self.answered;
+ response.fill_outputs(|out_idx, output| {
+ // we don't need to check output kinds here because all back-references
+ // are validated in the builder.
+ // TODO: optimization for only storing outputs we "care about"?
+ outputs.insert((idx, out_idx), output);
+ });
+
+ self.answered += 1;
+
+ // fill as much of the next request as we can.
+ if let Some(ref mut req) = self.requests.get_mut(self.answered) {
+ req.fill(|req_idx, out_idx| outputs.get(&(req_idx, out_idx)).cloned().ok_or(NoSuchOutput))
+ }
+ }
+}
+
+impl Requests {
+ /// Supply a response for the next request.
+ /// Fails on: wrong request kind, all requests answered already.
+ pub fn supply_response(&mut self, env: &T::Environment, response: &T::Response)
+ -> Result>
+ {
+ let idx = self.answered;
+
+ // check validity.
+ if idx == self.requests.len() { return Err(ResponseError::Unexpected) }
+ let completed = self.next_complete()
+ .expect("only fails when all requests have been answered; this just checked against; qed");
+
+ let extracted = self.requests[idx]
+ .check_response(&completed, env, response).map_err(ResponseError::Validity)?;
+
+ self.supply_response_unchecked(response);
+ Ok(extracted)
+ }
+}
+
+impl Requests {
+ /// For each request, produce a response.
+ /// The responses vector produced goes up to the point where the responder
+ /// first returns `None`, an invalid response, or until all requests have been responded to.
+ pub fn respond_to_all(mut self, responder: F) -> Vec
+ where F: Fn(super::CompleteRequest) -> Option
+ {
+ let mut responses = Vec::new();
+
+ while let Some(response) = self.next_complete().and_then(&responder) {
+ match self.supply_response(&(), &response) {
+ Ok(()) => responses.push(response),
+ Err(e) => {
+ debug!(target: "pip", "produced bad response to request: {:?}", e);
+ return responses;
+ }
+ }
+ }
+
+ responses
+ }
+}
+
+impl Deref for Requests {
+ type Target = [T];
+
+ fn deref(&self) -> &[T] {
+ &self.requests[..]
+ }
+}
+
+impl DerefMut for Requests {
+ fn deref_mut(&mut self) -> &mut [T] {
+ &mut self.requests[..]
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use request::*;
+ use super::RequestBuilder;
+ use bigint::hash::H256;
+
+ #[test]
+ fn all_scalar() {
+ let mut builder = RequestBuilder::default();
+ builder.push(Request::HeaderProof(IncompleteHeaderProofRequest {
+ num: 100.into(),
+ })).unwrap();
+ builder.push(Request::Receipts(IncompleteReceiptsRequest {
+ hash: H256::default().into(),
+ })).unwrap();
+ }
+
+ #[test]
+ #[should_panic]
+ fn missing_backref() {
+ let mut builder = RequestBuilder::default();
+ builder.push(Request::HeaderProof(IncompleteHeaderProofRequest {
+ num: Field::BackReference(100, 3),
+ })).unwrap();
+ }
+
+ #[test]
+ #[should_panic]
+ fn wrong_kind() {
+ let mut builder = RequestBuilder::default();
+ assert!(builder.push(Request::HeaderProof(IncompleteHeaderProofRequest {
+ num: 100.into(),
+ })).is_ok());
+ builder.push(Request::HeaderProof(IncompleteHeaderProofRequest {
+ num: Field::BackReference(0, 0),
+ })).unwrap();
+ }
+
+ #[test]
+ fn good_backreference() {
+ let mut builder = RequestBuilder::default();
+ builder.push(Request::HeaderProof(IncompleteHeaderProofRequest {
+ num: 100.into(), // header proof puts hash at output 0.
+ })).unwrap();
+ builder.push(Request::Receipts(IncompleteReceiptsRequest {
+ hash: Field::BackReference(0, 0),
+ })).unwrap();
+ }
+}
diff --git a/ethcore/res/ethereum/metropolis_test.json b/ethcore/res/ethereum/metropolis_test.json
new file mode 100644
index 0000000000000000000000000000000000000000..a452e5a80a121b35e01d85fb3c40443868bcdf7f
--- /dev/null
+++ b/ethcore/res/ethereum/metropolis_test.json
@@ -0,0 +1,53 @@
+{
+ "name": "Metropolis (Test)",
+ "engine": {
+ "Ethash": {
+ "params": {
+ "minimumDifficulty": "0x020000",
+ "difficultyBoundDivisor": "0x0800",
+ "durationLimit": "0x0d",
+
+ "homesteadTransition": "0x0",
+ "eip150Transition": "0x0",
+ "eip160Transition": "0x0",
+ "eip161abcTransition": "0x0",
+ "eip161dTransition": "0x0",
+ "maxCodeSize": 24576
+ }
+ }
+ },
+ "params": {
+ "gasLimitBoundDivisor": "0x0400",
+ "blockReward": "0x4563918244F40000",
+ "registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
+ "accountStartNonce": "0x00",
+ "maximumExtraDataSize": "0x20",
+ "minGasLimit": "0x1388",
+ "networkID" : "0x1",
+ "eip98Transition": "0x0",
+ "eip86Transition": "0x0",
+ "eip140Transition": "0x0",
+ "eip210Transition": "0x0",
+ "eip155Transition": "0x0"
+ },
+ "genesis": {
+ "seal": {
+ "ethereum": {
+ "nonce": "0x0000000000000042",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+ }
+ },
+ "difficulty": "0x400000000",
+ "author": "0x0000000000000000000000000000000000000000",
+ "timestamp": "0x00",
+ "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
+ "gasLimit": "0x1388"
+ },
+ "accounts": {
+ "0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+ "0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+ "0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+ "0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } }
+ }
+}
diff --git a/ethcore/res/ethereum/tobalaba.json b/ethcore/res/ethereum/tobalaba.json
new file mode 100644
index 0000000000000000000000000000000000000000..f580a0a19e926c4b659dc69e2308818becbfc360
--- /dev/null
+++ b/ethcore/res/ethereum/tobalaba.json
@@ -0,0 +1,38 @@
+{
+ "name": "Tobalaba",
+ "engine": {
+ "authorityRound": {
+ "params": {
+ "stepDuration": "3",
+ "validators": {
+ "safeContract": "0x1000000000000000000000000000000000000005"
+ }
+ }
+ }
+ },
+ "params": {
+ "maximumExtraDataSize": "0x20",
+ "minGasLimit": "0x1388",
+ "networkID": "0x62121",
+ "gasLimitBoundDivisor": "0x400"
+ },
+ "genesis": {
+ "seal": {
+ "authorityRound": {
+ "step": "0x0",
+ "signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ }
+ },
+ "difficulty": "0x20000",
+ "gasLimit": "0x800000"
+ },
+ "accounts": {
+ "0x1000000000000000000000000000000000000005": {
+ "balance": "1",
+ "constructor": "6060604052602060405190810160405280734ba15b56452521c0826a35a6f2022e1210fc519b73ffffffffffffffffffffffffffffffffffffffff16815250600190600161004e929190610100565b50602060405190810160405280734ba15b56452521c0826a35a6f2022e1210fc519b73ffffffffffffffffffffffffffffffffffffffff168152506002906001610099929190610100565b5034156100a557600080fd5b5b734ba15b56452521c0826a35a6f2022e1210fc519b6000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b6101cd565b828054828255906000526020600020908101928215610179579160200282015b828111156101785782518260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555091602001919060010190610120565b5b509050610186919061018a565b5090565b6101ca91905b808211156101c657600081816101000a81549073ffffffffffffffffffffffffffffffffffffffff021916905550600101610190565b5090565b90565b610a07806101dc6000396000f30060606040523615610081576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806318def8ef1461009957806340a141ff146100e65780634d238c8e1461011f57806375286211146101585780638914d3041461016d5780638da5cb5b14610196578063b7ab4db5146101eb575b341561008c57600080fd5b6100975b600080fd5b565b005b34156100a457600080fd5b6100d0600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050610256565b6040518082815260200191505060405180910390f35b34156100f157600080fd5b61011d600480803573ffffffffffffffffffffffffffffffffffffffff1690602001909190505061026e565b005b341561012a57600080fd5b610156600480803573ffffffffffffffffffffffffffffffffffffffff169060200190919050506105da565b005b341561016357600080fd5b61016b61079f565b005b341561017857600080fd5b6101806107ed565b6040518082815260200191505060405180910390f35b34156101a157600080fd5b6101a96107fb565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34156101f657600080fd5b6101fe610820565b6040518080602001828103825283818151815260200191508051906020019060200280838360005b838110156102425780820151818401525b602081019050610226565b505050509050019250505060405180910390f35b60036020528060005260406000206000915090505481565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156102cb57600080fd5b6000600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020541415151561031a57600080fd5b6001806103256107ed565b0381548110151561033257fe5b906000526020600020900160005b9054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050806002600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020548154811015156103b057fe5b906000526020600020900160005b6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600260016002805490500381548110151561041157fe5b906000526020600020900160005b6101000a81549073ffffffffffffffffffffffffffffffffffffffff021916905560016002805490500360028161045691906108b5565b50600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506000600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506001430340600019167f55252fa6eee4741b4e24a74a70e9c11fd2c2281df8d6ea13126ff845f7825c896002604051808060200182810382528381815481526020019150805480156105c657602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831161057c575b50509250505060405180910390a25b5b5050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561063557600080fd5b6002805480600101828161064991906108e1565b916000526020600020900160005b83909190916101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050600160028054905003600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506001430340600019167f55252fa6eee4741b4e24a74a70e9c11fd2c2281df8d6ea13126ff845f7825c8960026040518080602001828103825283818154815260200191508054801561078c57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311610742575b50509250505060405180910390a25b5b50565b73fffffffffffffffffffffffffffffffffffffffe3373ffffffffffffffffffffffffffffffffffffffff161415156107d757600080fd5b600260019080546107e992919061090d565b505b565b600060028054905090505b90565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b61082861095f565b60018054806020026020016040519081016040528092919081815260200182805480156108aa57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311610860575b505050505090505b90565b8154818355818115116108dc578183600052602060002091820191016108db9190610973565b5b505050565b815481835581811511610908578183600052602060002091820191016109079190610973565b5b505050565b82805482825590600052602060002090810192821561094e5760005260206000209182015b8281111561094d578254825591600101919060010190610932565b5b50905061095b9190610998565b5090565b602060405190810160405280600081525090565b61099591905b80821115610991576000816000905550600101610979565b5090565b90565b6109d891905b808211156109d457600081816101000a81549073ffffffffffffffffffffffffffffffffffffffff02191690555060010161099e565b5090565b905600a165627a7a72305820f010290c3ae950b0bd158019fc7b606faa22bd57d199727172b91971312cfca20029"
+ },
+ "0x4ba15b56452521c0826a35a6f2022e1210fc519b": {
+ "balance": "0x7E37BE2022B2B09472D89C0000"
+ }
+ }
+}
\ No newline at end of file
diff --git a/ethcore/src/json_tests/homestead_chain.rs b/ethcore/src/json_tests/homestead_chain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5f0fe5769ee9385eecd919356737005b04fe39fe
--- /dev/null
+++ b/ethcore/src/json_tests/homestead_chain.rs
@@ -0,0 +1,39 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+use super::chain::json_chain_test;
+use tests::helpers::*;
+
+fn do_json_test(json_data: &[u8]) -> Vec {
+ json_chain_test(json_data, ChainEra::Homestead)
+}
+
+declare_test!{BlockchainTests_Homestead_bcBlockGasLimitTest, "BlockchainTests/Homestead/bcBlockGasLimitTest"}
+declare_test!{BlockchainTests_Homestead_bcForkStressTest, "BlockchainTests/Homestead/bcForkStressTest"}
+declare_test!{BlockchainTests_Homestead_bcGasPricerTest, "BlockchainTests/Homestead/bcGasPricerTest"}
+declare_test!{BlockchainTests_Homestead_bcInvalidHeaderTest, "BlockchainTests/Homestead/bcInvalidHeaderTest"}
+declare_test!{BlockchainTests_Homestead_bcInvalidRLPTest, "BlockchainTests/Homestead/bcInvalidRLPTest"}
+declare_test!{BlockchainTests_Homestead_bcMultiChainTest, "BlockchainTests/Homestead/bcMultiChainTest"}
+declare_test!{BlockchainTests_Homestead_bcRPC_API_Test, "BlockchainTests/Homestead/bcRPC_API_Test"}
+declare_test!{BlockchainTests_Homestead_bcStateTest, "BlockchainTests/Homestead/bcStateTest"}
+declare_test!{BlockchainTests_Homestead_bcTotalDifficultyTest, "BlockchainTests/Homestead/bcTotalDifficultyTest"}
+declare_test!{BlockchainTests_Homestead_bcUncleHeaderValiditiy, "BlockchainTests/Homestead/bcUncleHeaderValiditiy"}
+declare_test!{BlockchainTests_Homestead_bcUncleTest, "BlockchainTests/Homestead/bcUncleTest"}
+declare_test!{BlockchainTests_Homestead_bcValidBlockTest, "BlockchainTests/Homestead/bcValidBlockTest"}
+declare_test!{BlockchainTests_Homestead_bcWalletTest, "BlockchainTests/Homestead/bcWalletTest"}
+declare_test!{BlockchainTests_Homestead_bcShanghaiLove, "BlockchainTests/Homestead/bcShanghaiLove"}
+declare_test!{BlockchainTests_Homestead_bcSuicideIssue, "BlockchainTests/Homestead/bcSuicideIssue"}
+declare_test!{BlockchainTests_Homestead_bcExploitTest, "BlockchainTests/Homestead/bcExploitTest"}
diff --git a/ethcore/src/snapshot/snapshot_service_trait.rs b/ethcore/src/snapshot/snapshot_service_trait.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9ef7706b442ae17b7108c5f53d094f3368e25a01
--- /dev/null
+++ b/ethcore/src/snapshot/snapshot_service_trait.rs
@@ -0,0 +1,58 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+use super::{ManifestData, RestorationStatus};
+use bigint::hash::H256;
+use util::Bytes;
+use ipc::IpcConfig;
+
+/// The interface for a snapshot network service.
+/// This handles:
+/// - restoration of snapshots to temporary databases.
+/// - responding to queries for snapshot manifests and chunks
+#[ipc(client_ident="RemoteSnapshotService")]
+pub trait SnapshotService : Sync + Send {
+ /// Query the most recent manifest data.
+ fn manifest(&self) -> Option;
+
+ /// Get the supported range of snapshot version numbers.
+ /// `None` indicates warp sync isn't supported by the consensus engine.
+ fn supported_versions(&self) -> Option<(u64, u64)>;
+
+ /// Get raw chunk for a given hash.
+ fn chunk(&self, hash: H256) -> Option;
+
+ /// Ask the snapshot service for the restoration status.
+ fn status(&self) -> RestorationStatus;
+
+ /// Begin snapshot restoration.
+ /// If restoration in-progress, this will reset it.
+ /// From this point on, any previous snapshot may become unavailable.
+ fn begin_restore(&self, manifest: ManifestData);
+
+ /// Abort an in-progress restoration if there is one.
+ fn abort_restore(&self);
+
+ /// Feed a raw state chunk to the service to be processed asynchronously.
+ /// no-op if not currently restoring.
+ fn restore_state_chunk(&self, hash: H256, chunk: Bytes);
+
+ /// Feed a raw block chunk to the service to be processed asynchronously.
+ /// no-op if currently restoring.
+ fn restore_block_chunk(&self, hash: H256, chunk: Bytes);
+}
+
+impl IpcConfig for SnapshotService { }
diff --git a/ethcore/src/tests/rpc.rs b/ethcore/src/tests/rpc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6444daa56b5d156b262a2021b4a58a73930f6c75
--- /dev/null
+++ b/ethcore/src/tests/rpc.rs
@@ -0,0 +1,78 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Client RPC tests
+
+use nanoipc;
+use std::sync::Arc;
+use std::sync::atomic::{Ordering, AtomicBool};
+use client::{Client, BlockChainClient, ClientConfig, BlockId};
+use client::remote::RemoteClient;
+use tests::helpers::*;
+use devtools::*;
+use miner::Miner;
+use crossbeam;
+use io::IoChannel;
+use util::kvdb::DatabaseConfig;
+
+pub fn run_test_worker(scope: &crossbeam::Scope, stop: Arc, socket_path: &str) {
+ let socket_path = socket_path.to_owned();
+ scope.spawn(move || {
+ let temp = RandomTempPath::create_dir();
+ let spec = get_test_spec();
+ let db_config = DatabaseConfig::with_columns(::db::NUM_COLUMNS);
+
+ let client = Client::new(
+ ClientConfig::default(),
+ &spec,
+ temp.as_path(),
+ Arc::new(Miner::with_spec(&spec)),
+ IoChannel::disconnected(),
+ &db_config
+ ).unwrap();
+ let mut worker = nanoipc::Worker::new(&(client as Arc));
+ worker.add_reqrep(&socket_path).unwrap();
+ while !stop.load(Ordering::Relaxed) {
+ worker.poll();
+ }
+ });
+}
+
+#[test]
+fn can_handshake() {
+ crossbeam::scope(|scope| {
+ let stop_guard = StopGuard::new();
+ let socket_path = "ipc:///tmp/parity-client-rpc-10.ipc";
+ run_test_worker(scope, stop_guard.share(), socket_path);
+ let remote_client = nanoipc::generic_client::>(socket_path).unwrap();
+
+ assert!(remote_client.handshake().is_ok());
+ })
+}
+
+#[test]
+fn can_query_block() {
+ crossbeam::scope(|scope| {
+ let stop_guard = StopGuard::new();
+ let socket_path = "ipc:///tmp/parity-client-rpc-20.ipc";
+ run_test_worker(scope, stop_guard.share(), socket_path);
+ let remote_client = nanoipc::generic_client::>(socket_path).unwrap();
+
+ let non_existant_block = remote_client.block_header(BlockId::Number(999));
+
+ assert!(non_existant_block.is_none());
+ })
+}
diff --git a/ethcore/wasm/src/call_args.rs b/ethcore/wasm/src/call_args.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7fb50bff3b28f8af927550046532ea7d9f608096
--- /dev/null
+++ b/ethcore/wasm/src/call_args.rs
@@ -0,0 +1,63 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Wasm evm call arguments helper
+
+use bigint::prelude::U256;
+use bigint::hash::H160;
+
+/// Input part of the wasm call descriptor
+pub struct CallArgs {
+ /// Receiver of the transaction
+ pub address: [u8; 20],
+
+ /// Sender of the transaction
+ pub sender: [u8; 20],
+
+ /// Original transaction initiator
+ pub origin: [u8; 20],
+
+ /// Transfer value
+ pub value: [u8; 32],
+
+ /// call/create params
+ pub data: Vec,
+}
+
+impl CallArgs {
+ /// New contract call payload with known parameters
+ pub fn new(address: H160, sender: H160, origin: H160, value: U256, data: Vec) -> Self {
+ let mut descriptor = CallArgs {
+ address: [0u8; 20],
+ sender: [0u8; 20],
+ origin: [0u8; 20],
+ value: [0u8; 32],
+ data: data,
+ };
+
+ descriptor.address.copy_from_slice(&*address);
+ descriptor.sender.copy_from_slice(&*sender);
+ descriptor.origin.copy_from_slice(&*origin);
+ value.to_big_endian(&mut descriptor.value);
+
+ descriptor
+ }
+
+ /// Total call payload length in linear memory
+ pub fn len(&self) -> u32 {
+ self.data.len() as u32 + 92
+ }
+}
diff --git a/ipc-common-types/Cargo.toml b/ipc-common-types/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a9efe143986d26197e9494bf0824ad52c3ffebf2
--- /dev/null
+++ b/ipc-common-types/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+description = "Types that implement IPC and are common to multiple modules."
+name = "ipc-common-types"
+version = "1.8.0"
+license = "GPL-3.0"
+authors = ["Parity Technologies "]
+build = "build.rs"
+
+[build-dependencies]
+ethcore-ipc-codegen = { path = "../ipc/codegen" }
+
+[dependencies]
+semver = "0.6"
+ethcore-ipc = { path = "../ipc/rpc" }
+ethcore-util = { path = "../util" }
+ethcore-bigint = { path = "../util/bigint" }
diff --git a/ipc-common-types/build.rs b/ipc-common-types/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3a51d6a215876b207501304611fc7e5ee68cb944
--- /dev/null
+++ b/ipc-common-types/build.rs
@@ -0,0 +1,21 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+extern crate ethcore_ipc_codegen;
+
+fn main() {
+ ethcore_ipc_codegen::derive_binary("src/types/mod.rs.in").unwrap();
+}
diff --git a/ipc-common-types/src/lib.rs b/ipc-common-types/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c1d18a8d76197e331cf7aef4e4b65024441de8fb
--- /dev/null
+++ b/ipc-common-types/src/lib.rs
@@ -0,0 +1,26 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Updater for Parity executables
+
+extern crate semver;
+extern crate ethcore_util as util;
+extern crate ethcore_bigint as bigint;
+extern crate ethcore_ipc as ipc;
+
+mod types;
+
+pub use types::*;
diff --git a/ipc-common-types/src/types/mod.rs b/ipc-common-types/src/types/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..68dfe0b252839d0b6027446bc17c3ead1ea46d7d
--- /dev/null
+++ b/ipc-common-types/src/types/mod.rs
@@ -0,0 +1,21 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Types used in the public api
+
+#![allow(dead_code, unused_assignments, unused_variables)] // codegen issues
+include!(concat!(env!("OUT_DIR"), "/mod.rs.in"));
+
diff --git a/ipc-common-types/src/types/mod.rs.in b/ipc-common-types/src/types/mod.rs.in
new file mode 100644
index 0000000000000000000000000000000000000000..f137d1d607bdba37c1c5b262bd866eb0d6249fd4
--- /dev/null
+++ b/ipc-common-types/src/types/mod.rs.in
@@ -0,0 +1,21 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+pub mod release_track;
+pub mod version_info;
+
+pub use release_track::{ReleaseTrack};
+pub use version_info::{VersionInfo};
\ No newline at end of file
diff --git a/ipc-common-types/src/types/release_track.rs b/ipc-common-types/src/types/release_track.rs
new file mode 100644
index 0000000000000000000000000000000000000000..418f590c88ce34d7a15286320c19753f4ec14b3d
--- /dev/null
+++ b/ipc-common-types/src/types/release_track.rs
@@ -0,0 +1,83 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Types used in the public API
+
+use std::fmt;
+
+/// A release's track.
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+#[binary]
+pub enum ReleaseTrack {
+ /// Stable track.
+ Stable,
+ /// Beta track.
+ Beta,
+ /// Nightly track.
+ Nightly,
+ /// Testing track.
+ Testing,
+ /// No known track, also "current executable's track" when it's not yet known.
+ Unknown,
+}
+
+impl fmt::Display for ReleaseTrack {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "{}", match *self {
+ ReleaseTrack::Stable => "stable",
+ ReleaseTrack::Beta => "beta",
+ ReleaseTrack::Nightly => "nightly",
+ ReleaseTrack::Testing => "testing",
+ ReleaseTrack::Unknown => "unknown",
+ })
+ }
+}
+
+impl<'a> From<&'a str> for ReleaseTrack {
+ fn from(s: &'a str) -> Self {
+ match s {
+ "stable" => ReleaseTrack::Stable,
+ "beta" => ReleaseTrack::Beta,
+ "nightly" => ReleaseTrack::Nightly,
+ "testing" => ReleaseTrack::Testing,
+ _ => ReleaseTrack::Unknown,
+ }
+ }
+}
+
+impl From for ReleaseTrack {
+ fn from(i: u8) -> Self {
+ match i {
+ 1 => ReleaseTrack::Stable,
+ 2 => ReleaseTrack::Beta,
+ 3 => ReleaseTrack::Nightly,
+ 4 => ReleaseTrack::Testing,
+ _ => ReleaseTrack::Unknown,
+ }
+ }
+}
+
+impl Into for ReleaseTrack {
+ fn into(self) -> u8 {
+ match self {
+ ReleaseTrack::Stable => 1,
+ ReleaseTrack::Beta => 2,
+ ReleaseTrack::Nightly => 3,
+ ReleaseTrack::Testing => 4,
+ ReleaseTrack::Unknown => 0,
+ }
+ }
+}
diff --git a/ipc-common-types/src/types/version_info.rs b/ipc-common-types/src/types/version_info.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ef386824d7c77ae62e1bcb9608dbb1d5409cd8eb
--- /dev/null
+++ b/ipc-common-types/src/types/version_info.rs
@@ -0,0 +1,70 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Types used in the public API
+
+use std::fmt;
+use std::str::FromStr;
+use semver::{Version};
+use bigint::hash::H160;
+use util::misc::raw_package_info;
+use release_track::ReleaseTrack;
+
+/// Version information of a particular release.
+#[derive(Debug, Clone, PartialEq)]
+#[binary]
+pub struct VersionInfo {
+ /// The track on which it was released.
+ pub track: ReleaseTrack,
+ /// The version.
+ pub version: Version,
+ /// The (SHA1?) 160-bit hash of this build's code base.
+ pub hash: H160,
+}
+
+impl fmt::Display for VersionInfo {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "{}.{}.{}-{}-{}", self.version.major, self.version.minor, self.version.patch, self.track, self.hash)
+ }
+}
+
+impl VersionInfo {
+ /// Get information for this (currently running) binary.
+ pub fn this() -> Self {
+ let raw = raw_package_info();
+ VersionInfo {
+ track: raw.0.into(),
+ version: { let mut v = Version::parse(raw.1).expect("Environment variables are known to be valid; qed"); v.build = vec![]; v.pre = vec![]; v },
+ hash: H160::from_str(raw.2).unwrap_or_else(|_| H160::zero()),
+ }
+ }
+
+ /// Compose the information from the provided raw fields.
+ pub fn from_raw(semver: u32, track: u8, hash: H160) -> Self {
+ let t = track.into();
+ VersionInfo {
+ version: Version {
+ major: (semver >> 16) as u64,
+ minor: ((semver >> 8) & 0xff) as u64,
+ patch: (semver & 0xff) as u64,
+ build: vec![],
+ pre: vec![],
+ },
+ track: t,
+ hash: hash,
+ }
+ }
+}
diff --git a/ipc/codegen/Cargo.toml b/ipc/codegen/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..69580e08d76f7faf55f66bc4706cc55eae324923
--- /dev/null
+++ b/ipc/codegen/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "ethcore-ipc-codegen"
+version = "1.8.0"
+authors = ["Parity Technologies "]
+license = "GPL-3.0"
+description = "Macros to auto-generate implementations for ipc call"
+build = "build.rs"
+keywords = ["ipc", "codegen"]
+
+[features]
+default = ["with-syntex"]
+nightly = ["quasi_macros"]
+nightly-testing = ["clippy"]
+with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
+
+[build-dependencies]
+quasi_codegen = { version = "0.32", optional = true }
+syntex = { version = "0.58", optional = true }
+
+[dependencies]
+aster = { version = "0.41", default-features = false }
+clippy = { version = "^0.*", optional = true }
+quasi = { version = "0.32", default-features = false }
+quasi_macros = { version = "0.32", optional = true }
+syntex = { version = "0.58", optional = true }
+syntex_syntax = { version = "0.58", optional = true }
diff --git a/ipc/codegen/build.rs b/ipc/codegen/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..442abf7dfba6404c05fbf2923dbe67346457b1b1
--- /dev/null
+++ b/ipc/codegen/build.rs
@@ -0,0 +1,43 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+
+#[cfg(feature = "with-syntex")]
+mod inner {
+ extern crate syntex;
+ extern crate quasi_codegen;
+
+ use std::env;
+ use std::path::Path;
+
+ pub fn main() {
+ let out_dir = env::var_os("OUT_DIR").unwrap();
+
+ let src = Path::new("src/lib.rs.in");
+ let dst = Path::new(&out_dir).join("lib.rs");
+
+ quasi_codegen::expand(&src, &dst).unwrap();
+ }
+}
+
+#[cfg(not(feature = "with-syntex"))]
+mod inner {
+ pub fn main() {}
+}
+
+fn main() {
+ inner::main();
+}
diff --git a/ipc/codegen/src/codegen.rs b/ipc/codegen/src/codegen.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f4752d9716407f99e954183210960ba8803e542
--- /dev/null
+++ b/ipc/codegen/src/codegen.rs
@@ -0,0 +1,898 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+use aster;
+
+use syntax::ast::{
+ MetaItem,
+ Item,
+ ImplItemKind,
+ MethodSig,
+ Arg,
+ PatKind,
+ FunctionRetTy,
+ Ty,
+ TraitRef,
+ Ident,
+ Generics,
+ TraitItemKind,
+};
+
+use syntax::ast;
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::ptr::P;
+
+pub struct Error;
+
+const RESERVED_MESSAGE_IDS: u16 = 16;
+
+pub fn expand_ipc_implementation(
+ cx: &mut ExtCtxt,
+ span: Span,
+ meta_item: &MetaItem,
+ annotatable: &Annotatable,
+ push: &mut FnMut(Annotatable)
+) {
+ let item = match *annotatable {
+ Annotatable::Item(ref item) => item,
+ _ => {
+ cx.span_err(meta_item.span, "`#[ipc]` may only be applied to implementations and traits");
+ return;
+ },
+ };
+
+ let builder = aster::AstBuilder::new().span(span);
+
+ let interface_map = match implement_interface(cx, &builder, &item, push, meta_item) {
+ Ok(interface_map) => interface_map,
+ Err(Error) => { return; },
+ };
+
+ push_client(cx, &builder, &interface_map, push);
+
+ push(Annotatable::Item(interface_map.item));
+}
+
+macro_rules! literal {
+ ($builder:ident, $($arg:tt)*) => {
+ $builder.expr().lit().str::<&str>(&format!($($arg)*))
+ }
+}
+
+fn field_name(builder: &aster::AstBuilder, arg: &Arg) -> ast::Ident {
+ match arg.pat.node {
+ PatKind::Ident(_, ref ident, _) => builder.id(ident.node),
+ _ => { panic!("unexpected param in interface: {:?}", arg.pat.node) }
+ }
+}
+
+pub fn replace_slice_u8(builder: &aster::AstBuilder, ty: &P) -> P {
+ if ::syntax::print::pprust::ty_to_string(&strip_ptr(ty)) == "[u8]" {
+ return builder.ty().id("Vec")
+ }
+ ty.clone()
+}
+
+struct NamedSignature<'a> {
+ sig: &'a MethodSig,
+ ident: &'a Ident,
+}
+
+fn push_invoke_signature_aster(
+ builder: &aster::AstBuilder,
+ named_signature: &NamedSignature,
+ push: &mut FnMut(Annotatable),
+) -> Dispatch {
+ let inputs = &named_signature.sig.decl.inputs;
+ let (input_type_name, input_arg_names, input_arg_tys) = if inputs.len() > 0 {
+ let first_field_name = field_name(builder, &inputs[0]).name.as_str();
+ if &*first_field_name == "self" && inputs.len() == 1 { (None, vec![], vec![]) }
+ else {
+ let skip = if &*first_field_name == "self" { 2 } else { 1 };
+ let name_str = format!("{}_input", named_signature.ident.name.as_str());
+
+ let mut arg_names = Vec::new();
+ let mut arg_tys = Vec::new();
+
+ let arg_name = format!("{}", field_name(builder, &inputs[skip-1]).name);
+ let arg_ty = &inputs[skip-1].ty;
+
+ let mut tree = builder.item()
+ .attr().word("binary")
+ .attr().word("allow(non_camel_case_types)")
+ .struct_(name_str.as_str())
+ .field(arg_name.as_str())
+ .ty().build(replace_slice_u8(builder, &strip_ptr(arg_ty)));
+
+ arg_names.push(arg_name);
+ arg_tys.push(arg_ty.clone());
+ for arg in inputs.iter().skip(skip) {
+ let arg_name = format!("{}", field_name(builder, &arg));
+ let arg_ty = &arg.ty;
+
+ tree = tree.field(arg_name.as_str()).ty().build(replace_slice_u8(builder, &strip_ptr(arg_ty)));
+ arg_names.push(arg_name);
+ arg_tys.push(arg_ty.clone());
+ }
+
+ push(Annotatable::Item(tree.build()));
+ (Some(name_str.to_owned()), arg_names, arg_tys)
+ }
+ }
+ else {
+ (None, vec![], vec![])
+ };
+
+ let return_type_ty = match named_signature.sig.decl.output {
+ FunctionRetTy::Ty(ref ty) => {
+ let name_str = format!("{}_output", named_signature.ident.name.as_str());
+ let tree = builder.item()
+ .attr().word("binary")
+ .attr().word("allow(non_camel_case_types)")
+ .struct_(name_str.as_str())
+ .field(format!("payload")).ty().build(ty.clone());
+ push(Annotatable::Item(tree.build()));
+ Some(ty.clone())
+ }
+ _ => None
+ };
+
+ Dispatch {
+ function_name: format!("{}", named_signature.ident.name.as_str()),
+ input_type_name: input_type_name,
+ input_arg_names: input_arg_names,
+ input_arg_tys: input_arg_tys,
+ return_type_ty: return_type_ty,
+ }
+}
+
+struct Dispatch {
+ function_name: String,
+ input_type_name: Option,
+ input_arg_names: Vec,
+ input_arg_tys: Vec>,
+ return_type_ty: Option>,
+}
+
+// This is the expanded version of this:
+//
+// let invoke_serialize_stmt = quote_stmt!(cx, {
+// ::bincode::serde::serialize(& $output_type_id { payload: self. $function_name ($hand_param_a, $hand_param_b) }, ::bincode::SizeLimit::Infinite).unwrap()
+// });
+//
+// But the above does not allow comma-separated expressions for arbitrary number
+// of parameters ...$hand_param_a, $hand_param_b, ... $hand_param_n
+fn implement_dispatch_arm_invoke_stmt(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ dispatch: &Dispatch,
+) -> ast::Stmt
+{
+ use ::syntax::tokenstream::TokenTree::Token;
+ let function_name = builder.id(dispatch.function_name.as_str());
+
+ let input_args_exprs = dispatch.input_arg_names.iter().enumerate().map(|(arg_index, arg_name)| {
+ let arg_ident = builder.id(arg_name);
+ let expr = quote_expr!(cx, input. $arg_ident);
+ if has_ptr(&dispatch.input_arg_tys[arg_index]) { quote_expr!(cx, & $expr) }
+ else { expr }
+ }).collect::>>();
+
+ let ext_cx = &*cx;
+ ::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
+ ext_cx.parse_sess(),
+ {
+ let _sp = ext_cx.call_site();
+ let mut tt = ::std::vec::Vec::new();
+
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+
+ if dispatch.return_type_ty.is_some() {
+ tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("ipc"))));
+ tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("binary"))));
+ tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("serialize"))));
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+ tt.push(Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+ }
+
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"))));
+ tt.push(Token(_sp, ::syntax::parse::token::Dot));
+ tt.extend(::quasi::ToTokens::to_tokens(&function_name, ext_cx).into_iter());
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+
+ for arg_expr in input_args_exprs {
+ tt.extend(::quasi::ToTokens::to_tokens(&arg_expr, ext_cx).into_iter());
+ tt.push(Token(_sp, ::syntax::parse::token::Comma));
+ }
+
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+
+ if dispatch.return_type_ty.is_some() {
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+ tt.push(Token(_sp, ::syntax::parse::token::Dot));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("unwrap"))));
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+ }
+ else {
+ tt.push(Token(_sp, ::syntax::parse::token::Semi));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("Vec"))));
+ tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("new"))));
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+
+ }
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+
+ tt
+ }
+ )).unwrap()
+}
+
+fn implement_dispatch_arm_invoke(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ dispatch: &Dispatch,
+ buffer: bool,
+) -> P
+{
+ let deserialize_expr = if buffer {
+ quote_expr!(cx,
+ ::ipc::binary::deserialize(buf)
+ .unwrap_or_else(|e| { panic!("ipc error while deserializing payload, aborting \n payload: {:?}, \n error: {:?}", buf, e); } )
+ )
+ } else {
+ quote_expr!(cx,
+ ::ipc::binary::deserialize_from(r)
+ .unwrap_or_else(|e| { panic!("ipc error while deserializing payload, aborting \n error: {:?}", e); } )
+ )
+ };
+
+ let invoke_serialize_stmt = implement_dispatch_arm_invoke_stmt(cx, builder, dispatch);
+ dispatch.input_type_name.as_ref().map(|val| {
+ let input_type_id = builder.id(val.clone().as_str());
+ quote_expr!(cx, {
+ let input: $input_type_id = $deserialize_expr;
+ $invoke_serialize_stmt
+ })
+ }).unwrap_or(quote_expr!(cx, { $invoke_serialize_stmt }))
+}
+
+/// generates dispatch match for method id
+fn implement_dispatch_arm(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ index: u32,
+ dispatch: &Dispatch,
+ buffer: bool,
+) -> ast::Arm
+{
+ let index_ident = builder.id(format!("{}", index + (RESERVED_MESSAGE_IDS as u32)).as_str());
+ let invoke_expr = implement_dispatch_arm_invoke(cx, builder, dispatch, buffer);
+ let trace = literal!(builder, "Dispatching: {}", &dispatch.function_name);
+ quote_arm!(cx, $index_ident => {
+ trace!(target: "ipc", $trace);
+ $invoke_expr
+ })
+}
+
+fn implement_dispatch_arms(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ dispatches: &[Dispatch],
+ buffer: bool,
+) -> Vec
+{
+ let mut index = -1;
+ dispatches.iter()
+ .map(|dispatch| { index = index + 1; implement_dispatch_arm(cx, builder, index as u32, dispatch, buffer) }).collect()
+}
+
+pub fn strip_ptr(ty: &P) -> P {
+ if let ast::TyKind::Rptr(_, ref ptr_mut) = ty.node {
+ ptr_mut.ty.clone()
+ }
+ else { ty.clone() }
+}
+
+pub fn has_ptr(ty: &P) -> bool {
+ if let ast::TyKind::Rptr(_, ref _ptr_mut) = ty.node {
+ true
+ }
+ else { false }
+}
+
+/// returns an expression with the body for single operation that is being sent to server
+/// operation itself serializes input, writes to socket and waits for socket to respond
+/// (the latter only if original method signature returns anyting)
+///
+/// assuming expanded class contains method
+/// fn commit(&self, f: u32) -> u32
+///
+/// the expanded implementation will generate method for the client like that
+/// #[binary]
+/// struct Request<'a> {
+/// f: &'a u32,
+/// }
+/// let payload = Request{f: &f,};
+/// let mut socket_ref = self.socket.borrow_mut();
+/// let mut socket = socket_ref.deref_mut();
+/// let serialized_payload = ::bincode::serde::serialize(&payload, ::bincode::SizeLimit::Infinite).unwrap();
+/// ::ipc::invoke(0, &Some(serialized_payload), &mut socket);
+/// while !socket.ready().load(::std::sync::atomic::Ordering::Relaxed) { }
+/// ::bincode::serde::deserialize_from::<_, u32>(&mut socket, ::bincode::SizeLimit::Infinite).unwrap()
+fn implement_client_method_body(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ index: u16,
+ interface_map: &InterfaceMap,
+) -> P
+{
+ use ::syntax::tokenstream::TokenTree::Token;
+
+ let dispatch = &interface_map.dispatches[index as usize];
+ let index_ident = builder.id(format!("{}", index + RESERVED_MESSAGE_IDS).as_str());
+
+ let request = if dispatch.input_arg_names.len() > 0 {
+
+ let arg_name = dispatch.input_arg_names[0].as_str();
+ let static_ty = strip_ptr(&dispatch.input_arg_tys[0]);
+ let arg_ty = builder
+ .ty().ref_()
+ .lifetime("'a")
+ .ty()
+ .build(static_ty.clone());
+
+ let mut tree = builder.item()
+ .attr().word("binary")
+ .struct_("Request")
+ .generics()
+ .lifetime_name("'a")
+ .build()
+ .field(arg_name).ty()
+ .build(arg_ty);
+
+ for arg_idx in 1..dispatch.input_arg_names.len() {
+ let arg_name = dispatch.input_arg_names[arg_idx].as_str();
+ let static_ty = strip_ptr(&dispatch.input_arg_tys[arg_idx]);
+
+ let arg_ty = builder
+ .ty().ref_()
+ .lifetime("'a")
+ .ty()
+ .build(static_ty);
+ tree = tree.field(arg_name).ty().build(arg_ty);
+
+ }
+ let mut request_serialization_statements = Vec::new();
+
+ let struct_tree = tree.build();
+ let struct_stmt = quote_stmt!(cx, $struct_tree);
+ request_serialization_statements.push(struct_stmt);
+
+ // actually this is just expanded version of this:
+ // request_serialization_statements.push(quote_stmt!(cx, let payload = Request { p1: &p1, p2: &p2, ... pn: &pn, }));
+ // again, cannot dynamically create expression with arbitrary number of comma-separated members
+ request_serialization_statements.push({
+ let ext_cx = &*cx;
+ ::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
+ ext_cx.parse_sess(),
+ {
+ let _sp = ext_cx.call_site();
+ let mut tt = ::std::vec::Vec::new();
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("let"))));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("payload"))));
+ tt.push(Token(_sp, ::syntax::parse::token::Eq));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("Request"))));
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+
+ for arg in dispatch.input_arg_names.iter() {
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()))));
+ tt.push(Token(_sp, ::syntax::parse::token::Colon));
+ tt.push(Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()))));
+ tt.push(Token(_sp, ::syntax::parse::token::Comma));
+ }
+
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+ tt
+ }))
+ });
+
+ request_serialization_statements.push(
+ quote_stmt!(cx, let mut socket = self.socket.write().unwrap(); ));
+
+ request_serialization_statements.push(
+ quote_stmt!(cx, let serialized_payload = ::ipc::binary::serialize(&payload).unwrap()));
+
+ request_serialization_statements.push(
+ quote_stmt!(cx, ::ipc::invoke($index_ident, &Some(serialized_payload), &mut *socket)));
+
+
+ request_serialization_statements
+ }
+ else {
+ let mut request_serialization_statements = Vec::new();
+ request_serialization_statements.push(
+ quote_stmt!(cx, let mut socket = self.socket.write().unwrap(); ));
+ request_serialization_statements.push(
+ quote_stmt!(cx, ::ipc::invoke($index_ident, &None, &mut *socket)));
+ request_serialization_statements
+ };
+
+ let trace = literal!(builder, "Invoking: {}", &dispatch.function_name);
+ if let Some(ref return_ty) = dispatch.return_type_ty {
+ let return_expr = quote_expr!(cx,
+ ::ipc::binary::deserialize_from::<$return_ty, _>(&mut *socket).unwrap()
+ );
+ quote_expr!(cx, {
+ trace!(target: "ipc", $trace);
+ $request;
+ $return_expr
+ })
+ }
+ else {
+ quote_expr!(cx, {
+ trace!(target: "ipc", $trace);
+ $request
+ })
+ }
+}
+
+/// Generates signature and body (see `implement_client_method_body`)
+/// for the client (signature is identical to the original method)
+fn implement_client_method(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ index: u16,
+ interface_map: &InterfaceMap,
+)
+ -> ast::ImplItem
+{
+ use ::syntax::tokenstream::TokenTree::Token;
+
+ let dispatch = &interface_map.dispatches[index as usize];
+ let method_name = builder.id(dispatch.function_name.as_str());
+ let body = implement_client_method_body(cx, builder, index, interface_map);
+
+ let ext_cx = &*cx;
+ // expanded version of this
+ // pub fn $method_name(&self, p1: p1_ty, p2: p2_ty ... pn: pn_ty, ) [-> return_ty] { $body }
+ // looks like it's tricky to build function declaration with aster if body already generated
+ let signature = ::syntax::parse::parser::Parser::parse_impl_item(
+ &mut ::syntax::parse::new_parser_from_tts(
+ ext_cx.parse_sess(),
+ {
+ let _sp = ext_cx.call_site();
+ let mut tt = ::std::vec::Vec::new();
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("fn"))));
+ tt.extend(::quasi::ToTokens::to_tokens(&method_name, ext_cx).into_iter());
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+ tt.push(Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"))));
+ tt.push(Token(_sp, ::syntax::parse::token::Comma));
+
+ for arg_idx in 0..dispatch.input_arg_names.len() {
+ let arg_name = dispatch.input_arg_names[arg_idx].as_str();
+ let arg_ty = dispatch.input_arg_tys[arg_idx].clone();
+
+ tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg_name))));
+ tt.push(Token(_sp, ::syntax::parse::token::Colon));
+ tt.extend(::quasi::ToTokens::to_tokens(&arg_ty, ext_cx).into_iter());
+ tt.push(Token(_sp, ::syntax::parse::token::Comma));
+ }
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+
+ if let Some(ref return_ty) = dispatch.return_type_ty {
+ tt.push(Token(_sp, ::syntax::parse::token::RArrow));
+ tt.extend(::quasi::ToTokens::to_tokens(return_ty, ext_cx).into_iter());
+ }
+
+ tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+ tt.extend(::quasi::ToTokens::to_tokens(&body, ext_cx).into_iter());
+ tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+
+ tt
+ }));
+
+ signature.unwrap()
+}
+
+fn client_generics(builder: &aster::AstBuilder, interface_map: &InterfaceMap) -> Generics {
+ let ty_param = aster::ty_param::TyParamBuilder::new(
+ builder.id("S")).trait_bound(
+ builder.path().global().ids(&["ipc", "IpcSocket"]).build()
+ ).build().build();
+
+ builder.from_generics(interface_map.generics.clone())
+ .with_ty_param(ty_param)
+ .build()
+}
+
+fn client_qualified_ident(cx: &ExtCtxt, builder: &aster::AstBuilder, interface_map: &InterfaceMap) -> P {
+ let generics = client_generics(builder, interface_map);
+ aster::ty::TyBuilder::new().path().segment(interface_map.ident_map.client_ident(cx, builder))
+ .with_generics(generics).build()
+ .build()
+}
+
+fn client_phantom_ident(builder: &aster::AstBuilder, interface_map: &InterfaceMap) -> P {
+ let generics = client_generics(builder, interface_map);
+ aster::ty::TyBuilder::new().phantom_data()
+ .tuple().with_tys(generics.ty_params.iter().map(|x| aster::ty::TyBuilder::new().id(x.ident)))
+ .build()
+}
+
+/// generates client type for specified server type
+/// for say `Service` it generates `ServiceClient`
+fn push_client_struct(cx: &ExtCtxt, builder: &aster::AstBuilder, interface_map: &InterfaceMap, push: &mut FnMut(Annotatable)) {
+ let generics = client_generics(builder, interface_map);
+ let client_short_ident = interface_map.ident_map.client_ident(cx, builder);
+ let phantom = client_phantom_ident(builder, interface_map);
+
+ let client_struct_item = quote_item!(cx,
+ pub struct $client_short_ident $generics {
+ socket: ::std::sync::RwLock,
+ phantom: $phantom,
+ });
+
+ push(Annotatable::Item(client_struct_item.expect(&format!("could not generate client struct for {:?}", client_short_ident.name))));
+}
+
+/// pushes generated code for the client class (type declaration and method invocation implementations)
+fn push_client(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ interface_map: &InterfaceMap,
+ push: &mut FnMut(Annotatable),
+) {
+ push_client_struct(cx, builder, interface_map, push);
+ push_client_implementation(cx, builder, interface_map, push);
+ push_with_socket_client_implementation(cx, builder, interface_map, push);
+}
+
+fn push_with_socket_client_implementation(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ interface_map: &InterfaceMap,
+ push: &mut FnMut(Annotatable))
+{
+ let generics = client_generics(builder, interface_map);
+ let client_ident = client_qualified_ident(cx, builder, interface_map);
+ let where_clause = &generics.where_clause;
+ let client_short_ident = interface_map.ident_map.client_ident(cx, builder);
+
+ let implement = quote_item!(cx,
+ impl $generics ::ipc::WithSocket for $client_ident $where_clause {
+ fn init(socket: S) -> $client_ident {
+ $client_short_ident {
+ socket: ::std::sync::RwLock::new(socket),
+ phantom: ::std::marker::PhantomData,
+ }
+ }
+ }).unwrap();
+ push(Annotatable::Item(implement));
+}
+
+/// pushes full client side code for the original class exposed via ipc
+fn push_client_implementation(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ interface_map: &InterfaceMap,
+ push: &mut FnMut(Annotatable),
+) {
+ let mut index = -1i32;
+ let items = interface_map.dispatches.iter()
+ .map(|_| { index = index + 1; P(implement_client_method(cx, builder, index as u16, interface_map)) })
+ .collect::>>();
+
+ let generics = client_generics(builder, interface_map);
+ let client_ident = client_qualified_ident(cx, builder, interface_map);
+ let where_clause = &generics.where_clause;
+ let endpoint = interface_map.endpoint;
+
+ let handshake_item = quote_impl_item!(cx,
+ pub fn handshake(&self) -> Result<(), ::ipc::Error> {
+ let payload = ::ipc::Handshake {
+ protocol_version: $endpoint::protocol_version(),
+ api_version: $endpoint::api_version(),
+ };
+
+ ::ipc::invoke(
+ 0,
+ &Some(::ipc::binary::serialize(&::ipc::BinHandshake::from(payload)).unwrap()),
+ &mut *self.socket.write().unwrap());
+
+ let mut result = vec![0u8; 1];
+ if try!(self.socket.write().unwrap().read(&mut result).map_err(|_| ::ipc::Error::HandshakeFailed)) == 1 {
+ match result[0] {
+ 1 => Ok(()),
+ _ => Err(::ipc::Error::RemoteServiceUnsupported),
+ }
+ }
+ else { Err(::ipc::Error::HandshakeFailed) }
+ }).unwrap();
+
+ let socket_item = quote_impl_item!(cx,
+ #[cfg(test)]
+ pub fn socket(&self) -> &::std::sync::RwLock {
+ &self.socket
+ }).unwrap();
+
+ let generic_items = vec![P(handshake_item), P(socket_item)];
+
+ if interface_map.impl_trait.is_some() {
+ let trait_ty = builder.id(
+ ::syntax::print::pprust::path_to_string(
+ &interface_map.impl_trait.as_ref().unwrap().path));
+
+ let implement_trait =
+ quote_item!(cx,
+ impl $generics $trait_ty for $client_ident $where_clause {
+ $items
+ }
+ ).unwrap();
+ push(Annotatable::Item(implement_trait));
+
+ let implement =
+ quote_item!(cx,
+ impl $generics $client_ident $where_clause {
+ $generic_items
+ }
+ ).unwrap();
+ push(Annotatable::Item(implement));
+ }
+ else {
+ let pub_items = items.iter().map(|item| {
+ let pub_item = item.clone();
+ pub_item.map(|mut val| { val.vis = ast::Visibility::Public; val })
+ }).collect::>>();
+
+ let implement = quote_item!(cx,
+ impl $generics $client_ident $where_clause {
+ $pub_items
+ $generic_items
+ }).unwrap();
+ push(Annotatable::Item(implement));
+ }
+
+}
+
+/// implements dispatching of system handshake invocation (method_num 0)
+fn implement_handshake_arm(
+ cx: &ExtCtxt,
+) -> (ast::Arm, ast::Arm)
+{
+ let handshake_deserialize = quote_stmt!(&cx,
+ let handshake_payload = ::ipc::binary::deserialize_from::<::ipc::BinHandshake, _>(r).unwrap();
+ );
+
+ let handshake_deserialize_buf = quote_stmt!(&cx,
+ let handshake_payload = ::ipc::binary::deserialize::<::ipc::BinHandshake>(buf).unwrap();
+ );
+
+ let handshake_serialize = quote_expr!(&cx,
+ ::ipc::binary::serialize::(&Self::handshake(&handshake_payload.to_semver())).unwrap()
+ );
+
+ (
+ quote_arm!(&cx, 0 => {
+ $handshake_deserialize
+ $handshake_serialize
+ }),
+ quote_arm!(&cx, 0 => {
+ $handshake_deserialize_buf
+ $handshake_serialize
+ }),
+ )
+}
+
+fn get_str_from_lit(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result {
+ match lit.node {
+ ast::LitKind::Str(ref s, _) => Ok(format!("{}", s)),
+ _ => {
+ cx.span_err(
+ lit.span,
+ &format!("ipc client_ident annotation `{}` must be a string, not `{}`",
+ name,
+ ::syntax::print::pprust::lit_to_string(lit)));
+
+ return Err(());
+ }
+ }
+}
+
+fn client_ident_renamed(cx: &ExtCtxt, meta_item: &MetaItem) -> Option {
+ if let ast::MetaItemKind::List(ref list) = meta_item.node {
+ for nested in list {
+ match nested.node {
+ ast::NestedMetaItemKind::MetaItem(ref meta_item) => {
+ let is_client_ident = &*meta_item.name.as_str() == "client_ident";
+ match meta_item.node {
+ ast::MetaItemKind::NameValue(ref lit) if is_client_ident => {
+ if let Ok(s) = get_str_from_lit(cx, "client_ident", lit) {
+ return Some(s);
+ }
+ }
+ _ => {
+ cx.span_err(
+ meta_item.span,
+ &format!("unknown client_ident container attribute `{}`",
+ ::syntax::print::pprust::meta_item_to_string(&meta_item)));
+ }
+ }
+ },
+ _ => {},
+ }
+ }
+ }
+
+ None
+}
+
+struct InterfaceMap {
+ pub original_item: Item,
+ pub item: P,
+ pub dispatches: Vec,
+ pub generics: Generics,
+ pub impl_trait: Option,
+ pub ident_map: IdentMap,
+ pub endpoint: Ident,
+}
+
+struct IdentMap {
+ original_path: ast::Path,
+ meta_item: MetaItem,
+}
+
+impl IdentMap {
+ fn ident(&self, builder: &aster::AstBuilder) -> Ident {
+ builder.id(format!("{}", ::syntax::print::pprust::path_to_string(&self.original_path)))
+ }
+
+ fn client_ident(&self, cx: &ExtCtxt, builder: &aster::AstBuilder) -> Ident {
+ if let Some(new_name) = client_ident_renamed(cx, &self.meta_item) {
+ builder.id(new_name)
+ }
+ else {
+ builder.id(format!("{}Client", self.original_path.segments[0].identifier))
+ }
+ }
+}
+
+fn ty_ident_map(original_ty: &P, meta_item: &MetaItem) -> IdentMap {
+ let original_path = match original_ty.node {
+ ::syntax::ast::TyKind::Path(_, ref path) => path.clone(),
+ _ => { panic!("incompatible implementation"); }
+ };
+ let ident_map = IdentMap { original_path: original_path, meta_item: meta_item.clone() };
+ ident_map
+}
+
+/// implements `IpcInterface` for the given class `C`
+fn implement_interface(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ item: &Item,
+ push: &mut FnMut(Annotatable),
+ meta_item: &MetaItem,
+) -> Result {
+ let (generics, impl_trait, original_ty, dispatch_table) = match item.node {
+ ast::ItemKind::Impl(_, _, ref generics, ref impl_trait, ref ty, ref impl_items) => {
+ let mut method_signatures = Vec::new();
+ for impl_item in impl_items {
+ if let ImplItemKind::Method(ref signature, _) = impl_item.node {
+ method_signatures.push(NamedSignature { ident: &impl_item.ident, sig: signature });
+ }
+ }
+
+ let dispatch_table = method_signatures.iter().map(|named_signature|
+ push_invoke_signature_aster(builder, named_signature, push))
+ .collect::>();
+
+ (generics, impl_trait.clone(), ty.clone(), dispatch_table)
+ },
+ ast::ItemKind::Trait(_, ref generics, _, ref trait_items) => {
+ let mut method_signatures = Vec::new();
+ for trait_item in trait_items {
+ if let TraitItemKind::Method(ref signature, _) = trait_item.node {
+ method_signatures.push(NamedSignature { ident: &trait_item.ident, sig: signature });
+ }
+ }
+
+ let dispatch_table = method_signatures.iter().map(|named_signature|
+ push_invoke_signature_aster(builder, named_signature, push))
+ .collect::>();
+
+ (
+ generics,
+ Some(ast::TraitRef {
+ path: builder.path().ids(&[item.ident.name]).build(),
+ ref_id: item.id,
+ }),
+ builder.ty().id(item.ident),
+ dispatch_table
+ )
+ },
+ _ => {
+ cx.span_err(
+ item.span,
+ "`#[ipc]` may only be applied to implementations and traits");
+ return Err(Error);
+ },
+ };
+ let impl_generics = builder.from_generics(generics.clone()).build();
+ let where_clause = &impl_generics.where_clause;
+
+ let dispatch_arms = implement_dispatch_arms(cx, builder, &dispatch_table, false);
+ let dispatch_arms_buffered = implement_dispatch_arms(cx, builder, &dispatch_table, true);
+
+ let (handshake_arm, handshake_arm_buf) = implement_handshake_arm(cx);
+
+ let ty = ty_ident_map(&original_ty, meta_item).ident(builder);
+ let (interface_endpoint, host_generics) = match impl_trait {
+ Some(ref trait_) => (builder.id(::syntax::print::pprust::path_to_string(&trait_.path)), None),
+ None => (ty, Some(&impl_generics)),
+ };
+
+ let ipc_item = quote_item!(cx,
+ impl $host_generics ::ipc::IpcInterface for $interface_endpoint $where_clause {
+ fn dispatch(&self, r: &mut R) -> Vec
+ where R: ::std::io::Read
+ {
+ let mut method_num = vec![0u8;2];
+ match r.read(&mut method_num) {
+ Ok(size) if size == 0 => { panic!("method id not supplied" ); }
+ Err(e) => { panic!("ipc read error: {:?}, aborting", e); }
+ _ => { }
+ }
+
+ // method_num is a 16-bit little-endian unsigned number
+ match method_num[1] as u16 + (method_num[0] as u16)*256 {
+ // handshake
+ $handshake_arm
+ // user methods
+ $dispatch_arms
+ _ => vec![]
+ }
+ }
+
+ fn dispatch_buf(&self, method_num: u16, buf: &[u8]) -> Vec
+ {
+ match method_num {
+ $handshake_arm_buf
+ $dispatch_arms_buffered
+ _ => vec![]
+ }
+ }
+ }
+ ).unwrap();
+
+ Ok(InterfaceMap {
+ ident_map: ty_ident_map(&original_ty, meta_item),
+ original_item: item.clone(),
+ item: ipc_item,
+ dispatches: dispatch_table,
+ generics: generics.clone(),
+ impl_trait: impl_trait.clone(),
+ endpoint: interface_endpoint,
+ })
+}
diff --git a/ipc/codegen/src/lib.rs b/ipc/codegen/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6e7fc441b324f217ce883b4d184e463f25061c74
--- /dev/null
+++ b/ipc/codegen/src/lib.rs
@@ -0,0 +1,237 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Codegen for IPC RPC
+
+#![cfg_attr(feature = "nightly-testing", plugin(clippy))]
+#![cfg_attr(feature = "nightly-testing", feature(plugin))]
+#![cfg_attr(feature = "nightly-testing", allow(used_underscore_binding))]
+#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
+#![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]
+
+extern crate aster;
+extern crate quasi;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex_syntax as syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+#[macro_use]
+extern crate syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+extern crate rustc_plugin;
+
+#[cfg(not(feature = "with-syntex"))]
+use syntax::feature_gate::AttributeType;
+
+#[cfg(feature = "with-syntex")]
+use syntax::{ast, fold};
+
+
+#[cfg(feature = "with-syntex")]
+include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+
+#[cfg(not(feature = "with-syntex"))]
+include!("lib.rs.in");
+
+#[cfg(feature = "with-syntex")]
+pub fn expand(src: &std::path::Path, dst: &std::path::Path) {
+ let mut registry = syntex::Registry::new();
+ register(&mut registry);
+ registry.expand("", src, dst).unwrap();
+}
+
+#[cfg(feature = "with-syntex")]
+struct StripAttributeFolder<'a> {
+ attr_title: &'a str,
+}
+
+#[cfg(feature = "with-syntex")]
+impl<'a> fold::Folder for StripAttributeFolder<'a> {
+ fn fold_attribute(&mut self, attr: ast::Attribute) -> Option {
+ let is_self = &*attr.value.name.as_str() == self.attr_title;
+
+ match attr.value.node {
+ ast::MetaItemKind::List(_) if is_self => { return None; }
+ ast::MetaItemKind::Word if is_self => { return None; }
+ _ => {}
+ }
+
+ Some(attr)
+ }
+
+ fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
+ fold::noop_fold_mac(mac, self)
+ }
+}
+
+#[cfg(feature = "with-syntex")]
+pub fn register_cleaner_ipc(reg: &mut syntex::Registry) {
+ #[cfg(feature = "with-syntex")]
+ fn strip_attributes(krate: ast::Crate) -> ast::Crate {
+ let mut folder = StripAttributeFolder { attr_title: "ipc" };
+ fold::Folder::fold_crate(&mut folder, krate)
+ }
+
+ reg.add_post_expansion_pass(strip_attributes);
+}
+
+#[cfg(feature = "with-syntex")]
+pub fn register_cleaner_binary(reg: &mut syntex::Registry) {
+ #[cfg(feature = "with-syntex")]
+ fn strip_attributes(krate: ast::Crate) -> ast::Crate {
+ let mut folder = StripAttributeFolder { attr_title: "binary" };
+ fold::Folder::fold_crate(&mut folder, krate)
+ }
+
+ reg.add_post_expansion_pass(strip_attributes);
+}
+
+#[cfg(feature = "with-syntex")]
+pub fn register(reg: &mut syntex::Registry) {
+ reg.add_attr("feature(custom_derive)");
+ reg.add_attr("feature(custom_attribute)");
+
+ reg.add_decorator("ipc", codegen::expand_ipc_implementation);
+ reg.add_decorator("binary", serialization::expand_serialization_implementation);
+
+ register_cleaner_ipc(reg);
+ register_cleaner_binary(reg);
+}
+
+#[cfg(not(feature = "with-syntex"))]
+pub fn register(reg: &mut rustc_plugin::Registry) {
+ reg.register_syntax_extension(
+ syntax::parse::token::intern("ipc"),
+ syntax::ext::base::MultiDecorator(
+ Box::new(codegen::expand_ipc_implementation)));
+ reg.register_syntax_extension(
+ syntax::parse::token::intern("binary"),
+ syntax::ext::base::MultiDecorator(
+ Box::new(serialization::expand_serialization_implementation)));
+
+ reg.register_attribute("ipc".to_owned(), AttributeType::Normal);
+ reg.register_attribute("binary".to_owned(), AttributeType::Normal);
+}
+
+#[derive(Debug)]
+pub enum Error { InvalidFileName, ExpandFailure, Io(std::io::Error) }
+
+impl std::convert::From for Error {
+ fn from(err: std::io::Error) -> Self {
+ Error::Io(err)
+ }
+}
+
+pub fn derive_ipc_cond(src_path: &str, has_feature: bool) -> Result<(), Error> {
+ if has_feature { derive_ipc(src_path) }
+ else { cleanup_ipc(src_path) }
+}
+
+pub fn cleanup_ipc(src_path: &str) -> Result<(), Error> {
+ cleanup(src_path, AttributeKind::Ipc)
+}
+
+pub fn cleanup_binary(src_path: &str) -> Result<(), Error> {
+ cleanup(src_path, AttributeKind::Binary)
+}
+
+enum AttributeKind {
+ Ipc,
+ Binary,
+}
+
+fn cleanup(src_path: &str, attr: AttributeKind) -> Result<(), Error> {
+ use std::env;
+ use std::path::{Path, PathBuf};
+
+ let out_dir = env::var_os("OUT_DIR").unwrap();
+ let file_name = PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())?;
+ let mut registry = syntex::Registry::new();
+
+ match attr {
+ AttributeKind::Ipc => { register_cleaner_ipc(&mut registry); }
+ AttributeKind::Binary => { register_cleaner_binary(&mut registry); }
+ }
+
+ if let Err(_) = registry.expand("", &Path::new(src_path), &Path::new(&out_dir).join(&file_name))
+ {
+ // will be reported by compiler
+ return Err(Error::ExpandFailure)
+ }
+ Ok(())
+}
+
+pub fn derive_ipc(src_path: &str) -> Result<(), Error> {
+ use std::env;
+ use std::path::{Path, PathBuf};
+
+ let out_dir = env::var_os("OUT_DIR").unwrap();
+ let file_name = PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())?;
+
+ let final_path = Path::new(&out_dir).join(&file_name);
+
+ let mut intermediate_file_name = file_name.clone();
+ intermediate_file_name.push_str(".rpc.in");
+ let intermediate_path = Path::new(&out_dir).join(&intermediate_file_name);
+
+ {
+ let mut registry = syntex::Registry::new();
+ register(&mut registry);
+ if let Err(_) = registry.expand("", &Path::new(src_path), &intermediate_path) {
+ // will be reported by compiler
+ return Err(Error::ExpandFailure)
+ }
+ }
+
+ {
+ let mut registry = syntex::Registry::new();
+ register(&mut registry);
+ if let Err(_) = registry.expand("", &intermediate_path, &final_path) {
+ // will be reported by compiler
+ return Err(Error::ExpandFailure)
+ }
+ }
+
+ Ok(())
+}
+
+pub fn derive_binary(src_path: &str) -> Result<(), Error> {
+ use std::env;
+ use std::path::{Path, PathBuf};
+
+ let out_dir = env::var_os("OUT_DIR").unwrap();
+ let file_name = PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())?;
+ let final_path = Path::new(&out_dir).join(&file_name);
+
+ let mut registry = syntex::Registry::new();
+ register(&mut registry);
+ if let Err(_) = registry.expand("", &Path::new(src_path), &final_path) {
+ // will be reported by compiler
+ return Err(Error::ExpandFailure)
+ }
+
+ Ok(())
+}
+
+pub fn derive_binary_cond(src_path: &str, has_feature: bool) -> Result<(), Error> {
+ if has_feature { derive_binary(src_path) }
+ else { cleanup_binary(src_path) }
+}
diff --git a/ipc/codegen/src/lib.rs.in b/ipc/codegen/src/lib.rs.in
new file mode 100644
index 0000000000000000000000000000000000000000..c8aa8ebf27416c489965c6490cc98a7081ab5070
--- /dev/null
+++ b/ipc/codegen/src/lib.rs.in
@@ -0,0 +1,18 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+mod codegen;
+mod serialization;
diff --git a/ipc/codegen/src/serialization.rs b/ipc/codegen/src/serialization.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fd908725c9b54e98b46d94d81ff5616f55a19df2
--- /dev/null
+++ b/ipc/codegen/src/serialization.rs
@@ -0,0 +1,810 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+use aster;
+
+use syntax::ast::{
+ MetaItem,
+ Item,
+ Ident,
+};
+
+use syntax::ast;
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::ptr::P;
+
+pub struct Error;
+
+use super::codegen;
+
+pub fn expand_serialization_implementation(
+ cx: &mut ExtCtxt,
+ span: Span,
+ meta_item: &MetaItem,
+ annotatable: &Annotatable,
+ push: &mut FnMut(Annotatable)
+) {
+ let item = match *annotatable {
+ Annotatable::Item(ref item) => item,
+ _ => {
+ cx.span_err(meta_item.span, "`#[derive(Binary)]` may only be applied to structs and enums");
+ return;
+ },
+ };
+
+ let builder = aster::AstBuilder::new().span(span);
+
+ let impl_item = match serialize_item(cx, &builder, &item) {
+ Ok(item) => item,
+ Err(Error) => {
+ // An error occurred, but it should have been reported already.
+ return;
+ },
+ };
+
+ push(Annotatable::Item(impl_item))
+}
+
+fn serialize_item(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ item: &Item,
+) -> Result, Error> {
+ let generics = match item.node {
+ ast::ItemKind::Struct(_, ref generics) => generics,
+ ast::ItemKind::Enum(_, ref generics) => generics,
+ _ => {
+ cx.span_err(
+ item.span,
+ "`#[derive(Binary)]` may only be applied to structs and enums");
+ return Err(Error);
+ },
+ };
+
+ let ty = builder.ty().path()
+ .segment(item.ident).with_generics(generics.clone()).build()
+ .build();
+
+ let where_clause = &generics.where_clause;
+
+ let binary_expressions = try!(binary_expr(cx,
+ &builder,
+ &item,
+ &generics,
+ ty.clone()));
+
+ let (size_expr, read_expr, write_expr) =
+ (binary_expressions.size, binary_expressions.read, binary_expressions.write);
+
+ match quote_item!(cx,
+ impl $generics ::ipc::BinaryConvertable for $ty $where_clause {
+ fn size(&self) -> usize {
+ $size_expr
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut ::std::collections::VecDeque) -> Result<(), ::ipc::BinaryConvertError> {
+ $write_expr
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut ::std::collections::VecDeque) -> Result {
+ $read_expr
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+ })
+ {
+ Some(item) => Ok(item),
+ None => {
+ cx.span_err(
+ item.span,
+ "syntax error expanding serialization implementation");
+ Err(Error)
+ }
+ }
+}
+
+#[allow(unreachable_code)]
+fn binary_expr(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ item: &Item,
+ impl_generics: &ast::Generics,
+ ty: P,
+) -> Result {
+ match item.node {
+ ast::ItemKind::Struct(ref variant_data, _) => {
+ binary_expr_item_struct(
+ cx,
+ builder,
+ impl_generics,
+ ty,
+ item.span,
+ variant_data,
+ )
+ },
+ ast::ItemKind::Enum(ref enum_def, _) => {
+ binary_expr_enum(
+ cx,
+ builder,
+ item.ident,
+ impl_generics,
+ ty,
+ item.span,
+ enum_def,
+ )
+ },
+ _ => {
+ cx.span_bug(item.span,
+ "expected ItemStruct or ItemEnum in #[derive(Binary)]");
+ Err(Error) as Result
+ },
+ }
+}
+
+struct BinaryExpressions {
+ pub size: P,
+ pub write: P,
+ pub read: P,
+}
+
+fn replace_qualified(s: &str) -> String {
+ if let Some(pos) = s.find("<") {
+ let mut source = s.to_owned();
+ source.insert(pos, ':');
+ source.insert(pos, ':');
+ source
+ }
+ else { s.to_owned() }
+}
+
+fn binary_expr_struct(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ ty: P,
+ fields: &[ast::StructField],
+ value_ident: Option,
+ instance_ident: Option,
+) -> Result {
+
+ let size_exprs: Vec> = fields.iter().enumerate().map(|(index, field)| {
+ let raw_ident = ::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty));
+ let index_ident = builder.id(format!("__field{}", index));
+ let field_id = match field.ident {
+ Some(ident) => builder.id(ident),
+ None => builder.id(format!("{}", index)),
+ };
+
+ match raw_ident.as_ref() {
+ "u8" => {
+ quote_expr!(cx, 1)
+ },
+ "[u8]" => {
+ value_ident.and_then(|x| {
+ Some(quote_expr!(cx, $x. $field_id .len()))
+ })
+ .unwrap_or_else(|| {
+ quote_expr!(cx, $index_ident .len())
+ }
+ )
+ }
+ _ => {
+ let field_type_ident = builder.id(
+ &::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty)));
+
+ let field_type_ident_qualified = builder.id(
+ replace_qualified(&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty))));
+
+ value_ident.and_then(|x|
+ {
+ Some(quote_expr!(cx,
+ match $field_type_ident_qualified::len_params() {
+ 0 => ::std::mem::size_of::<$field_type_ident>(),
+ _ => $x. $field_id .size(),
+ }))
+ })
+ .unwrap_or_else(|| {
+ quote_expr!(cx, match $field_type_ident_qualified::len_params() {
+ 0 => ::std::mem::size_of::<$field_type_ident>(),
+ _ => $index_ident .size(),
+ })
+ })
+ }
+ }
+ }).collect();
+
+ let first_size_expr = size_exprs[0].clone();
+ let mut total_size_expr = quote_expr!(cx, 0usize + $first_size_expr);
+ for index in 1..size_exprs.len() {
+ let next_expr = size_exprs[index].clone();
+ total_size_expr = quote_expr!(cx, $total_size_expr + $next_expr);
+ }
+
+ let mut write_stmts = Vec::::new();
+ write_stmts.push(quote_stmt!(cx, let mut offset = 0usize;).expect("stmt1"));
+
+ let mut map_stmts = Vec::::new();
+ let field_amount = builder.id(&format!("{}",fields.len()));
+ map_stmts.push(quote_stmt!(cx, let mut map = vec![0usize; $field_amount];).expect("stmt2"));
+ map_stmts.push(quote_stmt!(cx, let mut total = 0usize;).expect("stmt3"));
+
+ let mut post_write_stmts = Vec::::new();
+
+ for (index, field) in fields.iter().enumerate() {
+ let field_type_ident = builder.id(
+ &::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty)));
+
+ let field_type_ident_qualified = builder.id(
+ replace_qualified(&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty))));
+
+ let field_id = match field.ident {
+ Some(ident) => builder.id(ident),
+ None => builder.id(format!("{}", index)),
+ };
+ let member_expr = match value_ident {
+ Some(x) => {
+ quote_expr!(cx, $x . $field_id)
+ },
+ None => {
+ let index_ident = builder.id(format!("__field{}", index));
+ quote_expr!(cx, $index_ident)
+ },
+ };
+
+ let raw_ident = ::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty));
+ let range_ident = builder.id(format!("r{}", index));
+
+ let error_message = "Error serializing member: ".to_owned() + &::syntax::print::pprust::expr_to_string(&member_expr);
+ let _error_message_literal = builder.expr().lit().str::<&str>(&error_message);
+
+ match raw_ident.as_ref() {
+ "u8" => {
+ write_stmts.push(quote_stmt!(cx, let next_line = offset + 1;).expect("stmt4"));
+ write_stmts.push(quote_stmt!(cx, buffer[offset] = $member_expr; ).expect("stm5"));
+ },
+ "[u8]" => {
+ write_stmts.push(quote_stmt!(cx, let size = $member_expr .len();).unwrap());
+ write_stmts.push(quote_stmt!(cx, let next_line = offset + size;).unwrap());
+ write_stmts.push(quote_stmt!(cx, length_stack.push_back(size);).unwrap());
+ write_stmts.push(quote_stmt!(cx, let $range_ident = offset..next_line; ).unwrap());
+ post_write_stmts.push(quote_stmt!(cx, buffer[$range_ident].clone_from_slice($member_expr); ).unwrap());
+ }
+ _ => {
+ write_stmts.push(quote_stmt!(cx, let next_line = offset + match $field_type_ident_qualified::len_params() {
+ 0 => ::std::mem::size_of::<$field_type_ident>(),
+ _ => { let size = $member_expr .size(); length_stack.push_back(size); size },
+ }).unwrap());
+ write_stmts.push(quote_stmt!(cx, let $range_ident = offset..next_line; ).unwrap());
+ post_write_stmts.push(quote_stmt!(cx,
+ if $range_ident.end - $range_ident.start > 0 {
+ if let Err(e) = $member_expr .to_bytes(&mut buffer[$range_ident], length_stack) {
+ return Err(e)
+ };
+ }
+ ).unwrap());
+ }
+ }
+
+ write_stmts.push(quote_stmt!(cx, offset = next_line; ).unwrap());
+
+ let field_index = builder.id(&format!("{}", index));
+ map_stmts.push(quote_stmt!(cx, map[$field_index] = total;).unwrap());
+
+ match raw_ident.as_ref() {
+ "u8" => {
+ map_stmts.push(quote_stmt!(cx, total += 1;).unwrap());
+ },
+ "[u8]" => {
+ map_stmts.push(quote_stmt!(cx, let size = length_stack.pop_front().unwrap();).unwrap());
+ map_stmts.push(quote_stmt!(cx, total += size;).unwrap());
+ },
+ _ => {
+ map_stmts.push(quote_stmt!(cx, let size = match $field_type_ident_qualified::len_params() {
+ 0 => ::std::mem::size_of::<$field_type_ident>(),
+ _ => length_stack.pop_front().unwrap(),
+ }).unwrap());
+ map_stmts.push(quote_stmt!(cx, total += size;).unwrap());
+ }
+ }
+ };
+
+ let read_expr = match fields.iter().any(|f| codegen::has_ptr(&f.ty)) {
+ true => {
+ // cannot create structs with pointers
+ quote_expr!(cx, Err(::ipc::binary::BinaryConvertError::not_supported()))
+ },
+ false => {
+ if value_ident.is_some() {
+ let instance_create = named_fields_sequence(cx, &ty, fields);
+ quote_expr!(cx, { $map_stmts; $instance_create; Ok(result) })
+ }
+ else {
+ let map_variant = P(fields_sequence(cx, &ty, fields, &instance_ident.unwrap_or(builder.id("Self"))));
+ quote_expr!(cx, { $map_stmts; Ok($map_variant) })
+ }
+ },
+ };
+
+ Ok(BinaryExpressions {
+ size: total_size_expr,
+ write: quote_expr!(cx, { $write_stmts; $post_write_stmts; Ok(()) } ),
+ read: read_expr,
+ })
+}
+
+#[allow(unreachable_code)]
+fn binary_expr_item_struct(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ _impl_generics: &ast::Generics,
+ ty: P,
+ span: Span,
+ variant_data: &ast::VariantData,
+) -> Result {
+ match *variant_data {
+ ast::VariantData::Tuple(ref fields, _) => {
+ binary_expr_struct(
+ cx,
+ &builder,
+ ty,
+ fields,
+ Some(builder.id("self")),
+ None,
+ )
+ },
+ ast::VariantData::Struct(ref fields, _) => {
+ binary_expr_struct(
+ cx,
+ &builder,
+ ty,
+ fields,
+ Some(builder.id("self")),
+ None,
+ )
+ },
+ _ => {
+ cx.span_bug(span,
+ &format!("#[derive(Binary)] Unsupported struct content, expected tuple/struct, found: {:?}",
+ variant_data));
+ Err(Error) as Result
+ },
+ }
+}
+
+fn binary_expr_enum(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ type_ident: Ident,
+ impl_generics: &ast::Generics,
+ ty: P,
+ span: Span,
+ enum_def: &ast::EnumDef,
+) -> Result {
+ let arms: Vec<_> = try!(enum_def.variants.iter()
+ .enumerate()
+ .map(|(variant_index, variant)| {
+ binary_expr_variant(
+ cx,
+ builder,
+ type_ident,
+ impl_generics,
+ ty.clone(),
+ span,
+ variant,
+ variant_index,
+ )
+ })
+ .collect());
+
+ let (size_arms, write_arms, mut read_arms) = (
+ arms.iter().map(|x| x.size.clone()).collect::>(),
+ arms.iter().map(|x| x.write.clone()).collect::>(),
+ arms.iter().map(|x| x.read.clone()).collect::>());
+
+ read_arms.push(quote_arm!(cx, _ => { Err(::ipc::BinaryConvertError::variant(buffer[0])) } ));
+
+ Ok(BinaryExpressions {
+ size: quote_expr!(cx, 1usize + match *self { $size_arms }),
+ write: quote_expr!(cx, match *self { $write_arms }; ),
+ read: quote_expr!(cx, match buffer[0] { $read_arms }),
+ })
+}
+
+struct BinaryArm {
+ size: ast::Arm,
+ write: ast::Arm,
+ read: ast::Arm,
+}
+
+fn fields_sequence(
+ ext_cx: &ExtCtxt,
+ _ty: &P,
+ fields: &[ast::StructField],
+ variant_ident: &ast::Ident,
+) -> ast::Expr {
+ use syntax::parse::token;
+ use syntax::tokenstream::TokenTree::Token;
+
+ let named_members = fields.iter().any(|f| f.ident.is_some());
+
+ ::quasi::parse_expr_panic(&mut ::syntax::parse::new_parser_from_tts(
+ ext_cx.parse_sess(),
+ {
+ let _sp = ext_cx.call_site();
+ let mut tt = ::std::vec::Vec::new();
+ tt.push(Token(_sp, token::Ident(variant_ident.clone())));
+ if named_members {
+ tt.push(Token(_sp, token::OpenDelim(token::Brace)));
+ }
+ else {
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+ }
+
+ for (idx, field) in fields.iter().enumerate() {
+ if field.ident.is_some() {
+ tt.push(Token(_sp, token::Ident(field.ident.clone().unwrap())));
+ tt.push(Token(_sp, token::Colon));
+ }
+
+ // special case for u8, it just takes byte form sequence
+ if ::syntax::print::pprust::ty_to_string(&field.ty) == "u8" {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"))));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+ tt.push(Token(_sp, token::Comma));
+ continue;
+ }
+
+ // special case for [u8], it just takes a byte sequence
+ if ::syntax::print::pprust::ty_to_string(&field.ty) == "[u8]" {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"))));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ tt.push(Token(_sp, token::DotDot));
+
+ if idx+1 != fields.len() {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx+1)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ }
+
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+ tt.push(Token(_sp, token::Comma));
+ continue;
+ }
+
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("try!"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+ tt.push(
+ Token(
+ _sp,
+ token::Ident(ext_cx.ident_of(&replace_qualified(&::syntax::print::pprust::ty_to_string(&field.ty))))
+ ));
+ tt.push(Token(_sp, token::ModSep));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("from_bytes"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+
+ tt.push(Token(_sp, token::BinOp(token::And)));
+
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"))));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ tt.push(Token(_sp, token::DotDot));
+
+ if idx+1 != fields.len() {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx+1)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ }
+
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+ tt.push(Token(_sp, token::Comma));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("length_stack"))));
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+
+ // name member if it has resulted in the error
+ tt.push(Token(_sp, token::Dot));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map_err"))));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+ tt.push(Token(_sp, token::BinOp(token::Or)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("e"))));
+ tt.push(Token(_sp, token::BinOp(token::Or)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("e"))));
+ tt.push(Token(_sp, token::Dot));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("named"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+ tt.push(Token(_sp, token::Literal(token::Lit::Str_(
+ field.ident.unwrap_or(ext_cx.ident_of(&format!("f{}", idx))).name),
+ None))
+ );
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+
+ tt.push(Token(_sp, token::Comma));
+ }
+ if named_members {
+ tt.push(Token(_sp, token::CloseDelim(token::Brace)));
+ }
+ else {
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+ }
+ tt
+ })
+ ).unwrap()
+}
+
+fn named_fields_sequence(
+ ext_cx: &ExtCtxt,
+ ty: &P,
+ fields: &[ast::StructField],
+) -> ast::Stmt {
+ use syntax::parse::token;
+ use syntax::tokenstream::TokenTree::Token;
+
+ ::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
+ ext_cx.parse_sess(),
+ {
+ let _sp = ext_cx.call_site();
+ let mut tt = ::std::vec::Vec::new();
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("let"))));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("result"))));
+ tt.push(Token(_sp, token::Eq));
+
+ tt.push(Token(
+ _sp,
+ token::Ident(
+ ext_cx.ident_of(&::syntax::print::pprust::ty_to_string(ty))
+ )));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Brace)));
+
+ for (idx, field) in fields.iter().enumerate() {
+ tt.push(Token(_sp, match field.ident {
+ Some(ident) => token::Ident(ident),
+ None => token::Ident(ext_cx.ident_of(&format!("{}", idx))),
+ }));
+ tt.push(Token(_sp, token::Colon));
+
+ // special case for u8, it just takes byte form sequence
+ if ::syntax::print::pprust::ty_to_string(&field.ty) == "u8" {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"))));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+ tt.push(Token(_sp, token::Comma));
+ continue;
+ }
+
+ // special case for [u8], it just takes a byte sequence
+ if ::syntax::print::pprust::ty_to_string(&field.ty) == "[u8]" {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"))));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ tt.push(Token(_sp, token::DotDot));
+
+ if idx+1 != fields.len() {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx+1)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ }
+
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+ tt.push(Token(_sp, token::Comma));
+ continue;
+ }
+
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("try!"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+ tt.push(Token(
+ _sp,
+ token::Ident(
+ ext_cx.ident_of(&replace_qualified(&::syntax::print::pprust::ty_to_string(&field.ty)))
+ )));
+ tt.push(Token(_sp, token::ModSep));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("from_bytes"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+
+ tt.push(Token(_sp, token::BinOp(token::And)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"))));
+
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ tt.push(Token(_sp, token::DotDot));
+ if idx + 1 != fields.len() {
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx+1)))));
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+ }
+
+ tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+ tt.push(Token(_sp, token::Comma));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("length_stack"))));
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+
+ // name member if it has resulted in the error
+ tt.push(Token(_sp, token::Dot));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map_err"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+ tt.push(Token(_sp, token::BinOp(token::Or)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("e"))));
+ tt.push(Token(_sp, token::BinOp(token::Or)));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("e"))));
+ tt.push(Token(_sp, token::Dot));
+ tt.push(Token(_sp, token::Ident(ext_cx.ident_of("named"))));
+ tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+ tt.push(Token(_sp, token::Literal(token::Lit::Str_(
+ field.ident.unwrap_or(ext_cx.ident_of(&format!("f{}", idx))).name),
+ None))
+ );
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+
+ tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+ tt.push(Token(_sp, token::Comma));
+ }
+
+ tt.push(Token(_sp, token::CloseDelim(token::Brace)));
+ tt
+ })
+ ).unwrap()
+}
+
+fn binary_expr_variant(
+ cx: &ExtCtxt,
+ builder: &aster::AstBuilder,
+ type_ident: Ident,
+ _generics: &ast::Generics,
+ ty: P,
+ _span: Span,
+ variant: &ast::Variant,
+ variant_index: usize,
+) -> Result {
+ let variant_ident = variant.node.name;
+ let variant_index_ident = builder.id(format!("{}", variant_index));
+
+ match variant.node.data {
+ ast::VariantData::Unit(_) => {
+ let pat = builder.pat().path()
+ .id(type_ident).id(variant_ident)
+ .build();
+
+ let variant_val = builder.id(format!("{}::{}", type_ident, variant_ident));
+
+ Ok(BinaryArm {
+ size: quote_arm!(cx, $pat => { 0usize } ),
+ write: quote_arm!(cx, $pat => { buffer[0] = $variant_index_ident; Ok(()) } ),
+ read: quote_arm!(cx, $variant_index_ident => { Ok($variant_val) } ),
+ })
+ },
+ ast::VariantData::Tuple(ref fields, _) => {
+ let field_names: Vec = (0 .. fields.len())
+ .map(|i| builder.id(format!("__field{}", i)))
+ .collect();
+
+ let pat = builder.pat().enum_()
+ .id(type_ident).id(variant_ident).build()
+ .with_pats(
+ field_names.iter()
+ .map(|field| builder.pat().ref_id(field))
+ )
+ .build();
+
+ let binary_expr = try!(binary_expr_struct(
+ cx,
+ &builder,
+ ty,
+ fields,
+ None,
+ Some(builder.id(format!("{}::{}", type_ident, variant_ident))),
+ ));
+
+ let (size_expr, write_expr, read_expr) = (binary_expr.size, vec![binary_expr.write], binary_expr.read);
+ Ok(BinaryArm {
+ size: quote_arm!(cx, $pat => { $size_expr } ),
+ write: quote_arm!(cx,
+ $pat => {
+ buffer[0] = $variant_index_ident;
+ let buffer = &mut buffer[1..];
+ $write_expr
+ }),
+ read: quote_arm!(cx,
+ $variant_index_ident => {
+ let buffer = &buffer[1..];
+ $read_expr
+ }
+ ),
+ })
+ },
+ ast::VariantData::Struct(ref fields, _) => {
+ let field_names: Vec<_> = (0 .. fields.len())
+ .map(|i| builder.id(format!("__field{}", i)))
+ .collect();
+
+ let pat = builder.pat().struct_()
+ .id(type_ident).id(variant_ident).build()
+ .with_pats(
+ field_names.iter()
+ .zip(fields.iter())
+ .map(|(id, field)|(field.ident.unwrap(), builder.pat().ref_id(id))))
+ .build();
+
+ let binary_expr = try!(binary_expr_struct(
+ cx,
+ &builder,
+ ty,
+ fields,
+ None,
+ Some(builder.id(format!("{}::{}", type_ident, variant_ident))),
+ ));
+
+ let (size_expr, write_expr, read_expr) = (binary_expr.size, vec![binary_expr.write], binary_expr.read);
+
+ Ok(BinaryArm {
+ size: quote_arm!(cx, $pat => { $size_expr } ),
+ write: quote_arm!(cx,
+ $pat => {
+ buffer[0] = $variant_index_ident;
+ let buffer = &mut buffer[1..];
+ $write_expr
+ }),
+ read: quote_arm!(cx,
+ $variant_index_ident => {
+ let buffer = &buffer[1..];
+ $read_expr
+ }
+ ),
+ })
+ },
+ }
+}
diff --git a/ipc/hypervisor/Cargo.toml b/ipc/hypervisor/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1db60c904e67a612ace957ec983eb36bfbfdcf4f
--- /dev/null
+++ b/ipc/hypervisor/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "ethcore-ipc-hypervisor"
+version = "1.2.0"
+authors = ["Parity Technologies "]
+license = "GPL-3.0"
+build = "build.rs"
+
+[features]
+
+[dependencies]
+ethcore-ipc = { path = "../rpc" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git", branch = "parity-1.7" }
+ethcore-ipc-nano = { path = "../nano" }
+semver = "0.6"
+log = "0.3"
+time = "0.1"
+
+[build-dependencies]
+ethcore-ipc-codegen = { path = "../codegen" }
diff --git a/ipc/hypervisor/build.rs b/ipc/hypervisor/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..097aba0464ba18220fb5d00c85682199f43c0c5a
--- /dev/null
+++ b/ipc/hypervisor/build.rs
@@ -0,0 +1,21 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+extern crate ethcore_ipc_codegen;
+
+fn main() {
+ ethcore_ipc_codegen::derive_ipc("src/service.rs.in").unwrap();
+}
diff --git a/ipc/hypervisor/src/lib.rs b/ipc/hypervisor/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b522122b5b87d1c379e9e8b57555564098569ac4
--- /dev/null
+++ b/ipc/hypervisor/src/lib.rs
@@ -0,0 +1,273 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Parity interprocess hypervisor module
+
+#![cfg_attr(feature="dev", allow(used_underscore_binding))]
+
+extern crate ethcore_ipc as ipc;
+extern crate ethcore_ipc_nano as nanoipc;
+extern crate semver;
+#[macro_use] extern crate log;
+extern crate time;
+
+pub mod service;
+
+/// Default value for hypervisor ipc listener
+pub const HYPERVISOR_IPC_URL: &'static str = "parity-internal-hyper-status.ipc";
+
+use std::sync::{Arc,RwLock};
+use service::{HypervisorService, IpcModuleId};
+use std::process::{Command,Child};
+use std::collections::HashMap;
+
+pub use service::{HypervisorServiceClient, ControlService, CLIENT_MODULE_ID, SYNC_MODULE_ID};
+
+pub type BinaryId = &'static str;
+
+pub struct Hypervisor {
+ ipc_addr: String,
+ service: Arc,
+ ipc_worker: RwLock>,
+ processes: RwLock>,
+ modules: HashMap,
+ pub io_path: String,
+}
+
+/// Boot arguments for binary
+pub struct BootArgs {
+ cli: Option>,
+ stdin: Option>,
+}
+
+impl BootArgs {
+ /// New empty boot arguments
+ pub fn new() -> BootArgs {
+ BootArgs {
+ cli: None,
+ stdin: None,
+ }
+ }
+
+ /// Set command-line arguments for boot
+ pub fn cli(mut self, cli: Vec) -> BootArgs {
+ self.cli = Some(cli);
+ self
+ }
+
+ /// Set std-in stream for boot
+ pub fn stdin(mut self, stdin: Vec) -> BootArgs {
+ self.stdin = Some(stdin);
+ self
+ }
+}
+
+impl Hypervisor {
+ /// initializes the Hypervisor service with the open ipc socket for incoming clients
+ pub fn new() -> Hypervisor {
+ Hypervisor::with_url(HYPERVISOR_IPC_URL)
+ }
+
+ pub fn module(mut self, module_id: IpcModuleId, args: BootArgs) -> Hypervisor {
+ self.modules.insert(module_id, args);
+ self.service.add_module(module_id);
+ self
+ }
+
+ pub fn local_module(self, module_id: IpcModuleId) -> Hypervisor {
+ self.service.add_module(module_id);
+ self
+ }
+
+ pub fn io_path(mut self, directory: &str) -> Hypervisor {
+ self.io_path = directory.to_owned();
+ self
+ }
+
+ /// Starts with the specified address for the ipc listener and
+ /// the specified list of modules in form of created service
+ pub fn with_url(addr: &str) -> Hypervisor {
+ let service = HypervisorService::new();
+ let worker = nanoipc::Worker::new(&service);
+ Hypervisor{
+ ipc_addr: addr.to_owned(),
+ service: service,
+ ipc_worker: RwLock::new(worker),
+ processes: RwLock::new(HashMap::new()),
+ modules: HashMap::new(),
+ io_path: "/tmp".to_owned(),
+ }
+ }
+
+ /// Since one binary can host multiple modules
+ /// we match binaries
+ fn match_module(&self, module_id: &IpcModuleId) -> Option<&BootArgs> {
+ self.modules.get(module_id)
+ }
+
+ /// Creates IPC listener and starts all binaries
+ pub fn start(&self) {
+ let mut worker = self.ipc_worker.write().unwrap();
+ worker.add_reqrep(&self.ipc_addr).unwrap_or_else(|e| panic!("Hypervisor ipc worker can not start - critical! ({:?})", e));
+
+ for module_id in self.service.module_ids() {
+ self.start_module(module_id);
+ }
+ }
+
+ /// Start binary for the specified module
+ /// Does nothing when it is already started on module is inside the
+ /// main binary
+ fn start_module(&self, module_id: IpcModuleId) {
+ use std::io::Write;
+
+ self.match_module(&module_id).map(|boot_args| {
+ let mut processes = self.processes.write().unwrap();
+ {
+ if processes.get(&module_id).is_some() {
+ // already started for another module
+ return;
+ }
+ }
+
+ let mut command = Command::new(&std::env::current_exe().unwrap());
+ command.stderr(std::process::Stdio::inherit());
+
+ if let Some(ref cli_args) = boot_args.cli {
+ for arg in cli_args { command.arg(arg); }
+ }
+
+ command.stdin(std::process::Stdio::piped());
+
+ trace!(target: "hypervisor", "Spawn executable: {:?}", command);
+
+ let mut child = command.spawn().unwrap_or_else(
+ |e| panic!("Hypervisor cannot execute command ({:?}): {}", command, e));
+
+ if let Some(ref std_in) = boot_args.stdin {
+ trace!(target: "hypervisor", "Pushing std-in payload...");
+ child.stdin.as_mut()
+ .expect("std-in should be piped above")
+ .write(std_in)
+ .unwrap_or_else(|e| panic!(format!("Error trying to pipe stdin for {:?}: {:?}", &command, e)));
+ drop(child.stdin.take());
+ }
+
+ processes.insert(module_id, child);
+ });
+ }
+
+ /// Reports if all modules are checked in
+ pub fn modules_ready(&self) -> bool {
+ self.service.unchecked_count() == 0
+ }
+
+ pub fn modules_shutdown(&self) -> bool {
+ self.service.running_count() == 0
+ }
+
+ /// Waits for every required module to check in
+ pub fn wait_for_startup(&self) {
+ let mut worker = self.ipc_worker.write().unwrap();
+ while !self.modules_ready() {
+ worker.poll()
+ }
+ }
+
+ /// Waits for every required module to check in
+ pub fn wait_for_shutdown(&self) -> bool {
+ use time::{PreciseTime, Duration};
+
+ let mut worker = self.ipc_worker.write().unwrap();
+ let start = PreciseTime::now();
+ while !self.modules_shutdown() {
+ worker.poll();
+ if start.to(PreciseTime::now()) > Duration::seconds(30) {
+ warn!("Some modules failed to shutdown gracefully, they will be terminated.");
+ break;
+ }
+ }
+ self.modules_shutdown()
+ }
+
+ /// Shutdown the ipc and all managed child processes
+ pub fn shutdown(&self) {
+ let mut childs = self.processes.write().unwrap();
+ for (ref module, _) in childs.iter() {
+ trace!(target: "hypervisor", "Stopping process module: {}", module);
+ self.service.send_shutdown(**module);
+ }
+ trace!(target: "hypervisor", "Waiting for shutdown...");
+ if self.wait_for_shutdown() {
+ trace!(target: "hypervisor", "All modules reported shutdown");
+ return;
+ }
+
+ for (ref module, ref mut process) in childs.iter_mut() {
+ if self.service.is_running(**module) {
+ process.kill().unwrap();
+ trace!("Terminated {}", module);
+ }
+ }
+ }
+}
+
+impl Drop for Hypervisor {
+ fn drop(&mut self) {
+ self.shutdown();
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::sync::atomic::{AtomicBool,Ordering};
+ use std::sync::Arc;
+ use nanoipc;
+
+ #[test]
+ fn can_init() {
+ let url = "ipc:///tmp/test-parity-hypervisor-10.ipc";
+ let test_module_id = 8080u64;
+
+ let hypervisor = Hypervisor::with_url(url).local_module(test_module_id);
+ assert_eq!(false, hypervisor.modules_ready());
+ }
+
+ #[test]
+ fn can_wait_for_startup() {
+ let url = "ipc:///tmp/test-parity-hypervisor-20.ipc";
+ let test_module_id = 8080u64;
+
+ let hypervisor_ready = Arc::new(AtomicBool::new(false));
+ let hypervisor_ready_local = hypervisor_ready.clone();
+
+ ::std::thread::spawn(move || {
+ while !hypervisor_ready.load(Ordering::Relaxed) { }
+
+ let client = nanoipc::fast_client::>(url).unwrap();
+ client.handshake().unwrap();
+ client.module_ready(test_module_id, url.to_owned());
+ });
+
+ let hypervisor = Hypervisor::with_url(url).local_module(test_module_id);
+ hypervisor.start();
+ hypervisor_ready_local.store(true, Ordering::Relaxed);
+ hypervisor.wait_for_startup();
+
+ assert_eq!(true, hypervisor.modules_ready());
+ }
+}
diff --git a/ipc/hypervisor/src/service.rs b/ipc/hypervisor/src/service.rs
new file mode 100644
index 0000000000000000000000000000000000000000..59040251e6452018c4a99454e842c54cb26a969f
--- /dev/null
+++ b/ipc/hypervisor/src/service.rs
@@ -0,0 +1,20 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Parity interprocess hypervisor IPC service
+#![allow(dead_code, unused_assignments, unused_variables)] // codegen issues
+
+include!(concat!(env!("OUT_DIR"), "/service.rs.in"));
diff --git a/ipc/hypervisor/src/service.rs.in b/ipc/hypervisor/src/service.rs.in
new file mode 100644
index 0000000000000000000000000000000000000000..6d6f382680cd6632060d3a0d6f4783b3099141bb
--- /dev/null
+++ b/ipc/hypervisor/src/service.rs.in
@@ -0,0 +1,125 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+use std::sync::{RwLock,Arc};
+use ipc::IpcConfig;
+use std::collections::HashMap;
+use nanoipc;
+
+pub type IpcModuleId = u64;
+
+/// Blockhain database module id
+pub const CLIENT_MODULE_ID: IpcModuleId = 2000;
+
+/// Sync module id
+pub const SYNC_MODULE_ID: IpcModuleId = 2100;
+
+/// IPC service that handles module management
+pub struct HypervisorService {
+ modules: RwLock>,
+}
+
+#[derive(Default)]
+pub struct ModuleState {
+ started: bool,
+ control_url: String,
+ shutdown: bool,
+}
+
+#[ipc]
+pub trait ControlService {
+ fn shutdown(&self) -> bool;
+}
+
+#[ipc]
+impl HypervisorService {
+ // return type for making method synchronous
+ fn module_ready(&self, module_id: u64, control_url: String) -> bool {
+ let mut modules = self.modules.write().unwrap();
+ modules.get_mut(&module_id).map(|mut module| {
+ module.started = true;
+ module.control_url = control_url;
+ });
+ trace!(target: "hypervisor", "Module ready: {}", module_id);
+ true
+ }
+
+ // return type for making method synchronous
+ fn module_shutdown(&self, module_id: u64) -> bool {
+ let mut modules = self.modules.write().unwrap();
+ modules.get_mut(&module_id).map(|mut module| {
+ module.shutdown = true;
+ });
+ trace!(target: "hypervisor", "Module shutdown: {}", module_id);
+ true
+ }
+}
+
+impl HypervisorService {
+ /// New service with the default list of modules
+ pub fn new() -> Arc {
+ HypervisorService::with_modules(vec![])
+ }
+
+ /// New service with list of modules that will report for being ready
+ pub fn with_modules(module_ids: Vec) -> Arc {
+ let mut modules = HashMap::new();
+ for module_id in module_ids {
+ modules.insert(module_id, ModuleState::default());
+ }
+ Arc::new(HypervisorService {
+ modules: RwLock::new(modules),
+ })
+ }
+
+ /// Add the module to the check-list
+ pub fn add_module(&self, module_id: IpcModuleId) {
+ self.modules.write().unwrap().insert(module_id, ModuleState::default());
+ }
+
+ /// Number of modules still being waited for check-in
+ pub fn unchecked_count(&self) -> usize {
+ self.modules.read().unwrap().iter().filter(|&(_, module)| !module.started).count()
+ }
+
+ /// List of all modules within this service
+ pub fn module_ids(&self) -> Vec {
+ self.modules.read().unwrap().iter().map(|(module_id, _)| module_id).cloned().collect()
+ }
+
+ /// Number of modules started and running
+ pub fn running_count(&self) -> usize {
+ self.modules.read().unwrap().iter().filter(|&(_, module)| module.started && !module.shutdown).count()
+ }
+
+ pub fn is_running(&self, id: IpcModuleId) -> bool {
+ self.modules.read().unwrap().get(&id).map(|module| module.started && !module.shutdown).unwrap_or(false)
+ }
+
+ pub fn send_shutdown(&self, module_id: IpcModuleId) {
+ let modules = self.modules.read().unwrap();
+ modules.get(&module_id).map(|module| {
+ trace!(target: "hypervisor", "Sending shutdown to {}({})", module_id, &module.control_url);
+ let client = nanoipc::fast_client::>(&module.control_url).unwrap();
+ client.shutdown();
+ trace!(target: "hypervisor", "Sent shutdown to {}", module_id);
+ });
+ }
+}
+
+impl ::ipc::IpcConfig for HypervisorService {}
+
+impl ::ipc::IpcConfig for ControlService {}
diff --git a/ipc/nano/Cargo.toml b/ipc/nano/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a714e1d008da60ab0f91167e1a3558dc1074ac27
--- /dev/null
+++ b/ipc/nano/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "ethcore-ipc-nano"
+version = "1.8.0"
+authors = ["Parity Technologies "]
+license = "GPL-3.0"
+
+[features]
+
+[dependencies]
+ethcore-ipc = { path = "../rpc" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git", branch = "parity-1.7" }
+log = "0.3"
+lazy_static = "0.2"
diff --git a/ipc/nano/src/lib.rs b/ipc/nano/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9be3d2b1d26a3fd660eb0613d4747f0ea5c198a9
--- /dev/null
+++ b/ipc/nano/src/lib.rs
@@ -0,0 +1,355 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! IPC over nanomsg transport
+
+extern crate ethcore_ipc as ipc;
+extern crate nanomsg;
+#[macro_use] extern crate log;
+#[macro_use] extern crate lazy_static;
+
+pub use ipc::{WithSocket, IpcInterface, IpcConfig};
+pub use nanomsg::Socket as NanoSocket;
+
+use std::sync::*;
+use nanomsg::{Socket, Protocol, Error, Endpoint, PollRequest, PollFd, PollInOut};
+use std::ops::Deref;
+
+const POLL_TIMEOUT: isize = 200;
+const DEFAULT_CONNECTION_TIMEOUT: isize = 30000;
+const DEBUG_CONNECTION_TIMEOUT: isize = 5000;
+
+/// Generic worker to handle service (binded) sockets
+pub struct Worker where S: IpcInterface {
+ service: Arc,
+ sockets: Vec<(Socket, Endpoint)>,
+ polls: Vec,
+ buf: Vec,
+}
+
+/// struct for guarding `_endpoint` (so that it wont drop)
+/// derefs to client `S`
+pub struct GuardedSocket where S: WithSocket {
+ client: Arc,
+ _endpoint: Endpoint,
+}
+
+impl GuardedSocket where S: WithSocket {
+ pub fn service(&self) -> Arc {
+ self.client.clone()
+ }
+}
+
+impl Deref for GuardedSocket where S: WithSocket {
+ type Target = Arc;
+
+ fn deref(&self) -> &Arc {
+ &self.client
+ }
+}
+
+/// Spawns client <`S`> over specified address
+/// creates socket and connects endpoint to it
+/// for duplex (paired) connections with the service
+pub fn init_duplex_client(socket_addr: &str) -> Result, SocketError> where S: WithSocket {
+ let mut socket = Socket::new(Protocol::Pair).map_err(|e| {
+ warn!(target: "ipc", "Failed to create ipc socket: {:?}", e);
+ SocketError::DuplexLink
+ })?;
+
+ socket.set_receive_timeout(DEFAULT_CONNECTION_TIMEOUT).unwrap();
+
+ let endpoint = socket.connect(socket_addr).map_err(|e| {
+ warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", socket_addr, e);
+ SocketError::DuplexLink
+ })?;
+
+ Ok(GuardedSocket {
+ client: Arc::new(S::init(socket)),
+ _endpoint: endpoint,
+ })
+}
+
+/// Spawns client <`S`> over specified address
+/// creates socket and connects endpoint to it
+/// for request-reply connections to the service
+pub fn client(socket_addr: &str, receive_timeout: Option) -> Result, SocketError> where S: WithSocket {
+ let mut socket = Socket::new(Protocol::Req).map_err(|e| {
+ warn!(target: "ipc", "Failed to create ipc socket: {:?}", e);
+ SocketError::RequestLink
+ })?;
+
+ if let Some(timeout) = receive_timeout {
+ socket.set_receive_timeout(timeout).unwrap();
+ }
+
+ let endpoint = socket.connect(socket_addr).map_err(|e| {
+ warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", socket_addr, e);
+ SocketError::RequestLink
+ })?;
+
+ trace!(target: "ipc", "Created client for {}", socket_addr);
+ Ok(GuardedSocket {
+ client: Arc::new(S::init(socket)),
+ _endpoint: endpoint,
+ })
+}
+
+lazy_static! {
+ /// Set PARITY_IPC_DEBUG=1 for fail-fast connectivity problems diagnostic
+ pub static ref DEBUG_FLAG: bool = {
+ use std::env;
+
+ if let Ok(debug) = env::var("PARITY_IPC_DEBUG") {
+ debug == "1" || debug.to_uppercase() == "TRUE"
+ }
+ else { false }
+ };
+}
+
+/// Client with no default timeout on operations
+pub fn generic_client(socket_addr: &str) -> Result, SocketError> where S: WithSocket {
+ if *DEBUG_FLAG {
+ client(socket_addr, Some(DEBUG_CONNECTION_TIMEOUT))
+ } else {
+ client(socket_addr, None)
+ }
+}
+
+/// Client over interface that is supposed to give quick almost non-blocking responses
+pub fn fast_client(socket_addr: &str) -> Result, SocketError> where S: WithSocket {
+ if *DEBUG_FLAG {
+ client(socket_addr, Some(DEBUG_CONNECTION_TIMEOUT))
+ } else {
+ client(socket_addr, Some(DEFAULT_CONNECTION_TIMEOUT))
+ }
+}
+
+/// Error occurred while establising socket or endpoint
+#[derive(Debug)]
+pub enum SocketError {
+ /// Error establising duplex (paired) socket and/or endpoint
+ DuplexLink,
+ /// Error establising duplex (paired) socket and/or endpoint
+ RequestLink,
+}
+
+impl Worker where S: IpcInterface {
+ /// New worker over specified `service`
+ pub fn new(service: &Arc) -> Worker {
+ Worker:: {
+ service: service.clone(),
+ sockets: Vec::new(),
+ polls: Vec::new(),
+ buf: Vec::new(),
+ }
+ }
+
+ /// Polls all sockets, reads and dispatches method invocations
+ pub fn poll(&mut self) {
+ use std::io::Write;
+
+ let mut request = PollRequest::new(&mut self.polls[..]);
+ let _result_guard = Socket::poll(&mut request, POLL_TIMEOUT);
+
+ for (fd_index, fd) in request.get_fds().iter().enumerate() {
+ if fd.can_read() {
+ let (ref mut socket, _) = self.sockets[fd_index];
+ unsafe { self.buf.set_len(0); }
+ match socket.nb_read_to_end(&mut self.buf) {
+ Ok(method_sign_len) => {
+ if method_sign_len >= 2 {
+
+ // method_num
+ let method_num = self.buf[0] as u16 * 256 + self.buf[1] as u16;
+ // payload
+ let payload = &self.buf[2..];
+
+ // dispatching for ipc interface
+ let result = self.service.dispatch_buf(method_num, payload);
+
+ if let Err(e) = socket.write(&result) {
+ warn!(target: "ipc", "Failed to write response: {:?}", e);
+ }
+ }
+ else {
+ warn!(target: "ipc", "Failed to read method signature from socket: unexpected message length({})", method_sign_len);
+ }
+ },
+ Err(Error::TryAgain) => {
+ },
+ Err(x) => {
+ warn!(target: "ipc", "Error polling connections {:?}", x);
+ panic!();
+ }
+ }
+ }
+ }
+ }
+
+ /// Stores nanomsg poll request for reuse
+ fn rebuild_poll_request(&mut self) {
+ self.polls = self.sockets.iter()
+ .map(|&(ref socket, _)| socket.new_pollfd(PollInOut::In))
+ .collect::>();
+ }
+
+ /// Add exclusive socket for paired client
+ /// Only one connection over this address is allowed
+ pub fn add_duplex(&mut self, addr: &str) -> Result<(), SocketError> {
+ let mut socket = Socket::new(Protocol::Pair).map_err(|e| {
+ warn!(target: "ipc", "Failed to create ipc socket: {:?}", e);
+ SocketError::DuplexLink
+ })?;
+
+ let endpoint = socket.bind(addr).map_err(|e| {
+ warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", addr, e);
+ SocketError::DuplexLink
+ })?;
+
+ self.sockets.push((socket, endpoint));
+
+ self.rebuild_poll_request();
+
+ trace!(target: "ipc", "Started duplex worker at {}", addr);
+
+ Ok(())
+ }
+
+ /// Add generic socket for request-reply style communications
+ /// with multiple clients
+ pub fn add_reqrep(&mut self, addr: &str) -> Result<(), SocketError> {
+ let mut socket = Socket::new(Protocol::Rep).map_err(|e| {
+ warn!(target: "ipc", "Failed to create ipc socket: {:?}", e);
+ SocketError::DuplexLink
+ })?;
+
+
+ let endpoint = socket.bind(addr).map_err(|e| {
+ warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", addr, e);
+ SocketError::DuplexLink
+ })?;
+
+ self.sockets.push((socket, endpoint));
+
+ self.rebuild_poll_request();
+
+ trace!(target: "ipc", "Started request-reply worker at {}", addr);
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod service_tests {
+
+ use super::Worker;
+ use ipc::*;
+ use std::io::{Read, Write};
+ use std::sync::{Arc, RwLock};
+ use nanomsg::{Socket, Protocol, Endpoint};
+
+ struct TestInvoke {
+ method_num: u16,
+ params: Vec,
+ }
+
+ struct DummyService {
+ methods_stack: RwLock>,
+ }
+
+ impl DummyService {
+ fn new() -> DummyService {
+ DummyService { methods_stack: RwLock::new(Vec::new()) }
+ }
+ }
+
+ impl IpcInterface for DummyService {
+ fn dispatch(&self, _r: &mut R) -> Vec where R: Read {
+ vec![]
+ }
+ fn dispatch_buf(&self, method_num: u16, buf: &[u8]) -> Vec {
+ self.methods_stack.write().unwrap().push(
+ TestInvoke {
+ method_num: method_num,
+ params: buf.to_vec(),
+ });
+ vec![]
+ }
+ }
+
+ impl IpcConfig for DummyService {}
+
+ fn dummy_write(addr: &str, buf: &[u8]) -> (Socket, Endpoint) {
+ let mut socket = Socket::new(Protocol::Pair).unwrap();
+ let endpoint = socket.connect(addr).unwrap();
+ socket.write(buf).unwrap();
+ (socket, endpoint)
+ }
+
+ #[test]
+ fn can_create_worker() {
+ let worker = Worker::::new(&Arc::new(DummyService::new()));
+ assert_eq!(0, worker.sockets.len());
+ }
+
+ #[test]
+ fn can_add_duplex_socket_to_worker() {
+ let mut worker = Worker::::new(&Arc::new(DummyService::new()));
+ worker.add_duplex("ipc:///tmp/parity-test10.ipc").unwrap();
+ assert_eq!(1, worker.sockets.len());
+ }
+
+ #[test]
+ fn worker_can_poll_empty() {
+ let service = Arc::new(DummyService::new());
+ let mut worker = Worker::::new(&service);
+ worker.add_duplex("ipc:///tmp/parity-test20.ipc").unwrap();
+ worker.poll();
+ assert_eq!(0, service.methods_stack.read().unwrap().len());
+ }
+
+ #[test]
+ fn worker_can_poll() {
+ let url = "ipc:///tmp/parity-test30.ipc";
+
+ let mut worker = Worker::::new(&Arc::new(DummyService::new()));
+ worker.add_duplex(url).unwrap();
+
+ let (_socket, _endpoint) = dummy_write(url, &vec![0, 0, 7, 7, 6, 6]);
+ worker.poll();
+
+ assert_eq!(1, worker.service.methods_stack.read().unwrap().len());
+ assert_eq!(0, worker.service.methods_stack.read().unwrap()[0].method_num);
+ assert_eq!([7, 7, 6, 6], worker.service.methods_stack.read().unwrap()[0].params[..]);
+ }
+
+ #[test]
+ fn worker_can_poll_long() {
+ let url = "ipc:///tmp/parity-test40.ipc";
+
+ let mut worker = Worker::::new(&Arc::new(DummyService::new()));
+ worker.add_duplex(url).unwrap();
+
+ let message = [0u8; 1024*1024];
+
+ let (_socket, _endpoint) = dummy_write(url, &message);
+ worker.poll();
+
+ assert_eq!(1, worker.service.methods_stack.read().unwrap().len());
+ assert_eq!(0, worker.service.methods_stack.read().unwrap()[0].method_num);
+ assert_eq!(vec![0u8; 1024*1024-2], worker.service.methods_stack.read().unwrap()[0].params);
+ }
+}
diff --git a/ipc/rpc/Cargo.toml b/ipc/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..12d73a118bf47dfeac43a1038a57fa41a07f77b0
--- /dev/null
+++ b/ipc/rpc/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "ethcore-ipc"
+version = "1.8.0"
+authors = ["Parity Technologies "]
+license = "GPL-3.0"
+
+[features]
+
+[dependencies]
+ethcore-devtools = { path = "../../devtools" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git", branch = "parity-1.7" }
+ethcore-bigint = { path = "../../util/bigint"}
+ethcore-util = { path = "../../util" }
+semver = "0.6"
diff --git a/ipc/rpc/src/binary.rs b/ipc/rpc/src/binary.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6466acdb1394e261eeafa890cd982ea75572fb43
--- /dev/null
+++ b/ipc/rpc/src/binary.rs
@@ -0,0 +1,1196 @@
+// Copyright 2015-2017 Parity Technologies (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 .
+
+//! Binary representation of types
+
+use bigint::prelude::{U256, U512};
+use bigint::hash::{H256, H512, H2048};
+use util::{Address};
+use std::mem;
+use std::collections::{VecDeque, BTreeMap};
+use std::ops::Range;
+use super::Handshake;
+
+#[derive(Debug)]
+pub enum BinaryConvertErrorKind {
+ SizeMismatch {
+ expected: usize,
+ found: usize,
+ },
+ TargetPayloadEmpty,
+ UnexpectedVariant(u8),
+ MissingLengthValue,
+ InconsistentBoundaries,
+ NotSupported,
+}
+
+#[derive(Debug)]
+pub struct BinaryConvertError {
+ member_tree: Vec<&'static str>,
+ kind: BinaryConvertErrorKind,
+}
+
+impl BinaryConvertError {
+ pub fn size(expected: usize, found: usize) -> BinaryConvertError {
+ BinaryConvertError {
+ member_tree: Vec::new(),
+ kind: BinaryConvertErrorKind::SizeMismatch {
+ expected: expected,
+ found: found,
+ }
+ }
+ }
+
+ pub fn empty() -> BinaryConvertError {
+ BinaryConvertError { member_tree: Vec::new(), kind: BinaryConvertErrorKind::TargetPayloadEmpty }
+ }
+
+ pub fn variant(val: u8) -> BinaryConvertError {
+ BinaryConvertError { member_tree: Vec::new(), kind: BinaryConvertErrorKind::UnexpectedVariant(val) }
+ }
+
+ pub fn length() -> BinaryConvertError {
+ BinaryConvertError { member_tree: Vec::new(), kind: BinaryConvertErrorKind::MissingLengthValue }
+ }
+
+ pub fn boundaries() -> BinaryConvertError {
+ BinaryConvertError { member_tree: Vec::new(), kind: BinaryConvertErrorKind::InconsistentBoundaries }
+ }
+
+ pub fn not_supported() -> BinaryConvertError {
+ BinaryConvertError { member_tree: Vec::new(), kind: BinaryConvertErrorKind::NotSupported }
+ }
+
+ pub fn named(mut self, name: &'static str) -> BinaryConvertError {
+ self.member_tree.push(name);
+ self
+ }
+}
+
+#[derive(Debug)]
+pub enum BinaryError {
+ Serialization(BinaryConvertError),
+ Io(::std::io::Error),
+}
+
+impl From<::std::io::Error> for BinaryError {
+ fn from(err: ::std::io::Error) -> Self { BinaryError::Io(err) }
+}
+
+impl From for BinaryError {
+ fn from(err: BinaryConvertError) -> Self { BinaryError::Serialization(err) }
+}
+
+pub trait BinaryConvertable : Sized {
+ fn size(&self) -> usize {
+ mem::size_of::()
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError>;
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result;
+
+ fn from_empty_bytes() -> Result {
+ Err(BinaryConvertError::size(mem::size_of::(), 0))
+ }
+
+ fn len_params() -> usize {
+ 0
+ }
+}
+
+impl BinaryConvertable for Option where T: BinaryConvertable {
+ fn size(&self) -> usize {
+ match * self { None => 0, Some(ref val) => val.size() }
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> {
+ match *self { None => Err(BinaryConvertError::empty()), Some(ref val) => val.to_bytes(buffer, length_stack) }
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
+ if buffer.len() == 0 { return Self::from_empty_bytes(); }
+ Ok(Some(T::from_bytes(buffer, length_stack)?))
+ }
+
+ fn from_empty_bytes() -> Result {
+ Ok(None)
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+}
+
+impl BinaryConvertable for Result<(), E> {
+ fn size(&self) -> usize {
+ match *self {
+ Ok(_) => 0,
+ Err(ref e) => e.size(),
+ }
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> {
+ match *self {
+ Ok(_) => Err(BinaryConvertError::empty()),
+ Err(ref e) => Ok(e.to_bytes(buffer, length_stack)?),
+ }
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
+ Ok(Err(E::from_bytes(&buffer, length_stack)?))
+ }
+
+ fn from_empty_bytes() -> Result {
+ Ok(Ok(()))
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+}
+
+
+impl BinaryConvertable for Result {
+ fn size(&self) -> usize {
+ match *self {
+ Ok(ref r) => r.size(),
+ Err(_) => 0,
+ }
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> {
+ match *self {
+ Ok(ref r) => Ok(r.to_bytes(buffer, length_stack)?),
+ Err(_) => Err(BinaryConvertError::empty()),
+ }
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
+ Ok(Ok(R::from_bytes(&buffer, length_stack)?))
+ }
+
+ fn from_empty_bytes() -> Result {
+ Ok(Err(()))
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+}
+
+impl BinaryConvertable for Result {
+ fn size(&self) -> usize {
+ 1usize + match *self {
+ Ok(ref r) => r.size(),
+ Err(ref e) => e.size(),
+ }
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> {
+ match *self {
+ Ok(ref r) => {
+ buffer[0] = 0;
+ if r.size() > 0 {
+ Ok(r.to_bytes(&mut buffer[1..], length_stack)?)
+ }
+ else { Ok(()) }
+ },
+ Err(ref e) => {
+ buffer[0] = 1;
+ if e.size() > 0 {
+ Ok(e.to_bytes(&mut buffer[1..], length_stack)?)
+ }
+ else { Ok(()) }
+ },
+ }
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
+ match buffer[0] {
+ 0 => {
+ match buffer.len() {
+ 1 => Ok(Ok(R::from_empty_bytes()?)),
+ _ => Ok(Ok(R::from_bytes(&buffer[1..], length_stack)?)),
+ }
+ }
+ 1 => Ok(Err(E::from_bytes(&buffer[1..], length_stack)?)),
+ _ => Err(BinaryConvertError::variant(buffer[0]))
+ }
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+}
+
+impl BinaryConvertable for BTreeMap where K : BinaryConvertable + Ord, V: BinaryConvertable {
+ fn size(&self) -> usize {
+ 0usize + match K::len_params() {
+ 0 => mem::size_of::() * self.len(),
+ _ => self.iter().fold(0usize, |acc, (k, _)| acc + k.size())
+ } + match V::len_params() {
+ 0 => mem::size_of::() * self.len(),
+ _ => self.iter().fold(0usize, |acc, (_, v)| acc + v.size())
+ }
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> {
+ let mut offset = 0usize;
+ for (key, val) in self.iter() {
+ let key_size = match K::len_params() {
+ 0 => mem::size_of::(),
+ _ => { let size = key.size(); length_stack.push_back(size); size }
+ };
+ let val_size = match K::len_params() {
+ 0 => mem::size_of::(),
+ _ => { let size = val.size(); length_stack.push_back(size); size }
+ };
+
+ if key_size > 0 {
+ let item_end = offset + key_size;
+ key.to_bytes(&mut buffer[offset..item_end], length_stack)?;
+ offset = item_end;
+ }
+
+ if val_size > 0 {
+ let item_end = offset + key_size;
+ val.to_bytes(&mut buffer[offset..item_end], length_stack)?;
+ offset = item_end;
+ }
+ }
+ Ok(())
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
+ let mut index = 0;
+ let mut result = Self::new();
+
+ if buffer.len() == 0 { return Ok(result); }
+
+ loop {
+ let key_size = match K::len_params() {
+ 0 => mem::size_of::(),
+ _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?,
+ };
+ let key = if key_size == 0 {
+ K::from_empty_bytes()?
+ } else {
+ if index + key_size > buffer.len() {
+ return Err(BinaryConvertError::boundaries())
+ }
+ K::from_bytes(&buffer[index..index+key_size], length_stack)?
+ };
+ index = index + key_size;
+
+ let val_size = match V::len_params() {
+ 0 => mem::size_of::(),
+ _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?,
+ };
+ let val = if val_size == 0 {
+ V::from_empty_bytes()?
+ } else {
+ if index + val_size > buffer.len() {
+ return Err(BinaryConvertError::boundaries())
+ }
+ V::from_bytes(&buffer[index..index+val_size], length_stack)?
+ };
+ result.insert(key, val);
+ index = index + val_size;
+
+ if index == buffer.len() { break; }
+ if index > buffer.len() {
+ return Err(BinaryConvertError::boundaries())
+ }
+ }
+
+ Ok(result)
+ }
+
+ fn from_empty_bytes() -> Result {
+ Ok(Self::new())
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+}
+
+impl BinaryConvertable for VecDeque where T: BinaryConvertable {
+ fn size(&self) -> usize {
+ match T::len_params() {
+ 0 => mem::size_of::() * self.len(),
+ _ => self.iter().fold(0usize, |acc, t| acc + t.size()),
+ }
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> {
+ let mut offset = 0usize;
+ for item in self.iter() {
+ let next_size = match T::len_params() {
+ 0 => mem::size_of::(),
+ _ => { let size = item.size(); length_stack.push_back(size); size },
+ };
+ if next_size > 0 {
+ let item_end = offset + next_size;
+ item.to_bytes(&mut buffer[offset..item_end], length_stack)?;
+ offset = item_end;
+ }
+ }
+ Ok(())
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
+ let mut index = 0;
+ let mut result = Self::with_capacity(
+ match T::len_params() {
+ 0 => buffer.len() / mem::size_of::(),
+ _ => 128,
+ });
+
+ if buffer.len() == 0 { return Ok(result); }
+
+ loop {
+ let next_size = match T::len_params() {
+ 0 => mem::size_of::(),
+ _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?,
+ };
+ let item = if next_size == 0 {
+ T::from_empty_bytes()?
+ }
+ else {
+ if index + next_size > buffer.len() {
+ return Err(BinaryConvertError::boundaries())
+ }
+ T::from_bytes(&buffer[index..index+next_size], length_stack)?
+ };
+ result.push_back(item);
+
+ index = index + next_size;
+ if index == buffer.len() { break; }
+ if index > buffer.len() {
+ return Err(BinaryConvertError::boundaries())
+ }
+ }
+
+ Ok(result)
+ }
+
+ fn from_empty_bytes() -> Result {
+ Ok(Self::new())
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+}
+
+impl BinaryConvertable for Vec where T: BinaryConvertable {
+ fn size(&self) -> usize {
+ match T::len_params() {
+ 0 => mem::size_of::() * self.len(),
+ _ => self.iter().fold(0usize, |acc, t| acc + t.size()),
+ }
+ }
+
+ fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> {
+ let mut offset = 0usize;
+ for item in self.iter() {
+ let next_size = match T::len_params() {
+ 0 => mem::size_of::(),
+ _ => { let size = item.size(); length_stack.push_back(size); size },
+ };
+ if next_size > 0 {
+ let item_end = offset + next_size;
+ item.to_bytes(&mut buffer[offset..item_end], length_stack)?;
+ offset = item_end;
+ }
+ }
+ Ok(())
+ }
+
+ fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
+ let mut index = 0;
+ let mut result = Self::with_capacity(
+ match T::len_params() {
+ 0 => buffer.len() / mem::size_of::(),
+ _ => 128,
+ });
+
+ if buffer.len() == 0 { return Ok(result); }
+
+ loop {
+ let next_size = match T::len_params() {
+ 0 => mem::size_of::(),
+ _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?,
+ };
+ let item = if next_size == 0 {
+ T::from_empty_bytes()?
+ }
+ else {
+ if index + next_size > buffer.len() {
+ return Err(BinaryConvertError::boundaries())
+ }
+ T::from_bytes(&buffer[index..index+next_size], length_stack)?
+ };
+ result.push(item);
+
+ index = index + next_size;
+ if index == buffer.len() { break; }
+ if index > buffer.len() {
+ return Err(BinaryConvertError::boundaries())
+ }
+ }
+
+ Ok(result)
+ }
+
+ fn from_empty_bytes() -> Result {
+ Ok(Self::new())
+ }
+
+ fn len_params() -> usize {
+ 1
+ }
+}
+
+impl BinaryConvertable for String {
+ fn size(&self) -> usize {
+ self.as_bytes().len()
+ }
+
+ fn from_empty_bytes() -> Result