Plumb RPC listener up to caller

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

@@ -52,6 +52,14 @@ const MEGABYTE: u32 = 1024 * 1024;
 /// Type alias for the JSON-RPC server.
 pub type Server = jsonrpsee::server::ServerHandle;
 
+/// Type to encapsulate the server handle and listening address.
+pub struct ServerAndListenAddress {
+	/// Handle to the rpc server
+	pub handle: Server,
+	/// Listening address of the server
+	pub listen_addr: Option<SocketAddr>,
+}
+
 /// RPC server configuration.
 #[derive(Debug)]
 pub struct Config<'a, M: Send + Sync + 'static> {
@@ -100,7 +108,7 @@ struct PerConnection<RpcMiddleware, HttpMiddleware> {
 /// Start RPC server listening on given address.
 pub async fn start_server<M>(
 	config: Config<'_, M>,
-) -> Result<Server, Box<dyn StdError + Send + Sync>>
+) -> Result<ServerAndListenAddress, Box<dyn StdError + Send + Sync>>
 where
 	M: Send + Sync,
 {
@@ -264,5 +272,5 @@ where
 		format_cors(cors)
 	);
 
-	Ok(server_handle)
+	Ok(ServerAndListenAddress { handle: server_handle, listen_addr: local_addr })
 }

substrate/client/service/src/builder.rs

@@ -19,7 +19,7 @@
 use crate::{
 	build_network_future, build_system_rpc_future,
 	client::{Client, ClientConfig},
-	config::{Configuration, KeystoreConfig, PrometheusConfig},
+	config::{Configuration, KeystoreConfig, Multiaddr, PrometheusConfig},
 	error::Error,
 	metrics::MetricsService,
 	start_rpc_servers, BuildGenesisBlock, GenesisBlockBuilder, RpcHandlers, SpawnTaskHandle,
@@ -43,6 +43,7 @@ use sc_executor::{
 use sc_keystore::LocalKeystore;
 use sc_network::{
 	config::{FullNetworkConfiguration, SyncMode},
+	multiaddr::Protocol,
 	service::{
 		traits::{PeerStore, RequestResponseConfig},
 		NotificationMetrics,
@@ -507,8 +508,21 @@ where
 		)
 	};
 
-	let rpc = start_rpc_servers(&config, gen_rpc_module, rpc_id_provider)?;
-	let rpc_handlers = RpcHandlers(Arc::new(gen_rpc_module(sc_rpc::DenyUnsafe::No)?.into()));
+	let (rpc, listen_addr) = start_rpc_servers(&config, gen_rpc_module, rpc_id_provider)?;
+
+	let listen_addrs = match listen_addr {
+		Some(socket_addr) => {
+			let mut multiaddr: Multiaddr = socket_addr.ip().into();
+			multiaddr.push(Protocol::Tcp(socket_addr.port()));
+			vec![multiaddr]
+		},
+		None => vec![],
+	};
+
+	let rpc_handlers = RpcHandlers {
+		rpc_module: Arc::new(gen_rpc_module(sc_rpc::DenyUnsafe::No)?.into()),
+		listen_addresses: Box::new(listen_addrs),
+	};
 
 	// Spawn informant task
 	spawn_handle.spawn(

substrate/client/service/src/lib.rs

@@ -34,6 +34,7 @@ mod client;
 mod metrics;
 mod task_manager;
 
+use crate::config::Multiaddr;
 use std::{collections::HashMap, net::SocketAddr};
 
 use codec::{Decode, Encode};
@@ -47,6 +48,7 @@ use sc_network::{
 };
 use sc_network_sync::SyncingService;
 use sc_network_types::PeerId;
+use sc_rpc_server::ServerAndListenAddress;
 use sc_utils::mpsc::TracingUnboundedReceiver;
 use sp_blockchain::HeaderMetadata;
 use sp_consensus::SyncOracle;
@@ -98,7 +100,10 @@ const DEFAULT_PROTOCOL_ID: &str = "sup";
 
 /// RPC handlers that can perform RPC queries.
 #[derive(Clone)]
-pub struct RpcHandlers(Arc<RpcModule<()>>);
+pub struct RpcHandlers {
+	rpc_module: Arc<RpcModule<()>>,
+	listen_addresses: Box<Vec<Multiaddr>>,
+}
 
 impl RpcHandlers {
 	/// Starts an RPC query.
@@ -120,12 +125,17 @@ impl RpcHandlers {
 		// This limit is used to prevent panics and is large enough.
 		const TOKIO_MPSC_MAX_SIZE: usize = tokio::sync::Semaphore::MAX_PERMITS;
 
-		self.0.raw_json_request(json_query, TOKIO_MPSC_MAX_SIZE).await
+		self.rpc_module.raw_json_request(json_query, TOKIO_MPSC_MAX_SIZE).await
 	}
 
 	/// Provides access to the underlying `RpcModule`
 	pub fn handle(&self) -> Arc<RpcModule<()>> {
-		self.0.clone()
+		self.rpc_module.clone()
+	}
+
+	/// Provides access to listen addresses
+	pub fn listen_addresses(&self) -> &[Multiaddr] {
+		&self.listen_addresses[..]
 	}
 }
 
@@ -372,7 +382,7 @@ pub fn start_rpc_servers<R>(
 	config: &Configuration,
 	gen_rpc_module: R,
 	rpc_id_provider: Option<Box<dyn RpcSubscriptionIdProvider>>,
-) -> Result<Box<dyn std::any::Any + Send + Sync>, error::Error>
+) -> Result<(Box<dyn std::any::Any + Send + Sync>, Option<SocketAddr>), error::Error>
 where
 	R: Fn(sc_rpc::DenyUnsafe) -> Result<RpcModule<()>, Error>,
 {
@@ -419,7 +429,9 @@ where
 	match tokio::task::block_in_place(|| {
 		config.tokio_handle.block_on(sc_rpc_server::start_server(server_config))
 	}) {
-		Ok(server) => Ok(Box::new(waiting::Server(Some(server)))),
+		Ok(ServerAndListenAddress { handle, listen_addr }) => {
+			Ok((Box::new(waiting::Server(Some(handle))), listen_addr))
+		},
 		Err(e) => Err(Error::Application(e)),
 	}
 }