Allow to expose a subset of unsafe RPCs (#5233)

* sc-cli: Use type-safe constructors for RPC/Prometheus interfaces

* service: Simplify rpc handler creation

Could probably be further simplifies once [this][commit] lands.

[commit]: https://github.com/paritytech/jsonrpc/commit/20485387ed06a48f1a70bf4d609a7cde6cf0accf

* service: Streamline some HTTP & WS server start logic

* client: Introduce a simple RPC policy mechanism

* rpc/system: Check unsafe RPCs

* rpc/offchain: Check unsafe RPCs

* rpc/author: Check unsafe RPCs

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

@@ -0,0 +1,60 @@
+// 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/>.
+
+//! Policy-related types.
+//!
+//! Contains a `DenyUnsafe` type that can be used to deny potentially unsafe
+//! RPC when accessed externally.
+
+use jsonrpc_core as rpc;
+
+/// Signifies whether a potentially unsafe RPC should be denied.
+#[derive(Clone, Copy, Debug)]
+pub enum DenyUnsafe {
+    /// Denies only potentially unsafe RPCs.
+    Yes,
+    /// Allows calling every RPCs.
+    No
+}
+
+impl DenyUnsafe {
+    /// Returns `Ok(())` if the RPCs considered unsafe are safe to call,
+    /// otherwise returns `Err(UnsafeRpcError)`.
+    pub fn check_if_safe(self) -> Result<(), UnsafeRpcError> {
+        match self {
+            DenyUnsafe::Yes => Err(UnsafeRpcError),
+            DenyUnsafe::No => Ok(())
+        }
+    }
+}
+
+/// Signifies whether an RPC considered unsafe is denied to be called externally.
+#[derive(Debug)]
+pub struct UnsafeRpcError;
+
+impl std::fmt::Display for UnsafeRpcError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "RPC call is unsafe to be called externally")
+    }
+}
+
+impl std::error::Error for UnsafeRpcError {}
+
+impl From<UnsafeRpcError> for rpc::Error {
+    fn from(_: UnsafeRpcError) -> rpc::Error {
+        rpc::Error::method_not_found()
+    }
+}