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-04-30 21:17:56 +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,105 @@
+// 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/>.
+
+//! Substrate system API.
+
+#[cfg(test)]
+mod tests;
+
+use futures03::{channel::{mpsc, oneshot}, compat::Compat};
+use api::Receiver;
+use sr_primitives::traits::{self, Header as HeaderT};
+use self::error::Result;
+
+pub use api::system::*;
+pub use self::helpers::{Properties, SystemInfo, Health, PeerInfo, NodeRole};
+pub use self::gen_client::Client as SystemClient;
+
+/// System API implementation
+pub struct System<B: traits::Block> {
+	info: SystemInfo,
+	send_back: mpsc::UnboundedSender<Request<B>>,
+}
+
+/// Request to be processed.
+pub enum Request<B: traits::Block> {
+	/// Must return the health of the network.
+	Health(oneshot::Sender<Health>),
+	/// Must return information about the peers we are connected to.
+	Peers(oneshot::Sender<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>),
+	/// Must return the state of the network.
+	NetworkState(oneshot::Sender<rpc::Value>),
+	/// Must return the node role.
+	NodeRoles(oneshot::Sender<Vec<NodeRole>>)
+}
+
+impl<B: traits::Block> System<B> {
+	/// Creates new `System`.
+	///
+	/// The `send_back` will be used to transmit some of the requests. The user is responsible for
+	/// reading from that channel and answering the requests.
+	pub fn new(
+		info: SystemInfo,
+		send_back: mpsc::UnboundedSender<Request<B>>
+	) -> Self {
+		System {
+			info,
+			send_back,
+		}
+	}
+}
+
+impl<B: traits::Block> SystemApi<B::Hash, <B::Header as HeaderT>::Number> for System<B> {
+	fn system_name(&self) -> Result<String> {
+		Ok(self.info.impl_name.clone())
+	}
+
+	fn system_version(&self) -> Result<String> {
+		Ok(self.info.impl_version.clone())
+	}
+
+	fn system_chain(&self) -> Result<String> {
+		Ok(self.info.chain_name.clone())
+	}
+
+	fn system_properties(&self) -> Result<Properties> {
+		Ok(self.info.properties.clone())
+	}
+
+	fn system_health(&self) -> Receiver<Health> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::Health(tx));
+		Receiver(Compat::new(rx))
+	}
+
+	fn system_peers(&self) -> Receiver<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::Peers(tx));
+		Receiver(Compat::new(rx))
+	}
+
+	fn system_network_state(&self) -> Receiver<rpc::Value> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkState(tx));
+		Receiver(Compat::new(rx))
+	}
+
+	fn system_node_roles(&self) -> Receiver<Vec<NodeRole>> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NodeRoles(tx));
+		Receiver(Compat::new(rx))
+	}
+}
@@ -0,0 +1,234 @@
+// 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/>.
+
+use super::*;
+
+use network::{self, PeerId};
+use network::config::Roles;
+use test_client::runtime::Block;
+use assert_matches::assert_matches;
+use futures03::{prelude::*, channel::mpsc};
+use std::thread;
+
+struct Status {
+	pub peers: usize,
+	pub is_syncing: bool,
+	pub is_dev: bool,
+	pub peer_id: PeerId,
+}
+
+impl Default for Status {
+	fn default() -> Status {
+		Status {
+			peer_id: PeerId::random(),
+			peers: 0,
+			is_syncing: false,
+			is_dev: false,
+		}
+	}
+}
+
+fn api<T: Into<Option<Status>>>(sync: T) -> System<Block> {
+	let status = sync.into().unwrap_or_default();
+	let should_have_peers = !status.is_dev;
+	let (tx, rx) = mpsc::unbounded();
+	thread::spawn(move || {
+		futures03::executor::block_on(rx.for_each(move |request| {
+			match request {
+				Request::Health(sender) => {
+					let _ = sender.send(Health {
+						peers: status.peers,
+						is_syncing: status.is_syncing,
+						should_have_peers,
+					});
+				},
+				Request::Peers(sender) => {
+					let mut peers = vec![];
+					for _peer in 0..status.peers {
+						peers.push(PeerInfo {
+							peer_id: status.peer_id.to_base58(),
+							roles: format!("{:?}", Roles::FULL),
+							protocol_version: 1,
+							best_hash: Default::default(),
+							best_number: 1,
+						});
+					}
+					let _ = sender.send(peers);
+				}
+				Request::NetworkState(sender) => {
+					let _ = sender.send(serde_json::to_value(&network::NetworkState {
+						peer_id: String::new(),
+						listened_addresses: Default::default(),
+						external_addresses: Default::default(),
+						connected_peers: Default::default(),
+						not_connected_peers: Default::default(),
+						average_download_per_sec: 0,
+						average_upload_per_sec: 0,
+						peerset: serde_json::Value::Null,
+					}).unwrap());
+				},
+				Request::NodeRoles(sender) => {
+					let _ = sender.send(vec![NodeRole::Authority]);
+				}
+			};
+
+			future::ready(())
+		}))
+	});
+	System::new(SystemInfo {
+		impl_name: "testclient".into(),
+		impl_version: "0.2.0".into(),
+		chain_name: "testchain".into(),
+		properties: Default::default(),
+	}, tx)
+}
+
+fn wait_receiver<T>(rx: Receiver<T>) -> T {
+	let mut runtime = tokio::runtime::current_thread::Runtime::new().unwrap();
+	runtime.block_on(rx).unwrap()
+}
+
+#[test]
+fn system_name_works() {
+	assert_eq!(
+		api(None).system_name().unwrap(),
+		"testclient".to_owned()
+	);
+}
+
+#[test]
+fn system_version_works() {
+	assert_eq!(
+		api(None).system_version().unwrap(),
+		"0.2.0".to_owned()
+	);
+}
+
+#[test]
+fn system_chain_works() {
+	assert_eq!(
+		api(None).system_chain().unwrap(),
+		"testchain".to_owned()
+	);
+}
+
+#[test]
+fn system_properties_works() {
+	assert_eq!(
+		api(None).system_properties().unwrap(),
+		serde_json::map::Map::new()
+	);
+}
+
+#[test]
+fn system_health() {
+	assert_matches!(
+		wait_receiver(api(None).system_health()),
+		Health {
+			peers: 0,
+			is_syncing: false,
+			should_have_peers: true,
+		}
+	);
+
+	assert_matches!(
+		wait_receiver(api(Status {
+			peer_id: PeerId::random(),
+			peers: 5,
+			is_syncing: true,
+			is_dev: true,
+		}).system_health()),
+		Health {
+			peers: 5,
+			is_syncing: true,
+			should_have_peers: false,
+		}
+	);
+
+	assert_eq!(
+		wait_receiver(api(Status {
+			peer_id: PeerId::random(),
+			peers: 5,
+			is_syncing: false,
+			is_dev: false,
+		}).system_health()),
+		Health {
+			peers: 5,
+			is_syncing: false,
+			should_have_peers: true,
+		}
+	);
+
+	assert_eq!(
+		wait_receiver(api(Status {
+			peer_id: PeerId::random(),
+			peers: 0,
+			is_syncing: false,
+			is_dev: true,
+		}).system_health()),
+		Health {
+			peers: 0,
+			is_syncing: false,
+			should_have_peers: false,
+		}
+	);
+}
+
+#[test]
+fn system_peers() {
+	let peer_id = PeerId::random();
+	assert_eq!(
+		wait_receiver(api(Status {
+			peer_id: peer_id.clone(),
+			peers: 1,
+			is_syncing: false,
+			is_dev: true,
+		}).system_peers()),
+		vec![PeerInfo {
+			peer_id: peer_id.to_base58(),
+			roles: "FULL".into(),
+			protocol_version: 1,
+			best_hash: Default::default(),
+			best_number: 1u64,
+		}]
+	);
+}
+
+#[test]
+fn system_network_state() {
+	let res = wait_receiver(api(None).system_network_state());
+	assert_eq!(
+		serde_json::from_value::<network::NetworkState>(res).unwrap(),
+		network::NetworkState {
+			peer_id: String::new(),
+			listened_addresses: Default::default(),
+			external_addresses: Default::default(),
+			connected_peers: Default::default(),
+			not_connected_peers: Default::default(),
+			average_download_per_sec: 0,
+			average_upload_per_sec: 0,
+			peerset: serde_json::Value::Null,
+		}
+	);
+}
+
+#[test]
+fn system_node_roles() {
+	assert_eq!(
+		wait_receiver(api(None).system_node_roles()),
+		vec![NodeRole::Authority]
+	);
+}