openethereum/parity/run.rs

// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity Ethereum.

// Parity Ethereum 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 Ethereum 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 Ethereum.  If not, see <http://www.gnu.org/licenses/>.

use std::{
    any::Any,
    sync::{atomic, Arc, Weak},
    thread,
    time::{Duration, Instant},
};

use account_utils;
use ansi_term::Colour;
use bytes::Bytes;
use cache::CacheConfig;
use call_contract::CallContract;
use db;
use dir::{DatabaseDirectories, Directories};
use ethcore::{
    client::{
        BlockChainClient, BlockId, BlockInfo, Client, DatabaseCompactionProfile, Mode, VMType,
    },
    miner::{self, stratum, Miner, MinerOptions, MinerService},
    snapshot::{self, SnapshotConfiguration},
    spec::{OptimizeFor, SpecParams},
    verification::queue::VerifierSettings,
};
use ethcore_logger::{Config as LogConfig, RotatingLogger};
use ethcore_private_tx::{EncryptorConfig, ProviderConfig, SecretStoreEncryptor};
use ethcore_service::ClientService;
use ethereum_types::Address;
use futures::IntoFuture;
use hash_fetch::{self, fetch};
use helpers::{execute_upgrades, passwords_from_files, to_client_config};
use informant::{FullNodeInformantData, Informant, LightNodeInformantData};
use ipfs;
use journaldb::Algorithm;
use jsonrpc_core;
use light::Cache as LightDataCache;
use miner::{external::ExternalMiner, work_notify::WorkPoster};
use modules;
use node_filter::NodeFilter;
use params::{
    fatdb_switch_to_bool, mode_switch_to_bool, tracing_switch_to_bool, AccountsConfig,
    GasPricerConfig, MinerExtras, Pruning, SpecType, Switch,
};
use parity_rpc::{
    informant, is_major_importing, FutureOutput, FutureResponse, FutureResult, Metadata,
    NetworkSettings, Origin, PubSubSession,
};
use parity_runtime::Runtime;
use parity_version::version;
use registrar::{Asynchronous, RegistrarClient};
use rpc;
use rpc_apis;
use secretstore;
use signer;
use sync::{self, PrivateTxHandler, SyncConfig};
use updater::{UpdatePolicy, Updater};
use user_defaults::UserDefaults;

// how often to take periodic snapshots.
const SNAPSHOT_PERIOD: u64 = 5000;

// how many blocks to wait before starting a periodic snapshot.
const SNAPSHOT_HISTORY: u64 = 100;

// Number of minutes before a given gas price corpus should expire.
// Light client only.
const GAS_CORPUS_EXPIRATION_MINUTES: u64 = 60 * 6;

// Full client number of DNS threads
const FETCH_FULL_NUM_DNS_THREADS: usize = 4;

// Light client number of DNS threads
const FETCH_LIGHT_NUM_DNS_THREADS: usize = 1;

#[derive(Debug, PartialEq)]
pub struct RunCmd {
    pub cache_config: CacheConfig,
    pub dirs: Directories,
    pub spec: SpecType,
    pub pruning: Pruning,
    pub pruning_history: u64,
    pub pruning_memory: usize,
    /// Some if execution should be daemonized. Contains pid_file path.
    pub daemon: Option<String>,
    pub logger_config: LogConfig,
    pub miner_options: MinerOptions,
    pub gas_price_percentile: usize,
    pub poll_lifetime: u32,
    pub ws_conf: rpc::WsConfiguration,
    pub http_conf: rpc::HttpConfiguration,
    pub ipc_conf: rpc::IpcConfiguration,
    pub net_conf: sync::NetworkConfiguration,
    pub network_id: Option<u64>,
    pub warp_sync: bool,
    pub warp_barrier: Option<u64>,
    pub acc_conf: AccountsConfig,
    pub gas_pricer_conf: GasPricerConfig,
    pub miner_extras: MinerExtras,
    pub update_policy: UpdatePolicy,
    pub mode: Option<Mode>,
    pub tracing: Switch,
    pub fat_db: Switch,
    pub compaction: DatabaseCompactionProfile,
    pub vm_type: VMType,
    pub experimental_rpcs: bool,
    pub net_settings: NetworkSettings,
    pub ipfs_conf: ipfs::Configuration,
    pub secretstore_conf: secretstore::Configuration,
    pub private_provider_conf: ProviderConfig,
    pub private_encryptor_conf: EncryptorConfig,
    pub private_tx_enabled: bool,
    pub name: String,
    pub custom_bootnodes: bool,
    pub stratum: Option<stratum::Options>,
    pub snapshot_conf: SnapshotConfiguration,
    pub check_seal: bool,
    pub allow_missing_blocks: bool,
    pub download_old_blocks: bool,
    pub verifier_settings: VerifierSettings,
    pub serve_light: bool,
    pub light: bool,
    pub no_persistent_txqueue: bool,
    pub no_hardcoded_sync: bool,
    pub max_round_blocks_to_import: usize,
    pub on_demand_response_time_window: Option<u64>,
    pub on_demand_request_backoff_start: Option<u64>,
    pub on_demand_request_backoff_max: Option<u64>,
    pub on_demand_request_backoff_rounds_max: Option<usize>,
    pub on_demand_request_consecutive_failures: Option<usize>,
}

// node info fetcher for the local store.
struct FullNodeInfo {
    miner: Option<Arc<Miner>>, // TODO: only TXQ needed, just use that after decoupling.
}

impl ::local_store::NodeInfo for FullNodeInfo {
    fn pending_transactions(&self) -> Vec<::types::transaction::PendingTransaction> {
        let miner = match self.miner.as_ref() {
            Some(m) => m,
            None => return Vec::new(),
        };

        miner
            .local_transactions()
            .values()
            .filter_map(|status| match *status {
                ::miner::pool::local_transactions::Status::Pending(ref tx) => {
                    Some(tx.pending().clone())
                }
                _ => None,
            })
            .collect()
    }
}

type LightClient = ::light::client::Client<::light_helpers::EpochFetch>;

// helper for light execution.
fn execute_light_impl<Cr>(
    cmd: RunCmd,
    logger: Arc<RotatingLogger>,
    on_client_rq: Cr,
) -> Result<RunningClient, String>
where
    Cr: Fn(String) + 'static + Send,
{
    use light::client as light_client;
    use parking_lot::{Mutex, RwLock};
    use sync::{LightSync, LightSyncParams, ManageNetwork};

    // load spec
    let spec = cmd.spec.spec(SpecParams::new(
        cmd.dirs.cache.as_ref(),
        OptimizeFor::Memory,
    ))?;

    // load genesis hash
    let genesis_hash = spec.genesis_header().hash();

    // database paths
    let db_dirs = cmd.dirs.database(
        genesis_hash,
        cmd.spec.legacy_fork_name(),
        spec.data_dir.clone(),
    );

    // user defaults path
    let user_defaults_path = db_dirs.user_defaults_path();

    // load user defaults
    let user_defaults = UserDefaults::load(&user_defaults_path)?;

    // select pruning algorithm
    let algorithm = cmd.pruning.to_algorithm(&user_defaults);

    // execute upgrades
    execute_upgrades(&cmd.dirs.base, &db_dirs, algorithm, &cmd.compaction)?;

    // create dirs used by parity
    cmd.dirs.create_dirs(
        cmd.acc_conf.unlocked_accounts.len() == 0,
        cmd.secretstore_conf.enabled,
    )?;

    //print out running parity environment
    print_running_environment(&spec.data_dir, &cmd.dirs, &db_dirs);

    info!(
        "Running in experimental {} mode.",
        Colour::Blue.bold().paint("Light Client")
    );

    // TODO: configurable cache size.
    let cache = LightDataCache::new(
        Default::default(),
        Duration::from_secs(60 * GAS_CORPUS_EXPIRATION_MINUTES),
    );
    let cache = Arc::new(Mutex::new(cache));

    // start client and create transaction queue.
    let mut config = light_client::Config {
        queue: Default::default(),
        chain_column: ::ethcore_db::COL_LIGHT_CHAIN,
        verify_full: true,
        check_seal: cmd.check_seal,
        no_hardcoded_sync: cmd.no_hardcoded_sync,
    };

    config.queue.max_mem_use = cmd.cache_config.queue() as usize * 1024 * 1024;
    config.queue.verifier_settings = cmd.verifier_settings;

    // start on_demand service.

    let response_time_window = cmd
        .on_demand_response_time_window
        .map_or(::light::on_demand::DEFAULT_RESPONSE_TIME_TO_LIVE, |s| {
            Duration::from_secs(s)
        });

    let request_backoff_start = cmd.on_demand_request_backoff_start.map_or(
        ::light::on_demand::DEFAULT_REQUEST_MIN_BACKOFF_DURATION,
        |s| Duration::from_secs(s),
    );

    let request_backoff_max = cmd.on_demand_request_backoff_max.map_or(
        ::light::on_demand::DEFAULT_REQUEST_MAX_BACKOFF_DURATION,
        |s| Duration::from_secs(s),
    );

    let on_demand = Arc::new({
        ::light::on_demand::OnDemand::new(
            cache.clone(),
            response_time_window,
            request_backoff_start,
            request_backoff_max,
            cmd.on_demand_request_backoff_rounds_max
                .unwrap_or(::light::on_demand::DEFAULT_MAX_REQUEST_BACKOFF_ROUNDS),
            cmd.on_demand_request_consecutive_failures
                .unwrap_or(::light::on_demand::DEFAULT_NUM_CONSECUTIVE_FAILED_REQUESTS),
        )
    });

    let sync_handle = Arc::new(RwLock::new(Weak::new()));
    let fetch = ::light_helpers::EpochFetch {
        on_demand: on_demand.clone(),
        sync: sync_handle.clone(),
    };

    // initialize database.
    let db = db::open_db(
        &db_dirs
            .client_path(algorithm)
            .to_str()
            .expect("DB path could not be converted to string."),
        &cmd.cache_config,
        &cmd.compaction,
    )
    .map_err(|e| format!("Failed to open database {:?}", e))?;

    let service = light_client::Service::start(config, &spec, fetch, db, cache.clone())
        .map_err(|e| format!("Error starting light client: {}", e))?;
    let client = service.client().clone();
    let txq = Arc::new(RwLock::new(
        ::light::transaction_queue::TransactionQueue::default(),
    ));
    let provider = ::light::provider::LightProvider::new(client.clone(), txq.clone());

    // start network.
    // set up bootnodes
    let mut net_conf = cmd.net_conf;
    if !cmd.custom_bootnodes {
        net_conf.boot_nodes = spec.nodes.clone();
    }

    // set network path.
    net_conf.net_config_path = Some(db_dirs.network_path().to_string_lossy().into_owned());
    let sync_params = LightSyncParams {
        network_config: net_conf
            .into_basic()
            .map_err(|e| format!("Failed to produce network config: {}", e))?,
        client: Arc::new(provider),
        network_id: cmd.network_id.unwrap_or(spec.network_id()),
        subprotocol_name: sync::LIGHT_PROTOCOL,
        handlers: vec![on_demand.clone()],
    };
    let light_sync =
        LightSync::new(sync_params).map_err(|e| format!("Error starting network: {}", e))?;
    let light_sync = Arc::new(light_sync);
    *sync_handle.write() = Arc::downgrade(&light_sync);

    // spin up event loop
    let runtime = Runtime::with_default_thread_count();

    // start the network.
    light_sync.start_network();

    // fetch service
    let fetch = fetch::Client::new(FETCH_LIGHT_NUM_DNS_THREADS)
        .map_err(|e| format!("Error starting fetch client: {:?}", e))?;
    let passwords = passwords_from_files(&cmd.acc_conf.password_files)?;

    // prepare account provider
    let account_provider = Arc::new(account_utils::prepare_account_provider(
        &cmd.spec,
        &cmd.dirs,
        &spec.data_dir,
        cmd.acc_conf,
        &passwords,
    )?);
    let rpc_stats = Arc::new(informant::RpcStats::default());

    // the dapps server
    let signer_service = Arc::new(signer::new_service(&cmd.ws_conf, &cmd.logger_config));

    // start RPCs
    let deps_for_rpc_apis = Arc::new(rpc_apis::LightDependencies {
        signer_service: signer_service,
        client: client.clone(),
        sync: light_sync.clone(),
        net: light_sync.clone(),
        accounts: account_provider,
        logger: logger,
        settings: Arc::new(cmd.net_settings),
        on_demand: on_demand,
        cache: cache.clone(),
        transaction_queue: txq,
        ws_address: cmd.ws_conf.address(),
        fetch: fetch,
        experimental_rpcs: cmd.experimental_rpcs,
        executor: runtime.executor(),
        private_tx_service: None, //TODO: add this to client.
        gas_price_percentile: cmd.gas_price_percentile,
        poll_lifetime: cmd.poll_lifetime,
    });

    let dependencies = rpc::Dependencies {
        apis: deps_for_rpc_apis.clone(),
        executor: runtime.executor(),
        stats: rpc_stats.clone(),
    };

    // start rpc servers
    let rpc_direct = rpc::setup_apis(rpc_apis::ApiSet::All, &dependencies);
    let ws_server = rpc::new_ws(cmd.ws_conf, &dependencies)?;
    let http_server = rpc::new_http(
        "HTTP JSON-RPC",
        "jsonrpc",
        cmd.http_conf.clone(),
        &dependencies,
    )?;
    let ipc_server = rpc::new_ipc(cmd.ipc_conf, &dependencies)?;

    // the informant
    let informant = Arc::new(Informant::new(
        LightNodeInformantData {
            client: client.clone(),
            sync: light_sync.clone(),
            cache: cache,
        },
        None,
        Some(rpc_stats),
        cmd.logger_config.color,
    ));
    service.add_notify(informant.clone());
    service
        .register_handler(informant.clone())
        .map_err(|_| "Unable to register informant handler".to_owned())?;

    client.set_exit_handler(on_client_rq);

    Ok(RunningClient {
        inner: RunningClientInner::Light {
            rpc: rpc_direct,
            informant,
            client,
            keep_alive: Box::new((service, ws_server, http_server, ipc_server, runtime)),
        },
    })
}

fn execute_impl<Cr, Rr>(
    cmd: RunCmd,
    logger: Arc<RotatingLogger>,
    on_client_rq: Cr,
    on_updater_rq: Rr,
) -> Result<RunningClient, String>
where
    Cr: Fn(String) + 'static + Send,
    Rr: Fn() + 'static + Send,
{
    // load spec
    let spec = cmd.spec.spec(&cmd.dirs.cache)?;

    // load genesis hash
    let genesis_hash = spec.genesis_header().hash();

    // database paths
    let db_dirs = cmd.dirs.database(
        genesis_hash,
        cmd.spec.legacy_fork_name(),
        spec.data_dir.clone(),
    );

    // user defaults path
    let user_defaults_path = db_dirs.user_defaults_path();

    // load user defaults
    let mut user_defaults = UserDefaults::load(&user_defaults_path)?;

    // select pruning algorithm
    let algorithm = cmd.pruning.to_algorithm(&user_defaults);

    // check if tracing is on
    let tracing = tracing_switch_to_bool(cmd.tracing, &user_defaults)?;

    // check if fatdb is on
    let fat_db = fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm)?;

    // get the mode
    let mode = mode_switch_to_bool(cmd.mode, &user_defaults)?;
    trace!(target: "mode", "mode is {:?}", mode);
    let network_enabled = match mode {
        Mode::Dark(_) | Mode::Off => false,
        _ => true,
    };

    // get the update policy
    let update_policy = cmd.update_policy;

    // prepare client and snapshot paths.
    let client_path = db_dirs.client_path(algorithm);
    let snapshot_path = db_dirs.snapshot_path();

    // execute upgrades
    execute_upgrades(&cmd.dirs.base, &db_dirs, algorithm, &cmd.compaction)?;

    // create dirs used by parity
    cmd.dirs.create_dirs(
        cmd.acc_conf.unlocked_accounts.len() == 0,
        cmd.secretstore_conf.enabled,
    )?;

    //print out running parity environment
    print_running_environment(&spec.data_dir, &cmd.dirs, &db_dirs);

    // display info about used pruning algorithm
    info!(
        "State DB configuration: {}{}{}",
        Colour::White.bold().paint(algorithm.as_str()),
        match fat_db {
            true => Colour::White.bold().paint(" +Fat").to_string(),
            false => "".to_owned(),
        },
        match tracing {
            true => Colour::White.bold().paint(" +Trace").to_string(),
            false => "".to_owned(),
        }
    );
    info!(
        "Operating mode: {}",
        Colour::White.bold().paint(format!("{}", mode))
    );

    // display warning about using experimental journaldb algorithm
    if !algorithm.is_stable() {
        warn!(
            "Your chosen strategy is {}! You can re-run with --pruning to change.",
            Colour::Red.bold().paint("unstable")
        );
    }

    // create sync config
    let mut sync_config = SyncConfig::default();
    sync_config.network_id = match cmd.network_id {
        Some(id) => id,
        None => spec.network_id(),
    };
    if spec.subprotocol_name().len() != 3 {
        warn!("Your chain specification's subprotocol length is not 3. Ignoring.");
    } else {
        sync_config
            .subprotocol_name
            .clone_from_slice(spec.subprotocol_name().as_bytes());
    }

    sync_config.fork_block = spec.fork_block();
    let mut warp_sync = spec.engine.supports_warp() && cmd.warp_sync;
    if warp_sync {
        // Logging is not initialized yet, so we print directly to stderr
        if fat_db {
            warn!("Warning: Warp Sync is disabled because Fat DB is turned on.");
            warp_sync = false;
        } else if tracing {
            warn!("Warning: Warp Sync is disabled because tracing is turned on.");
            warp_sync = false;
        } else if algorithm != Algorithm::OverlayRecent {
            warn!("Warning: Warp Sync is disabled because of non-default pruning mode.");
            warp_sync = false;
        }
    }
    sync_config.warp_sync = match (warp_sync, cmd.warp_barrier) {
        (true, Some(block)) => sync::WarpSync::OnlyAndAfter(block),
        (true, _) => sync::WarpSync::Enabled,
        _ => sync::WarpSync::Disabled,
    };
    sync_config.download_old_blocks = cmd.download_old_blocks;
    sync_config.serve_light = cmd.serve_light;

    let passwords = passwords_from_files(&cmd.acc_conf.password_files)?;

    // prepare account provider
    let account_provider = Arc::new(account_utils::prepare_account_provider(
        &cmd.spec,
        &cmd.dirs,
        &spec.data_dir,
        cmd.acc_conf,
        &passwords,
    )?);

    // spin up event loop
    let runtime = Runtime::with_default_thread_count();

    // fetch service
    let fetch = fetch::Client::new(FETCH_FULL_NUM_DNS_THREADS)
        .map_err(|e| format!("Error starting fetch client: {:?}", e))?;

    let txpool_size = cmd.miner_options.pool_limits.max_count;
    // create miner
    let miner = Arc::new(Miner::new(
        cmd.miner_options,
        cmd.gas_pricer_conf
            .to_gas_pricer(fetch.clone(), runtime.executor()),
        &spec,
        (
            cmd.miner_extras.local_accounts,
            account_utils::miner_local_accounts(account_provider.clone()),
        ),
    ));
    miner.set_author(miner::Author::External(cmd.miner_extras.author));
    miner.set_gas_range_target(cmd.miner_extras.gas_range_target);
    miner.set_extra_data(cmd.miner_extras.extra_data);

    if !cmd.miner_extras.work_notify.is_empty() {
        miner.add_work_listener(Box::new(WorkPoster::new(
            &cmd.miner_extras.work_notify,
            fetch.clone(),
            runtime.executor(),
        )));
    }

    let engine_signer = cmd.miner_extras.engine_signer;
    if engine_signer != Default::default() {
        if let Some(author) = account_utils::miner_author(
            &cmd.spec,
            &cmd.dirs,
            &account_provider,
            engine_signer,
            &passwords,
        )? {
            miner.set_author(author);
        }
    }

    // display warning if using --no-hardcoded-sync
    if cmd.no_hardcoded_sync {
        warn!("The --no-hardcoded-sync flag has no effect if you don't use --light");
    }

    // create client config
    let mut client_config = to_client_config(
        &cmd.cache_config,
        spec.name.to_lowercase(),
        mode.clone(),
        tracing,
        fat_db,
        cmd.compaction,
        cmd.vm_type,
        cmd.name,
        algorithm,
        cmd.pruning_history,
        cmd.pruning_memory,
        cmd.check_seal,
        cmd.max_round_blocks_to_import,
    );

    client_config.queue.verifier_settings = cmd.verifier_settings;
    client_config.transaction_verification_queue_size = ::std::cmp::max(2048, txpool_size / 4);
    client_config.snapshot = cmd.snapshot_conf.clone();

    // set up bootnodes
    let mut net_conf = cmd.net_conf;
    if !cmd.custom_bootnodes {
        net_conf.boot_nodes = spec.nodes.clone();
    }

    // set network path.
    net_conf.net_config_path = Some(db_dirs.network_path().to_string_lossy().into_owned());

    let restoration_db_handler = db::restoration_db_handler(&client_path, &client_config);
    let client_db = restoration_db_handler
        .open(&client_path)
        .map_err(|e| format!("Failed to open database {:?}", e))?;

    let private_tx_signer = account_utils::private_tx_signer(account_provider.clone(), &passwords)?;

    // create client service.
    let service = ClientService::start(
        client_config,
        &spec,
        client_db,
        &snapshot_path,
        restoration_db_handler,
        &cmd.dirs.ipc_path(),
        miner.clone(),
        private_tx_signer.clone(),
        Box::new(
            SecretStoreEncryptor::new(
                cmd.private_encryptor_conf.clone(),
                fetch.clone(),
                private_tx_signer,
            )
            .map_err(|e| e.to_string())?,
        ),
        cmd.private_provider_conf,
        cmd.private_encryptor_conf,
    )
    .map_err(|e| format!("Client service error: {:?}", e))?;

    let connection_filter_address = spec.params().node_permission_contract;
    // drop the spec to free up genesis state.
    drop(spec);

    // take handle to client
    let client = service.client();
    // Update miners block gas limit
    miner.update_transaction_queue_limits(*client.best_block_header().gas_limit());

    // take handle to private transactions service
    let private_tx_service = service.private_tx_service();
    let private_tx_provider = private_tx_service.provider();
    let connection_filter = connection_filter_address.map(|a| {
        Arc::new(NodeFilter::new(
            Arc::downgrade(&client) as Weak<dyn BlockChainClient>,
            a,
        ))
    });
    let snapshot_service = service.snapshot_service();

    // initialize the local node information store.
    let store = {
        let db = service.db();
        let node_info = FullNodeInfo {
            miner: match cmd.no_persistent_txqueue {
                true => None,
                false => Some(miner.clone()),
            },
        };

        let store = ::local_store::create(
            db.key_value().clone(),
            ::ethcore_db::COL_NODE_INFO,
            node_info,
        );

        if cmd.no_persistent_txqueue {
            info!("Running without a persistent transaction queue.");

            if let Err(e) = store.clear() {
                warn!("Error clearing persistent transaction queue: {}", e);
            }
        }

        // re-queue pending transactions.
        match store.pending_transactions() {
            Ok(pending) => {
                for pending_tx in pending {
                    if let Err(e) = miner.import_own_transaction(&*client, pending_tx) {
                        warn!("Error importing saved transaction: {}", e)
                    }
                }
            }
            Err(e) => warn!("Error loading cached pending transactions from disk: {}", e),
        }

        Arc::new(store)
    };

    // register it as an IO service to update periodically.
    service
        .register_io_handler(store)
        .map_err(|_| "Unable to register local store handler".to_owned())?;

    // create external miner
    let external_miner = Arc::new(ExternalMiner::default());

    // start stratum
    if let Some(ref stratum_config) = cmd.stratum {
        stratum::Stratum::register(stratum_config, miner.clone(), Arc::downgrade(&client))
            .map_err(|e| format!("Stratum start error: {:?}", e))?;
    }

    let private_tx_sync: Option<Arc<dyn PrivateTxHandler>> = match cmd.private_tx_enabled {
        true => Some(private_tx_service.clone() as Arc<dyn PrivateTxHandler>),
        false => None,
    };

    // create sync object
    let (sync_provider, manage_network, chain_notify, priority_tasks) = modules::sync(
        sync_config,
        net_conf.clone().into(),
        client.clone(),
        snapshot_service.clone(),
        private_tx_sync,
        client.clone(),
        &cmd.logger_config,
        connection_filter
            .clone()
            .map(|f| f as Arc<dyn crate::sync::ConnectionFilter + 'static>),
    )
    .map_err(|e| format!("Sync error: {}", e))?;

    service.add_notify(chain_notify.clone());

    // Propagate transactions as soon as they are imported.
    let tx = ::parking_lot::Mutex::new(priority_tasks);
    let is_ready = Arc::new(atomic::AtomicBool::new(true));
    miner.add_transactions_listener(Box::new(move |_hashes| {
        // we want to have only one PendingTransactions task in the queue.
        if is_ready.compare_and_swap(true, false, atomic::Ordering::SeqCst) {
            let task =
                ::sync::PriorityTask::PropagateTransactions(Instant::now(), is_ready.clone());
            // we ignore error cause it means that we are closing
            let _ = tx.lock().send(task);
        }
    }));

    // provider not added to a notification center is effectively disabled
    // TODO [debris] refactor it later on
    if cmd.private_tx_enabled {
        service.add_notify(private_tx_provider.clone());
        // TODO [ToDr] PrivateTX should use separate notifications
        // re-using ChainNotify for this is a bit abusive.
        private_tx_provider.add_notify(chain_notify.clone());
    }

    // start network
    if network_enabled {
        chain_notify.start();
    }

    let contract_client = {
        struct FullRegistrar {
            client: Arc<Client>,
        }
        impl RegistrarClient for FullRegistrar {
            type Call = Asynchronous;
            fn registrar_address(&self) -> Result<Address, String> {
                self.client
                    .registrar_address()
                    .ok_or_else(|| "Registrar not defined.".into())
            }
            fn call_contract(&self, address: Address, data: Bytes) -> Self::Call {
                Box::new(
                    self.client
                        .call_contract(BlockId::Latest, address, data)
                        .into_future(),
                )
            }
        }

        Arc::new(FullRegistrar {
            client: client.clone(),
        })
    };

    // the updater service
    let updater_fetch = fetch.clone();
    let updater = Updater::new(
        &Arc::downgrade(&(service.client() as Arc<dyn BlockChainClient>)),
        &Arc::downgrade(&sync_provider),
        update_policy,
        hash_fetch::Client::with_fetch(contract_client.clone(), updater_fetch, runtime.executor()),
    );
    service.add_notify(updater.clone());

    // set up dependencies for rpc servers
    let rpc_stats = Arc::new(informant::RpcStats::default());
    let secret_store = account_provider.clone();
    let signer_service = Arc::new(signer::new_service(&cmd.ws_conf, &cmd.logger_config));

    let deps_for_rpc_apis = Arc::new(rpc_apis::FullDependencies {
        signer_service: signer_service,
        snapshot: snapshot_service.clone(),
        client: client.clone(),
        sync: sync_provider.clone(),
        net: manage_network.clone(),
        accounts: secret_store,
        miner: miner.clone(),
        external_miner: external_miner.clone(),
        logger: logger.clone(),
        settings: Arc::new(cmd.net_settings.clone()),
        net_service: manage_network.clone(),
        updater: updater.clone(),
        experimental_rpcs: cmd.experimental_rpcs,
        ws_address: cmd.ws_conf.address(),
        fetch: fetch.clone(),
        executor: runtime.executor(),
        private_tx_service: Some(private_tx_service.clone()),
        gas_price_percentile: cmd.gas_price_percentile,
        poll_lifetime: cmd.poll_lifetime,
        allow_missing_blocks: cmd.allow_missing_blocks,
        no_ancient_blocks: !cmd.download_old_blocks,
    });

    let dependencies = rpc::Dependencies {
        apis: deps_for_rpc_apis.clone(),
        executor: runtime.executor(),
        stats: rpc_stats.clone(),
    };

    // start rpc servers
    let rpc_direct = rpc::setup_apis(rpc_apis::ApiSet::All, &dependencies);
    let ws_server = rpc::new_ws(cmd.ws_conf.clone(), &dependencies)?;
    let ipc_server = rpc::new_ipc(cmd.ipc_conf, &dependencies)?;
    let http_server = rpc::new_http(
        "HTTP JSON-RPC",
        "jsonrpc",
        cmd.http_conf.clone(),
        &dependencies,
    )?;

    // secret store key server
    let secretstore_deps = secretstore::Dependencies {
        client: client.clone(),
        sync: sync_provider.clone(),
        miner: miner.clone(),
        account_provider,
        accounts_passwords: &passwords,
    };
    let secretstore_key_server = secretstore::start(
        cmd.secretstore_conf.clone(),
        secretstore_deps,
        runtime.executor(),
    )?;

    // the ipfs server
    let ipfs_server = ipfs::start_server(cmd.ipfs_conf.clone(), client.clone())?;

    // the informant
    let informant = Arc::new(Informant::new(
        FullNodeInformantData {
            client: service.client(),
            sync: Some(sync_provider.clone()),
            net: Some(manage_network.clone()),
        },
        Some(snapshot_service.clone()),
        Some(rpc_stats.clone()),
        cmd.logger_config.color,
    ));
    service.add_notify(informant.clone());
    service
        .register_io_handler(informant.clone())
        .map_err(|_| "Unable to register informant handler".to_owned())?;

    // save user defaults
    user_defaults.is_first_launch = false;
    user_defaults.pruning = algorithm;
    user_defaults.tracing = tracing;
    user_defaults.fat_db = fat_db;
    user_defaults.set_mode(mode);
    user_defaults.save(&user_defaults_path)?;

    // tell client how to save the default mode if it gets changed.
    client.on_user_defaults_change(move |mode: Option<Mode>| {
        if let Some(mode) = mode {
            user_defaults.set_mode(mode);
        }
        let _ = user_defaults.save(&user_defaults_path); // discard failures - there's nothing we can do
    });

    // the watcher must be kept alive.
    let watcher = match cmd.snapshot_conf.no_periodic {
        true => None,
        false => {
            let sync = sync_provider.clone();
            let client = client.clone();
            let watcher = Arc::new(snapshot::Watcher::new(
                service.client(),
                move || is_major_importing(Some(sync.status().state), client.queue_info()),
                service.io().channel(),
                SNAPSHOT_PERIOD,
                SNAPSHOT_HISTORY,
            ));

            service.add_notify(watcher.clone());
            Some(watcher)
        }
    };

    client.set_exit_handler(on_client_rq);
    updater.set_exit_handler(on_updater_rq);

    Ok(RunningClient {
        inner: RunningClientInner::Full {
            rpc: rpc_direct,
            informant,
            client,
            client_service: Arc::new(service),
            keep_alive: Box::new((
                watcher,
                updater,
                ws_server,
                http_server,
                ipc_server,
                secretstore_key_server,
                ipfs_server,
                runtime,
            )),
        },
    })
}

/// Parity client currently executing in background threads.
///
/// Should be destroyed by calling `shutdown()`, otherwise execution will continue in the
/// background.
pub struct RunningClient {
    inner: RunningClientInner,
}

enum RunningClientInner {
    Light {
        rpc: jsonrpc_core::MetaIoHandler<
            Metadata,
            informant::Middleware<rpc_apis::LightClientNotifier>,
        >,
        informant: Arc<Informant<LightNodeInformantData>>,
        client: Arc<LightClient>,
        keep_alive: Box<dyn Any>,
    },
    Full {
        rpc:
            jsonrpc_core::MetaIoHandler<Metadata, informant::Middleware<informant::ClientNotifier>>,
        informant: Arc<Informant<FullNodeInformantData>>,
        client: Arc<Client>,
        client_service: Arc<ClientService>,
        keep_alive: Box<dyn Any>,
    },
}

impl RunningClient {
    /// Performs an asynchronous RPC query.
    // FIXME: [tomaka] This API should be better, with for example a Future
    pub fn rpc_query(
        &self,
        request: &str,
        session: Option<Arc<PubSubSession>>,
    ) -> FutureResult<FutureResponse, FutureOutput> {
        let metadata = Metadata {
            origin: Origin::CApi,
            session,
        };

        match self.inner {
            RunningClientInner::Light { ref rpc, .. } => rpc.handle_request(request, metadata),
            RunningClientInner::Full { ref rpc, .. } => rpc.handle_request(request, metadata),
        }
    }

    /// Shuts down the client.
    pub fn shutdown(self) {
        match self.inner {
            RunningClientInner::Light {
                rpc,
                informant,
                client,
                keep_alive,
            } => {
                // Create a weak reference to the client so that we can wait on shutdown
                // until it is dropped
                let weak_client = Arc::downgrade(&client);
                drop(rpc);
                drop(keep_alive);
                informant.shutdown();
                drop(informant);
                drop(client);
                wait_for_drop(weak_client);
            }
            RunningClientInner::Full {
                rpc,
                informant,
                client,
                client_service,
                keep_alive,
            } => {
                info!("Finishing work, please wait...");
                // Create a weak reference to the client so that we can wait on shutdown
                // until it is dropped
                let weak_client = Arc::downgrade(&client);
                // Shutdown and drop the ClientService
                client_service.shutdown();
                trace!(target: "shutdown", "ClientService shut down");
                drop(client_service);
                trace!(target: "shutdown", "ClientService dropped");
                // drop this stuff as soon as exit detected.
                drop(rpc);
                trace!(target: "shutdown", "RPC dropped");
                drop(keep_alive);
                trace!(target: "shutdown", "KeepAlive dropped");
                // to make sure timer does not spawn requests while shutdown is in progress
                informant.shutdown();
                trace!(target: "shutdown", "Informant shut down");
                // just Arc is dropping here, to allow other reference release in its default time
                drop(informant);
                trace!(target: "shutdown", "Informant dropped");
                drop(client);
                trace!(target: "shutdown", "Client dropped");
                // This may help when debugging ref cycles. Requires nightly-only  `#![feature(weak_counts)]`
                // trace!(target: "shutdown", "Waiting for refs to Client to shutdown, strong_count={:?}, weak_count={:?}", weak_client.strong_count(), weak_client.weak_count());
                trace!(target: "shutdown", "Waiting for refs to Client to shutdown");
                wait_for_drop(weak_client);
            }
        }
    }
}

/// Executes the given run command.
///
/// `on_client_rq` is the action to perform when the client receives an RPC request to be restarted
/// with a different chain.
///
/// `on_updater_rq` is the action to perform when the updater has a new binary to execute.
///
/// On error, returns what to print on stderr.
pub fn execute<Cr, Rr>(
    cmd: RunCmd,
    logger: Arc<RotatingLogger>,
    on_client_rq: Cr,
    on_updater_rq: Rr,
) -> Result<RunningClient, String>
where
    Cr: Fn(String) + 'static + Send,
    Rr: Fn() + 'static + Send,
{
    if cmd.light {
        execute_light_impl(cmd, logger, on_client_rq)
    } else {
        execute_impl(cmd, logger, on_client_rq, on_updater_rq)
    }
}

fn print_running_environment(data_dir: &str, dirs: &Directories, db_dirs: &DatabaseDirectories) {
    info!("Starting {}", Colour::White.bold().paint(version()));
    info!(
        "Keys path {}",
        Colour::White
            .bold()
            .paint(dirs.keys_path(data_dir).to_string_lossy().into_owned())
    );
    info!(
        "DB path {}",
        Colour::White
            .bold()
            .paint(db_dirs.db_root_path().to_string_lossy().into_owned())
    );
}

fn wait_for_drop<T>(w: Weak<T>) {
    const SLEEP_DURATION: Duration = Duration::from_secs(1);
    const WARN_TIMEOUT: Duration = Duration::from_secs(60);
    const MAX_TIMEOUT: Duration = Duration::from_secs(300);

    let instant = Instant::now();
    let mut warned = false;

    while instant.elapsed() < MAX_TIMEOUT {
        if w.upgrade().is_none() {
            return;
        }

        if !warned && instant.elapsed() > WARN_TIMEOUT {
            warned = true;
            warn!("Shutdown is taking longer than expected.");
        }

        thread::sleep(SLEEP_DURATION);

        // When debugging shutdown issues on a nightly build it can help to enable this with the
        // `#![feature(weak_counts)]` added to lib.rs (TODO: enable when
        // https://github.com/rust-lang/rust/issues/57977 is stable)
        // trace!(target: "shutdown", "Waiting for client to drop, strong_count={:?}, weak_count={:?}", w.strong_count(), w.weak_count());
        trace!(target: "shutdown", "Waiting for client to drop");
    }

    warn!("Shutdown timeout reached, exiting uncleanly.");
}