Reorganising the repository - external renames and moves (#4074)

* Adding first rough ouline of the repository structure * Remove old CI stuff * add title * formatting fixes * move node-exits job's script to scripts dir * Move docs into subdir * move to bin * move maintainence scripts, configs and helpers into its own dir * add .local to ignore * move core->client * start up 'test' area * move test client * move test runtime * make test move compile * Add dependencies rule enforcement. * Fix indexing. * Update docs to reflect latest changes * Moving /srml->/paint * update docs * move client/sr-* -> primitives/ * clean old readme * remove old broken code in rhd * update lock * Step 1. * starting to untangle client * Fix after merge. * start splitting out client interfaces * move children and blockchain interfaces * Move trie and state-machine to primitives. * Fix WASM builds. * fixing broken imports * more interface moves * move backend and light to interfaces * move CallExecutor * move cli off client * moving around more interfaces * re-add consensus crates into the mix * fix subkey path * relieve client from executor * starting to pull out client from grandpa * move is_decendent_of out of client * grandpa still depends on client directly * lemme tests pass * rename srml->paint * Make it compile. * rename interfaces->client-api * Move keyring to primitives. * fixup libp2p dep * fix broken use * allow dependency enforcement to fail * move fork-tree * Moving wasm-builder * make env * move build-script-utils * fixup broken crate depdencies and names * fix imports for authority discovery * fix typo * update cargo.lock * fixing imports * Fix paths and add missing crates * re-add missing crates
2026-06-19 05:21:03 +00:00 · 2019-11-14 21:51:17 +01:00
parent becc3b0a4f
commit 60e5011c72
809 changed files with 7801 additions and 6464 deletions
@@ -0,0 +1,232 @@
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Chain utilities.
+
+use crate::error;
+use chain_spec::{ChainSpec, RuntimeGenesis, Extension};
+
+/// Defines the logic for an operation exporting blocks within a range.
+#[macro_export]
+/// Export blocks
+macro_rules! export_blocks {
+($client:ident, $exit:ident, $output:ident, $from:ident, $to:ident, $json:ident) => {{
+	let mut block = $from;
+
+	let last = match $to {
+		Some(v) if v.is_zero() => One::one(),
+		Some(v) => v,
+		None => $client.info().chain.best_number,
+	};
+
+	if last < block {
+		return Err("Invalid block range specified".into());
+	}
+
+	let (exit_send, exit_recv) = std::sync::mpsc::channel();
+	std::thread::spawn(move || {
+		let _ = $exit.wait();
+		let _ = exit_send.send(());
+	});
+	info!("Exporting blocks from #{} to #{}", block, last);
+	if !$json {
+		let last_: u64 = last.saturated_into::<u64>();
+		let block_: u64 = block.saturated_into::<u64>();
+		let len: u64 = last_ - block_ + 1;
+		$output.write_all(&len.encode())?;
+	}
+
+	loop {
+		if exit_recv.try_recv().is_ok() {
+			break;
+		}
+		match $client.block(&BlockId::number(block))? {
+			Some(block) => {
+				if $json {
+					serde_json::to_writer(&mut $output, &block)
+						.map_err(|e| format!("Error writing JSON: {}", e))?;
+				} else {
+					$output.write_all(&block.encode())?;
+				}
+			},
+			None => break,
+		}
+		if (block % 10000.into()).is_zero() {
+			info!("#{}", block);
+		}
+		if block == last {
+			break;
+		}
+		block += One::one();
+	}
+	Ok(())
+}}
+}
+
+/// Defines the logic for an operation importing blocks from some known import.
+#[macro_export]
+/// Import blocks
+macro_rules! import_blocks {
+($block:ty, $client:ident, $queue:ident, $exit:ident, $input:ident) => {{
+	use consensus_common::import_queue::{IncomingBlock, Link, BlockImportError, BlockImportResult};
+	use consensus_common::BlockOrigin;
+	use network::message;
+	use sr_primitives::generic::SignedBlock;
+	use sr_primitives::traits::Block;
+	use futures03::TryFutureExt as _;
+
+	struct WaitLink {
+		imported_blocks: u64,
+		has_error: bool,
+	}
+
+	impl WaitLink {
+		fn new() -> WaitLink {
+			WaitLink {
+				imported_blocks: 0,
+				has_error: false,
+			}
+		}
+	}
+
+	impl<B: Block> Link<B> for WaitLink {
+		fn blocks_processed(
+			&mut self,
+			imported: usize,
+			_count: usize,
+			results: Vec<(Result<BlockImportResult<NumberFor<B>>, BlockImportError>, B::Hash)>
+		) {
+			self.imported_blocks += imported as u64;
+
+			for result in results {
+				if let (Err(err), hash) = result {
+					warn!("There was an error importing block with hash {:?}: {:?}", hash, err);
+					self.has_error = true;
+					break;
+				}
+			}
+		}
+	}
+
+	let (exit_send, exit_recv) = std::sync::mpsc::channel();
+	std::thread::spawn(move || {
+		let _ = $exit.wait();
+		let _ = exit_send.send(());
+	});
+
+	let mut io_reader_input = IoReader($input);
+	let count: u64 = Decode::decode(&mut io_reader_input)
+		.map_err(|e| format!("Error reading file: {}", e))?;
+	info!("Importing {} blocks", count);
+	let mut block_count = 0;
+	for b in 0 .. count {
+		if exit_recv.try_recv().is_ok() {
+			break;
+		}
+		match SignedBlock::<$block>::decode(&mut io_reader_input) {
+			Ok(signed) => {
+				let (header, extrinsics) = signed.block.deconstruct();
+				let hash = header.hash();
+				let block  = message::BlockData::<$block> {
+					hash,
+					justification: signed.justification,
+					header: Some(header),
+					body: Some(extrinsics),
+					receipt: None,
+					message_queue: None
+				};
+				// import queue handles verification and importing it into the client
+				$queue.import_blocks(BlockOrigin::File, vec![
+					IncomingBlock::<$block> {
+						hash: block.hash,
+						header: block.header,
+						body: block.body,
+						justification: block.justification,
+						origin: None,
+						allow_missing_state: false,
+					}
+				]);
+			}
+			Err(e) => {
+				warn!("Error reading block data at {}: {}", b, e);
+				break;
+			}
+		}
+
+		block_count = b;
+		if b % 1000 == 0 && b != 0 {
+			info!("#{} blocks were added to the queue", b);
+		}
+	}
+
+	let mut link = WaitLink::new();
+	Ok(futures::future::poll_fn(move || {
+		if exit_recv.try_recv().is_ok() {
+			return Ok(Async::Ready(()));
+		}
+
+		let blocks_before = link.imported_blocks;
+		let _ = futures03::future::poll_fn(|cx| {
+			$queue.poll_actions(cx, &mut link);
+			std::task::Poll::Pending::<Result<(), ()>>
+		}).compat().poll();
+		if link.has_error {
+			info!(
+				"Stopping after #{} blocks because of an error",
+				link.imported_blocks,
+			);
+			return Ok(Async::Ready(()));
+		}
+		if link.imported_blocks / 1000 != blocks_before / 1000 {
+			info!(
+				"#{} blocks were imported (#{} left)",
+				link.imported_blocks,
+				count - link.imported_blocks
+			);
+		}
+		if link.imported_blocks >= count {
+			info!("Imported {} blocks. Best: #{}", block_count, $client.info().chain.best_number);
+			Ok(Async::Ready(()))
+		} else {
+			Ok(Async::NotReady)
+		}
+	}))
+}}
+}
+
+/// Revert the chain some number of blocks.
+#[macro_export]
+macro_rules! revert_chain {
+($client:ident, $blocks:ident) => {{
+	let reverted = $client.revert($blocks)?;
+	let info = $client.info().chain;
+
+	if reverted.is_zero() {
+		info!("There aren't any non-finalized blocks to revert.");
+	} else {
+		info!("Reverted {} blocks. Best: #{} ({})", reverted, info.best_number, info.best_hash);
+	}
+	Ok(())
+}}
+}
+
+/// Build a chain spec json
+pub fn build_spec<G, E>(spec: ChainSpec<G, E>, raw: bool) -> error::Result<String> where
+	G: RuntimeGenesis,
+	E: Extension,
+{
+	Ok(spec.to_json(raw)?)
+}