2016-01-09 18:50:45 +01:00
|
|
|
use util::*;
|
2016-01-14 01:28:37 +01:00
|
|
|
use rocksdb::{DB};
|
2016-01-12 13:14:01 +01:00
|
|
|
use blockchain::{BlockChain, BlockProvider};
|
2016-01-07 21:35:06 +01:00
|
|
|
use views::BlockView;
|
2016-01-11 12:28:59 +01:00
|
|
|
use error::*;
|
2016-01-11 01:07:58 +01:00
|
|
|
use header::BlockNumber;
|
2016-01-11 12:28:59 +01:00
|
|
|
use spec::Spec;
|
2016-01-11 11:51:31 +01:00
|
|
|
use engine::Engine;
|
2016-01-11 13:42:32 +01:00
|
|
|
use queue::BlockQueue;
|
2016-01-13 23:15:44 +01:00
|
|
|
use sync::NetSyncMessage;
|
2016-01-14 01:28:37 +01:00
|
|
|
use env_info::LastHashes;
|
|
|
|
use verification::*;
|
|
|
|
use block::*;
|
2016-01-07 21:35:06 +01:00
|
|
|
|
|
|
|
/// General block status
|
|
|
|
pub enum BlockStatus {
|
|
|
|
/// Part of the blockchain.
|
|
|
|
InChain,
|
|
|
|
/// Queued for import.
|
2016-01-10 23:37:09 +01:00
|
|
|
Queued,
|
2016-01-07 21:35:06 +01:00
|
|
|
/// Known as bad.
|
|
|
|
Bad,
|
|
|
|
/// Unknown.
|
|
|
|
Unknown,
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Information about the blockchain gthered together.
|
|
|
|
pub struct BlockChainInfo {
|
|
|
|
/// Blockchain difficulty.
|
|
|
|
pub total_difficulty: U256,
|
|
|
|
/// Block queue difficulty.
|
|
|
|
pub pending_total_difficulty: U256,
|
|
|
|
/// Genesis block hash.
|
|
|
|
pub genesis_hash: H256,
|
|
|
|
/// Best blockchain block hash.
|
|
|
|
pub best_block_hash: H256,
|
|
|
|
/// Best blockchain block number.
|
|
|
|
pub best_block_number: BlockNumber
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Block queue status
|
|
|
|
pub struct BlockQueueStatus {
|
|
|
|
pub full: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub type TreeRoute = ::blockchain::TreeRoute;
|
|
|
|
|
|
|
|
/// Blockchain database client. Owns and manages a blockchain and a block queue.
|
2016-01-14 19:03:48 +01:00
|
|
|
pub trait BlockChainClient : Sync + Send {
|
2016-01-07 21:35:06 +01:00
|
|
|
/// Get raw block header data by block header hash.
|
|
|
|
fn block_header(&self, hash: &H256) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Get raw block body data by block header hash.
|
|
|
|
/// Block body is an RLP list of two items: uncles and transactions.
|
|
|
|
fn block_body(&self, hash: &H256) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Get raw block data by block header hash.
|
|
|
|
fn block(&self, hash: &H256) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Get block status by block header hash.
|
|
|
|
fn block_status(&self, hash: &H256) -> BlockStatus;
|
|
|
|
|
|
|
|
/// Get raw block header data by block number.
|
|
|
|
fn block_header_at(&self, n: BlockNumber) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Get raw block body data by block number.
|
|
|
|
/// Block body is an RLP list of two items: uncles and transactions.
|
|
|
|
fn block_body_at(&self, n: BlockNumber) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Get raw block data by block number.
|
|
|
|
fn block_at(&self, n: BlockNumber) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Get block status by block number.
|
|
|
|
fn block_status_at(&self, n: BlockNumber) -> BlockStatus;
|
|
|
|
|
|
|
|
/// Get a tree route between `from` and `to`.
|
|
|
|
/// See `BlockChain::tree_route`.
|
2016-01-10 23:37:09 +01:00
|
|
|
fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute>;
|
2016-01-07 21:35:06 +01:00
|
|
|
|
|
|
|
/// Get latest state node
|
|
|
|
fn state_data(&self, hash: &H256) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Get raw block receipts data by block header hash.
|
|
|
|
fn block_receipts(&self, hash: &H256) -> Option<Bytes>;
|
|
|
|
|
|
|
|
/// Import a block into the blockchain.
|
|
|
|
fn import_block(&mut self, byte: &[u8]) -> ImportResult;
|
|
|
|
|
|
|
|
/// Get block queue information.
|
|
|
|
fn queue_status(&self) -> BlockQueueStatus;
|
|
|
|
|
2016-01-09 10:16:35 +01:00
|
|
|
/// Clear block queue and abort all import activity.
|
2016-01-07 21:35:06 +01:00
|
|
|
fn clear_queue(&mut self);
|
|
|
|
|
|
|
|
/// Get blockchain information.
|
|
|
|
fn chain_info(&self) -> BlockChainInfo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Blockchain database client backed by a persistent database. Owns and manages a blockchain and a block queue.
|
|
|
|
pub struct Client {
|
2016-01-11 13:42:32 +01:00
|
|
|
chain: Arc<RwLock<BlockChain>>,
|
2016-01-14 01:28:37 +01:00
|
|
|
engine: Arc<Box<Engine>>,
|
|
|
|
state_db: OverlayDB,
|
2016-01-11 13:42:32 +01:00
|
|
|
queue: BlockQueue,
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Client {
|
2016-01-15 01:03:29 +01:00
|
|
|
/// Create a new client with given spec and DB path.
|
2016-01-13 23:15:44 +01:00
|
|
|
pub fn new(spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Result<Client, Error> {
|
2016-01-11 13:42:32 +01:00
|
|
|
let chain = Arc::new(RwLock::new(BlockChain::new(&spec.genesis_block(), path)));
|
2016-01-11 12:28:59 +01:00
|
|
|
let engine = Arc::new(try!(spec.to_engine()));
|
2016-01-14 01:28:37 +01:00
|
|
|
let mut state_path = path.to_path_buf();
|
|
|
|
state_path.push("state");
|
|
|
|
let db = DB::open_default(state_path.to_str().unwrap()).unwrap();
|
2016-01-14 19:03:48 +01:00
|
|
|
let mut state_db = OverlayDB::new(db);
|
|
|
|
engine.spec().ensure_db_good(&mut state_db);
|
2016-01-14 22:38:49 +01:00
|
|
|
state_db.commit().expect("Error commiting genesis state to state DB");
|
2016-01-14 01:28:37 +01:00
|
|
|
|
2016-01-11 12:28:59 +01:00
|
|
|
Ok(Client {
|
2016-01-09 10:16:35 +01:00
|
|
|
chain: chain.clone(),
|
2016-01-14 01:28:37 +01:00
|
|
|
engine: engine.clone(),
|
2016-01-14 19:03:48 +01:00
|
|
|
state_db: state_db,
|
2016-01-14 01:28:37 +01:00
|
|
|
queue: BlockQueue::new(engine.clone(), message_channel),
|
2016-01-11 12:28:59 +01:00
|
|
|
})
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
2016-01-13 23:15:44 +01:00
|
|
|
|
2016-01-15 01:03:29 +01:00
|
|
|
/// This is triggered by a message coming from a block queue when the block is ready for insertion
|
2016-01-13 23:15:44 +01:00
|
|
|
pub fn import_verified_block(&mut self, bytes: Bytes) {
|
2016-01-14 01:28:37 +01:00
|
|
|
let block = BlockView::new(&bytes);
|
2016-01-14 19:03:48 +01:00
|
|
|
let header = block.header();
|
|
|
|
if let Err(e) = verify_block_family(&bytes, self.engine.deref().deref(), self.chain.read().unwrap().deref()) {
|
|
|
|
warn!(target: "client", "Stage 3 block verification failed for {}\nError: {:?}", header.hash(), e);
|
2016-01-14 01:28:37 +01:00
|
|
|
// TODO: mark as bad
|
|
|
|
return;
|
|
|
|
};
|
2016-01-14 19:03:48 +01:00
|
|
|
let parent = match self.chain.read().unwrap().block_header(&header.parent_hash) {
|
2016-01-14 01:28:37 +01:00
|
|
|
Some(p) => p,
|
|
|
|
None => {
|
2016-01-14 19:03:48 +01:00
|
|
|
warn!(target: "client", "Block import failed for {}: Parent not found ({}) ", header.hash(), header.parent_hash);
|
2016-01-14 01:28:37 +01:00
|
|
|
return;
|
|
|
|
},
|
|
|
|
};
|
|
|
|
// build last hashes
|
|
|
|
let mut last = self.chain.read().unwrap().best_block_hash();
|
|
|
|
let mut last_hashes = LastHashes::new();
|
|
|
|
last_hashes.resize(256, H256::new());
|
|
|
|
for i in 0..255 {
|
|
|
|
match self.chain.read().unwrap().block_details(&last) {
|
|
|
|
Some(details) => {
|
|
|
|
last_hashes[i + 1] = details.parent.clone();
|
|
|
|
last = details.parent.clone();
|
|
|
|
},
|
|
|
|
None => break,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-14 19:03:48 +01:00
|
|
|
let result = match enact(&bytes, self.engine.deref().deref(), self.state_db.clone(), &parent, &last_hashes) {
|
|
|
|
Ok(b) => b,
|
|
|
|
Err(e) => {
|
|
|
|
warn!(target: "client", "Block import failed for {}\nError: {:?}", header.hash(), e);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
if let Err(e) = verify_block_final(&header, result.block().header()) {
|
|
|
|
warn!(target: "client", "Stage 4 block verification failed for {}\nError: {:?}", header.hash(), e);
|
2016-01-14 22:38:49 +01:00
|
|
|
return;
|
2016-01-14 19:03:48 +01:00
|
|
|
}
|
2016-01-14 01:28:37 +01:00
|
|
|
|
2016-01-14 19:03:48 +01:00
|
|
|
self.chain.write().unwrap().insert_block(&bytes); //TODO: err here?
|
|
|
|
match result.drain().commit() {
|
|
|
|
Ok(_) => (),
|
|
|
|
Err(e) => {
|
|
|
|
warn!(target: "client", "State DB commit failed: {:?}", e);
|
2016-01-14 01:28:37 +01:00
|
|
|
return;
|
2016-01-14 19:03:48 +01:00
|
|
|
}
|
2016-01-14 01:28:37 +01:00
|
|
|
}
|
2016-01-15 01:03:29 +01:00
|
|
|
info!(target: "client", "Imported #{} ({})", header.number(), header.hash());
|
2016-01-13 23:15:44 +01:00
|
|
|
}
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
impl BlockChainClient for Client {
|
|
|
|
fn block_header(&self, hash: &H256) -> Option<Bytes> {
|
2016-01-11 13:42:32 +01:00
|
|
|
self.chain.read().unwrap().block(hash).map(|bytes| BlockView::new(&bytes).rlp().at(0).as_raw().to_vec())
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn block_body(&self, hash: &H256) -> Option<Bytes> {
|
2016-01-11 13:42:32 +01:00
|
|
|
self.chain.read().unwrap().block(hash).map(|bytes| {
|
2016-01-07 21:35:06 +01:00
|
|
|
let rlp = Rlp::new(&bytes);
|
|
|
|
let mut body = RlpStream::new();
|
2016-01-08 16:00:32 +01:00
|
|
|
body.append_raw(rlp.at(1).as_raw(), 1);
|
|
|
|
body.append_raw(rlp.at(2).as_raw(), 1);
|
2016-01-07 21:35:06 +01:00
|
|
|
body.out()
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
fn block(&self, hash: &H256) -> Option<Bytes> {
|
2016-01-11 13:42:32 +01:00
|
|
|
self.chain.read().unwrap().block(hash)
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn block_status(&self, hash: &H256) -> BlockStatus {
|
2016-01-11 13:42:32 +01:00
|
|
|
if self.chain.read().unwrap().is_known(&hash) { BlockStatus::InChain } else { BlockStatus::Unknown }
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn block_header_at(&self, n: BlockNumber) -> Option<Bytes> {
|
2016-01-11 13:42:32 +01:00
|
|
|
self.chain.read().unwrap().block_hash(n).and_then(|h| self.block_header(&h))
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn block_body_at(&self, n: BlockNumber) -> Option<Bytes> {
|
2016-01-11 13:42:32 +01:00
|
|
|
self.chain.read().unwrap().block_hash(n).and_then(|h| self.block_body(&h))
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn block_at(&self, n: BlockNumber) -> Option<Bytes> {
|
2016-01-11 13:42:32 +01:00
|
|
|
self.chain.read().unwrap().block_hash(n).and_then(|h| self.block(&h))
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn block_status_at(&self, n: BlockNumber) -> BlockStatus {
|
2016-01-11 13:42:32 +01:00
|
|
|
match self.chain.read().unwrap().block_hash(n) {
|
2016-01-07 21:35:06 +01:00
|
|
|
Some(h) => self.block_status(&h),
|
|
|
|
None => BlockStatus::Unknown
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-10 23:37:09 +01:00
|
|
|
fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute> {
|
2016-01-11 13:42:32 +01:00
|
|
|
self.chain.read().unwrap().tree_route(from.clone(), to.clone())
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn state_data(&self, _hash: &H256) -> Option<Bytes> {
|
|
|
|
unimplemented!();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn block_receipts(&self, _hash: &H256) -> Option<Bytes> {
|
|
|
|
unimplemented!();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn import_block(&mut self, bytes: &[u8]) -> ImportResult {
|
2016-01-14 01:28:37 +01:00
|
|
|
let header = BlockView::new(bytes).header();
|
|
|
|
if self.chain.read().unwrap().is_known(&header.hash()) {
|
|
|
|
return Err(ImportError::AlreadyInChain);
|
|
|
|
}
|
2016-01-11 13:42:32 +01:00
|
|
|
self.queue.import_block(bytes)
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn queue_status(&self) -> BlockQueueStatus {
|
|
|
|
BlockQueueStatus {
|
|
|
|
full: false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn clear_queue(&mut self) {
|
|
|
|
}
|
|
|
|
|
|
|
|
fn chain_info(&self) -> BlockChainInfo {
|
2016-01-11 13:42:32 +01:00
|
|
|
let chain = self.chain.read().unwrap();
|
2016-01-07 21:35:06 +01:00
|
|
|
BlockChainInfo {
|
2016-01-11 13:42:32 +01:00
|
|
|
total_difficulty: chain.best_block_total_difficulty(),
|
|
|
|
pending_total_difficulty: chain.best_block_total_difficulty(),
|
|
|
|
genesis_hash: chain.genesis_hash(),
|
|
|
|
best_block_hash: chain.best_block_hash(),
|
|
|
|
best_block_number: From::from(chain.best_block_number())
|
2016-01-07 21:35:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|