RPC api for offchain storage (#4694)

* Rpc api for offchain storage

* Replace Vec<u8> to Bytes, replace Mutex to RwLock

* Remove pub

* Modify copyright year

substrate/Cargo.lock

@@ -5768,6 +5768,7 @@ dependencies = [
  "sp-blockchain 2.0.0",
  "sp-core 2.0.0",
  "sp-io 2.0.0",
+ "sp-offchain 2.0.0",
  "sp-rpc 2.0.0",
  "sp-runtime 2.0.0",
  "sp-session 2.0.0",

substrate/client/rpc-api/src/lib.rs

@@ -30,5 +30,6 @@ pub use helpers::Receiver;
 
 pub mod author;
 pub mod chain;
+pub mod offchain;
 pub mod state;
 pub mod system;

substrate/client/rpc-api/src/offchain/error.rs

@@ -0,0 +1,51 @@
+// Copyright 2020 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/>.
+
+//! Offchain RPC errors.
+
+use jsonrpc_core as rpc;
+
+/// Offchain RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Offchain RPC errors.
+#[derive(Debug, derive_more::Display, derive_more::From)]
+pub enum Error {
+	/// Unavailable storage kind error.
+	#[display(fmt="This storage kind is not available yet.")]
+	UnavailableStorageKind,
+}
+
+impl std::error::Error for Error {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		None
+	}
+}
+
+/// Base error code for all offchain errors.
+const BASE_ERROR: i64 = 5000;
+
+impl From<Error> for rpc::Error {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::UnavailableStorageKind => rpc::Error {
+				code: rpc::ErrorCode::ServerError(BASE_ERROR + 1),
+				message: "This storage kind is not available yet" .into(),
+				data: None,
+			},
+		}
+	}
+}

substrate/client/rpc-api/src/offchain/mod.rs

@@ -0,0 +1,37 @@
+// Copyright 2020 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 offchain API.
+
+pub mod error;
+
+use jsonrpc_derive::rpc;
+use self::error::Result;
+use sp_core::{Bytes, offchain::StorageKind};
+
+pub use self::gen_client::Client as OffchainClient;
+
+/// Substrate offchain RPC API
+#[rpc]
+pub trait OffchainApi {
+	/// Set offchain local storage under given key and prefix.
+	#[rpc(name = "offchain_localStorageSet")]
+	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> Result<()>;
+
+	/// Get offchain local storage under given key and prefix.
+	#[rpc(name = "offchain_localStorageGet")]
+	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> Result<Option<Bytes>>;
+}

substrate/client/rpc/Cargo.toml

@@ -18,6 +18,7 @@ rpc = { package = "jsonrpc-core", version = "14.0.3" }
 sp-version = { version = "2.0.0", path = "../../primitives/version" }
 serde_json = "1.0.41"
 sp-session = { version = "2.0.0", path = "../../primitives/session" }
+sp-offchain = { version = "2.0.0", path = "../../primitives/offchain" }
 sp-runtime = { version = "2.0.0", path = "../../primitives/runtime" }
 sp-rpc = { version = "2.0.0", path = "../../primitives/rpc" }
 sp-state-machine = { version = "0.8", path = "../../primitives/state-machine" }

substrate/client/rpc/src/lib.rs

@@ -28,5 +28,6 @@ pub use rpc::IoHandlerExtension as RpcExtension;
 
 pub mod author;
 pub mod chain;
+pub mod offchain;
 pub mod state;
 pub mod system;

substrate/client/rpc/src/offchain/mod.rs

@@ -0,0 +1,67 @@
+// Copyright 2020 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 offchain API.
+
+#[cfg(test)]
+mod tests;
+
+/// Re-export the API for backward compatibility.
+pub use sc_rpc_api::offchain::*;
+use self::error::{Error, Result};
+use sp_core::{
+	Bytes,
+	offchain::{OffchainStorage, StorageKind},
+};
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+/// Offchain API
+#[derive(Debug)]
+pub struct Offchain<T: OffchainStorage> {
+	/// Offchain storage
+	storage: Arc<RwLock<T>>,
+}
+
+impl<T: OffchainStorage> Offchain<T> {
+	/// Create new instance of Offchain API.
+	pub fn new(storage: T) -> Self {
+		Offchain {
+			storage: Arc::new(RwLock::new(storage)),
+		}
+	}
+}
+
+impl<T: OffchainStorage + 'static> OffchainApi for Offchain<T> {
+	/// Set offchain local storage under given key and prefix.
+	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> Result<()> {
+		let prefix = match kind {
+			StorageKind::PERSISTENT => sp_offchain::STORAGE_PREFIX,
+			StorageKind::LOCAL => return Err(Error::UnavailableStorageKind),
+		};
+		self.storage.write().set(prefix, &*key, &*value);
+		Ok(())
+	}
+
+	/// Get offchain local storage under given key and prefix.
+	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> Result<Option<Bytes>> {
+		let prefix = match kind {
+			StorageKind::PERSISTENT => sp_offchain::STORAGE_PREFIX,
+			StorageKind::LOCAL => return Err(Error::UnavailableStorageKind),
+		};
+		Ok(self.storage.read().get(prefix, &*key).map(Into::into))
+	}
+}

substrate/client/rpc/src/offchain/tests.rs

@@ -0,0 +1,36 @@
+// Copyright 2020 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 assert_matches::assert_matches;
+use sp_core::{Bytes, offchain::storage::InMemOffchainStorage};
+
+#[test]
+fn local_storage_should_work() {
+	let storage = InMemOffchainStorage::default();
+	let offchain = Offchain::new(storage);
+	let key = Bytes(b"offchain_storage".to_vec());
+	let value = Bytes(b"offchain_value".to_vec());
+
+	assert_matches!(
+		offchain.set_local_storage(StorageKind::PERSISTENT, key.clone(), value.clone()),
+		Ok(())
+	);
+	assert_matches!(
+		offchain.get_local_storage(StorageKind::PERSISTENT, key),
+		Ok(Some(ref v)) if *v == value
+	);
+}

substrate/client/service/src/builder.rs

@@ -863,7 +863,7 @@ ServiceBuilder<
 		let network_status_sinks = Arc::new(Mutex::new(status_sinks::StatusSinks::new()));
 
 		let offchain_storage = backend.offchain_storage();
-		let offchain_workers = match (config.offchain_worker, offchain_storage) {
+		let offchain_workers = match (config.offchain_worker, offchain_storage.clone()) {
 			(true, Some(db)) => {
 				Some(Arc::new(sc_offchain::OffchainWorkers::new(client.clone(), db)))
 			},
@@ -1008,7 +1008,7 @@ ServiceBuilder<
 		// RPC
 		let (system_rpc_tx, system_rpc_rx) = mpsc::unbounded();
 		let gen_handler = || {
-			use sc_rpc::{chain, state, author, system};
+			use sc_rpc::{chain, state, author, system, offchain};
 
 			let system_info = sc_rpc::system::SystemInfo {
 				chain_name: config.chain_spec.name().into(),
@@ -1054,13 +1054,26 @@ ServiceBuilder<
 			);
 			let system = system::System::new(system_info, system_rpc_tx.clone());
 
-			sc_rpc_server::rpc_handler((
-				state::StateApi::to_delegate(state),
-				chain::ChainApi::to_delegate(chain),
-				author::AuthorApi::to_delegate(author),
-				system::SystemApi::to_delegate(system),
-				rpc_extensions.clone(),
-			))
+			match offchain_storage.clone() {
+				Some(storage) => {
+					let offchain = sc_rpc::offchain::Offchain::new(storage);
+					sc_rpc_server::rpc_handler((
+						state::StateApi::to_delegate(state),
+						chain::ChainApi::to_delegate(chain),
+						offchain::OffchainApi::to_delegate(offchain),
+						author::AuthorApi::to_delegate(author),
+						system::SystemApi::to_delegate(system),
+						rpc_extensions.clone(),
+					))
+				},
+				None => sc_rpc_server::rpc_handler((
+					state::StateApi::to_delegate(state),
+					chain::ChainApi::to_delegate(chain),
+					author::AuthorApi::to_delegate(author),
+					system::SystemApi::to_delegate(system),
+					rpc_extensions.clone(),
+				))
+			}
 		};
 		let rpc_handlers = gen_handler();
 		let rpc = start_rpc_servers(&config, gen_handler)?;

substrate/primitives/core/src/offchain/mod.rs

@@ -50,6 +50,7 @@ pub trait OffchainStorage: Clone + Send + Sync {
 
 /// A type of supported crypto.
 #[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, RuntimeDebug, PassByEnum)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
 #[repr(C)]
 pub enum StorageKind {
 	/// Persistent storage is non-revertible and not fork-aware. It means that any value