      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102

    // 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://www.gnu.org/licenses/>.

    //! Ethcore rpc.
    #![warn(missing_docs)]
    #![cfg_attr(feature="nightly", feature(custom_derive, custom_attribute, plugin))]
    #![cfg_attr(feature="nightly", plugin(serde_macros, clippy))]

    extern crate semver;
    extern crate rustc_serialize;
    extern crate serde;
    extern crate serde_json;
    extern crate jsonrpc_core;
    extern crate jsonrpc_http_server;

    extern crate ethcore_io as io;
    extern crate ethcore;
    extern crate ethkey;
    extern crate ethcrypto as crypto;
    extern crate ethstore;
    extern crate ethsync;
    extern crate ethash;
    extern crate transient_hashmap;
    extern crate jsonrpc_ipc_server as ipc;
    extern crate ethcore_ipc;
    extern crate time;
    extern crate rlp;
    extern crate fetch;
    extern crate futures;
    extern crate parity_updater as updater;
    extern crate parity_reactor;

    #[macro_use]
    extern crate log;
    #[macro_use]
    extern crate ethcore_util as util;
    #[macro_use]
    extern crate jsonrpc_macros;

    #[cfg(test)]
    extern crate ethjson;
    #[cfg(test)]
    extern crate ethcore_devtools as devtools;

    use std::sync::Arc;
    use std::net::SocketAddr;
    use io::PanicHandler;
    use jsonrpc_core::reactor::RpcHandler;

    pub use ipc::{Server as IpcServer, Error as IpcServerError};
    pub use jsonrpc_http_server::{ServerBuilder, Server, RpcServerError};
    pub mod v1;
    pub use v1::{SigningQueue, SignerService, ConfirmationsQueue, NetworkSettings, Metadata, Origin};
    pub use v1::block_import::is_major_importing;

    /// Start http server asynchronously and returns result with `Server` handle on success or an error.
    pub fn start_http<M: jsonrpc_core::Metadata>(
    	addr: &SocketAddr,
    	cors_domains: Option<Vec<String>>,
    	allowed_hosts: Option<Vec<String>>,
    	panic_handler: Arc<PanicHandler>,
    	handler: RpcHandler<M>,
    ) -> Result<Server, RpcServerError> {

    	let cors_domains = cors_domains.map(|domains| {
    		domains.into_iter()
    			.map(|v| match v.as_str() {
    				"*" => jsonrpc_http_server::AccessControlAllowOrigin::Any,
    				"null" => jsonrpc_http_server::AccessControlAllowOrigin::Null,
    				v => jsonrpc_http_server::AccessControlAllowOrigin::Value(v.into()),
    			})
    			.collect()
    	});

    	ServerBuilder::with_rpc_handler(handler)
    		.cors(cors_domains.into())
    		.allowed_hosts(allowed_hosts.into())
    		.panic_handler(move || {
    			panic_handler.notify_all("Panic in RPC thread.".to_owned());
    		})
    		.start_http(addr)
    }

    /// Start ipc server asynchronously and returns result with `Server` handle on success or an error.
    pub fn start_ipc<M: jsonrpc_core::Metadata>(addr: &str, handler: RpcHandler<M>) -> Result<ipc::Server<M>, ipc::Error> {
    	let server = ipc::Server::with_rpc_handler(addr, handler)?;
    	server.run_async()?;
    	Ok(server)
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)