[WIP] Snapshot sync

codechain/codechain.yml

@@ -260,6 +260,16 @@ args:
         takes_value: true
         conflicts_with:
             - no-discovery
+    - snapshot-hash:
+        long: snapshot-hash
+        value_name: HASH
+        requires: snapshot-number
+        takes_value: true
+    - snapshot-number:
+        long: snapshot-number
+        value_name: NUM
+        requires: snapshot-hash
+        takes_value: true
     - no-snapshot:
         long: no-snapshot
         help: Disable snapshots

codechain/config/mod.rs

@@ -25,6 +25,7 @@ use cidr::IpCidr;
 use ckey::PlatformAddress;
 use clap;
 use cnetwork::{FilterEntry, NetworkConfig, SocketAddr};
+use primitives::H256;
 use toml;
 
 pub use self::chain_type::ChainType;
@@ -274,6 +275,8 @@ pub struct Network {
     pub min_peers: Option<usize>,
     pub max_peers: Option<usize>,
     pub sync: Option<bool>,
+    pub snapshot_hash: Option<H256>,
+    pub snapshot_number: Option<u64>,
     pub transaction_relay: Option<bool>,
     pub discovery: Option<bool>,
     pub discovery_type: Option<String>,
@@ -313,6 +316,8 @@ fn default_enable_devel_api() -> bool {
 pub struct Snapshot {
     pub disable: Option<bool>,
     pub path: Option<String>,
+    // Snapshot's age in blocks
+    pub expiration: Option<u64>,
 }
 
 #[derive(Deserialize)]
@@ -575,6 +580,12 @@ impl Network {
         if other.sync.is_some() {
             self.sync = other.sync;
         }
+        if other.snapshot_hash.is_some() {
+            self.snapshot_hash = other.snapshot_hash;
+        }
+        if other.snapshot_number.is_some() {
+            self.snapshot_number = other.snapshot_number;
+        }
         if other.transaction_relay.is_some() {
             self.transaction_relay = other.transaction_relay;
         }
@@ -627,6 +638,12 @@ impl Network {
         if matches.is_present("no-sync") {
             self.sync = Some(false);
         }
+        if let Some(snapshot_hash) = matches.value_of("snapshot-hash") {
+            self.snapshot_hash = Some(snapshot_hash.parse().map_err(|_| "Invalid snapshot-hash")?);
+        }
+        if let Some(snapshot_number) = matches.value_of("snapshot-number") {
+            self.snapshot_number = Some(snapshot_number.parse().map_err(|_| "Invalid snapshot-number")?);
+        }
         if matches.is_present("no-tx-relay") {
             self.transaction_relay = Some(false);
         }
@@ -739,6 +756,9 @@ impl Snapshot {
         if other.path.is_some() {
             self.path = other.path.clone();
         }
+        if other.expiration.is_some() {
+            self.expiration = other.expiration;
+        }
     }
 
     pub fn overwrite_with(&mut self, matches: &clap::ArgMatches) -> Result<(), String> {

codechain/config/presets/config.dev.toml

@@ -52,6 +52,7 @@ max_connections = 100
 [snapshot]
 disable = false
 path = "snapshot"
+expiration = 100000 # blocks. About a week
 
 [stratum]
 disable = false

codechain/config/presets/config.prod.toml

@@ -52,6 +52,7 @@ max_connections = 100
 [snapshot]
 disable = true
 path = "snapshot"
+expiration = 100000 # blocks. About a week
 
 [stratum]
 disable = true

codechain/rpc.rs

@@ -15,8 +15,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use std::io;
-use std::net::SocketAddr;
 
+use crate::config::Config;
 use crate::rpc_apis;
 use crpc::{
     jsonrpc_core, start_http, start_ipc, start_ws, HttpServer, IpcServer, MetaIoHandler, Middleware, WsError, WsServer,
@@ -33,38 +33,27 @@ pub struct RpcHttpConfig {
 }
 
 pub fn rpc_http_start(
-    cfg: RpcHttpConfig,
-    enable_devel_api: bool,
-    deps: &rpc_apis::ApiDependencies,
+    server: MetaIoHandler<(), impl Middleware<()>>,
+    config: RpcHttpConfig,
 ) -> Result<HttpServer, String> {
-    let url = format!("{}:{}", cfg.interface, cfg.port);
+    let url = format!("{}:{}", config.interface, config.port);
     let addr = url.parse().map_err(|_| format!("Invalid JSONRPC listen host/port given: {}", url))?;
-    let server = setup_http_rpc_server(&addr, cfg.cors.clone(), cfg.hosts.clone(), enable_devel_api, deps)?;
-    cinfo!(RPC, "RPC Listening on {}", url);
-    if let Some(hosts) = cfg.hosts {
-        cinfo!(RPC, "Allowed hosts are {:?}", hosts);
-    }
-    if let Some(cors) = cfg.cors {
-        cinfo!(RPC, "CORS domains are {:?}", cors);
-    }
-    Ok(server)
-}
-
-fn setup_http_rpc_server(
-    url: &SocketAddr,
-    cors_domains: Option<Vec<String>>,
-    allowed_hosts: Option<Vec<String>>,
-    enable_devel_api: bool,
-    deps: &rpc_apis::ApiDependencies,
-) -> Result<HttpServer, String> {
-    let server = setup_rpc_server(enable_devel_api, deps);
-    let start_result = start_http(url, cors_domains, allowed_hosts, server);
+    let start_result = start_http(&addr, config.cors.clone(), config.hosts.clone(), server);
     match start_result {
         Err(ref err) if err.kind() == io::ErrorKind::AddrInUse => {
             Err(format!("RPC address {} is already in use, make sure that another instance of a CodeChain node is not running or change the address using the --jsonrpc-port option.", url))
         },
         Err(e) => Err(format!("RPC error: {:?}", e)),
-        Ok(server) => Ok(server),
+        Ok(server) => {
+            cinfo!(RPC, "RPC Listening on {}", url);
+            if let Some(hosts) = config.hosts {
+                cinfo!(RPC, "Allowed hosts are {:?}", hosts);
+            }
+            if let Some(cors) = config.cors {
+                cinfo!(RPC, "CORS domains are {:?}", cors);
+            }
+            Ok(server)
+        },
     }
 }
 
@@ -74,19 +63,17 @@ pub struct RpcIpcConfig {
 }
 
 pub fn rpc_ipc_start(
-    cfg: &RpcIpcConfig,
-    enable_devel_api: bool,
-    deps: &rpc_apis::ApiDependencies,
+    server: MetaIoHandler<(), impl Middleware<()>>,
+    config: RpcIpcConfig,
 ) -> Result<IpcServer, String> {
-    let server = setup_rpc_server(enable_devel_api, deps);
-    let start_result = start_ipc(&cfg.socket_addr, server);
+    let start_result = start_ipc(&config.socket_addr, server);
     match start_result {
         Err(ref err) if err.kind() == io::ErrorKind::AddrInUse => {
-            Err(format!("IPC address {} is already in use, make sure that another instance of a Codechain node is not running or change the address using the --ipc-path options.", cfg.socket_addr))
+            Err(format!("IPC address {} is already in use, make sure that another instance of a Codechain node is not running or change the address using the --ipc-path options.", config.socket_addr))
             },
         Err(e) => Err(format!("IPC error: {:?}", e)),
         Ok(server) =>  {
-            cinfo!(RPC, "IPC Listening on {}", cfg.socket_addr);
+            cinfo!(RPC, "IPC Listening on {}", config.socket_addr);
             Ok(server)
         },
     }
@@ -99,15 +86,10 @@ pub struct RpcWsConfig {
     pub max_connections: usize,
 }
 
-pub fn rpc_ws_start(
-    cfg: &RpcWsConfig,
-    enable_devel_api: bool,
-    deps: &rpc_apis::ApiDependencies,
-) -> Result<WsServer, String> {
-    let server = setup_rpc_server(enable_devel_api, deps);
-    let url = format!("{}:{}", cfg.interface, cfg.port);
+pub fn rpc_ws_start(server: MetaIoHandler<(), impl Middleware<()>>, config: RpcWsConfig) -> Result<WsServer, String> {
+    let url = format!("{}:{}", config.interface, config.port);
     let addr = url.parse().map_err(|_| format!("Invalid WebSockets listen host/port given: {}", url))?;
-    let start_result = start_ws(&addr, server, cfg.max_connections);
+    let start_result = start_ws(&addr, server, config.max_connections);
     match start_result {
         Err(WsError::Io(ref err)) if err.kind() == io::ErrorKind::AddrInUse => {
             Err(format!("WebSockets address {} is already in use, make sure that another instance of a Codechain node is not running or change the address using the --ws-port options.", addr))
@@ -120,12 +102,9 @@ pub fn rpc_ws_start(
     }
 }
 
-fn setup_rpc_server(
-    enable_devel_api: bool,
-    deps: &rpc_apis::ApiDependencies,
-) -> MetaIoHandler<(), impl Middleware<()>> {
+pub fn setup_rpc_server(config: &Config, deps: &rpc_apis::ApiDependencies) -> MetaIoHandler<(), impl Middleware<()>> {
     let mut handler = MetaIoHandler::with_middleware(LogMiddleware::new());
-    deps.extend_api(enable_devel_api, &mut handler);
+    deps.extend_api(config, &mut handler);
     rpc_apis::setup_rpc(handler)
 }
 

codechain/rpc_apis.rs

@@ -22,6 +22,8 @@ use cnetwork::{EventSender, NetworkControl};
 use crpc::{MetaIoHandler, Middleware, Params, Value};
 use csync::BlockSyncEvent;
 
+use crate::config::Config;
+
 pub struct ApiDependencies {
     pub client: Arc<Client>,
     pub miner: Arc<Miner>,
@@ -31,11 +33,12 @@ pub struct ApiDependencies {
 }
 
 impl ApiDependencies {
-    pub fn extend_api(&self, enable_devel_api: bool, handler: &mut MetaIoHandler<(), impl Middleware<()>>) {
+    pub fn extend_api(&self, config: &Config, handler: &mut MetaIoHandler<(), impl Middleware<()>>) {
         use crpc::v1::*;
         handler.extend_with(ChainClient::new(Arc::clone(&self.client)).to_delegate());
         handler.extend_with(MempoolClient::new(Arc::clone(&self.client)).to_delegate());
-        if enable_devel_api {
+        handler.extend_with(SnapshotClient::new(Arc::clone(&self.client), config.snapshot.path.clone()).to_delegate());
+        if config.rpc.enable_devel_api {
             handler.extend_with(
                 DevelClient::new(Arc::clone(&self.client), Arc::clone(&self.miner), self.block_sync.clone())
                     .to_delegate(),