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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

// Copyright 2015-2018 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/>.

use std::str::FromStr;
use std::fmt::{Display, Formatter, Error as FmtError};

use verification::{VerifierType, QueueConfig};
use journaldb;

pub use std::time::Duration;
pub use blockchain::Config as BlockChainConfig;
pub use trace::Config as TraceConfig;
pub use evm::VMType;

/// Client state db compaction profile
#[derive(Debug, PartialEq, Clone)]
pub enum DatabaseCompactionProfile {
	/// Try to determine compaction profile automatically
	Auto,
	/// SSD compaction profile
	SSD,
	/// HDD or other slow storage io compaction profile
	HDD,
}

impl Default for DatabaseCompactionProfile {
	fn default() -> Self {
		DatabaseCompactionProfile::Auto
	}
}

impl FromStr for DatabaseCompactionProfile {
	type Err = String;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
		match s {
			"auto" => Ok(DatabaseCompactionProfile::Auto),
			"ssd" => Ok(DatabaseCompactionProfile::SSD),
			"hdd" => Ok(DatabaseCompactionProfile::HDD),
			_ => Err("Invalid compaction profile given. Expected default/hdd/ssd.".into()),
		}
	}
}

/// Operating mode for the client.
#[derive(Debug, Eq, PartialEq, Clone)]
pub enum Mode {
	/// Always on.
	Active,
	/// Goes offline after client is inactive for some (given) time, but
	/// comes back online after a while of inactivity.
	Passive(Duration, Duration),
	/// Goes offline after client is inactive for some (given) time and
	/// stays inactive.
	Dark(Duration),
	/// Always off.
	Off,
}

impl Display for Mode {
	fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
		match *self {
			Mode::Active => write!(f, "active"),
			Mode::Passive(..) => write!(f, "passive"),
			Mode::Dark(..) => write!(f, "dark"),
			Mode::Off => write!(f, "offline"),
		}
	}
}

/// Client configuration. Includes configs for all sub-systems.
#[derive(Debug, PartialEq, Clone)]
pub struct ClientConfig {
	/// Block queue configuration.
	pub queue: QueueConfig,
	/// Blockchain configuration.
	pub blockchain: BlockChainConfig,
	/// Trace configuration.
	pub tracing: TraceConfig,
	/// VM type.
	pub vm_type: VMType,
	/// Fat DB enabled?
	pub fat_db: bool,
	/// The JournalDB ("pruning") algorithm to use.
	pub pruning: journaldb::Algorithm,
	/// The name of the client instance.
	pub name: String,
	/// RocksDB column cache-size if not default
	pub db_cache_size: Option<usize>,
	/// State db compaction profile
	pub db_compaction: DatabaseCompactionProfile,
	/// Operating mode
	pub mode: Mode,
	/// The chain spec name
	pub spec_name: String,
	/// Type of block verifier used by client.
	pub verifier_type: VerifierType,
	/// State db cache-size.
	pub state_cache_size: usize,
	/// EVM jump-tables cache size.
	pub jump_table_size: usize,
	/// Minimum state pruning history size.
	pub history: u64,
	/// Ideal memory usage for state pruning history.
	pub history_mem: usize,
	/// Check seal valididity on block import
	pub check_seal: bool,
	/// Maximal number of transactions queued for verification in a separate thread.
	pub transaction_verification_queue_size: usize,
}

impl Default for ClientConfig {
	fn default() -> Self {
		let mb = 1024 * 1024;
		ClientConfig {
			queue: Default::default(),
			blockchain: Default::default(),
			tracing: Default::default(),
			vm_type: Default::default(),
			fat_db: false,
			pruning: journaldb::Algorithm::OverlayRecent,
			name: "default".into(),
			db_cache_size: None,
			db_compaction: Default::default(),
			mode: Mode::Active,
			spec_name: "".into(),
			verifier_type: VerifierType::Canon,
			state_cache_size: 1 * mb,
			jump_table_size: 1 * mb,
			history: 64,
			history_mem: 32 * mb,
			check_seal: true,
			transaction_verification_queue_size: 8192,
		}
	}
}
#[cfg(test)]
mod test {
	use super::DatabaseCompactionProfile;

	#[test]
	fn test_default_compaction_profile() {
		assert_eq!(DatabaseCompactionProfile::default(), DatabaseCompactionProfile::Auto);
	}

	#[test]
	fn test_parsing_compaction_profile() {
		assert_eq!(DatabaseCompactionProfile::Auto, "auto".parse().unwrap());
		assert_eq!(DatabaseCompactionProfile::SSD, "ssd".parse().unwrap());
		assert_eq!(DatabaseCompactionProfile::HDD, "hdd".parse().unwrap());
	}
}