Implement and expose connect_peer/disconnect_peer

Author: tnull

src/lib.rs

@@ -845,6 +845,79 @@ impl Node {
 		self.channel_manager.list_channels()
 	}
 
+	/// Connect to a node on the peer-to-peer network.
+	///
+	/// If `permanently` is set to `true`, we'll remember the peer and reconnect to it on restart.
+	pub fn connect_peer(
+		&self, pubkey: &PublicKey, address: &SocketAddr, permanently: bool,
+	) -> Result<(), Error> {
+		let runtime_lock = self.running.read().unwrap();
+		if runtime_lock.is_none() {
+			return Err(Error::NotRunning);
+		}
+
+		let runtime = runtime_lock.as_ref().unwrap();
+
+		let peer_info = PeerInfo { pubkey: pubkey.clone(), address: address.clone() };
+
+		let con_peer_pubkey = peer_info.pubkey.clone();
+		let con_peer_addr = peer_info.address.clone();
+		let con_success = Arc::new(AtomicBool::new(false));
+		let con_success_cloned = Arc::clone(&con_success);
+		let con_logger = Arc::clone(&self.logger);
+		let con_pm = Arc::clone(&self.peer_manager);
+
+		tokio::task::block_in_place(move || {
+			runtime.tokio_runtime.block_on(async move {
+				let res =
+					connect_peer_if_necessary(con_peer_pubkey, con_peer_addr, con_pm, con_logger)
+						.await;
+				con_success_cloned.store(res.is_ok(), Ordering::Release);
+			})
+		});
+
+		if !con_success.load(Ordering::Acquire) {
+			return Err(Error::ConnectionFailed);
+		}
+
+		if permanently {
+			self.peer_store.add_peer(peer_info.clone())?;
+		}
+
+		log_info!(self.logger, "Connected to peer {}@{}. ", peer_info.pubkey, peer_info.address,);
+
+		Ok(())
+	}
+
+	/// Disconnects the peer with the given node id.
+	///
+	/// Will also remove the peer from the peer store, i.e., after this has been called we won't
+	/// try to reconnect on restart.
+	pub fn disconnect_peer(&self, counterparty_node_id: &str) -> Result<(), Error> {
+		let runtime_lock = self.running.read().unwrap();
+		if runtime_lock.is_none() {
+			return Err(Error::NotRunning);
+		}
+
+		let node_id = match hex_utils::to_compressed_pubkey(counterparty_node_id) {
+			Some(node_id) => node_id,
+			None => {
+				log_error!(self.logger, "Failed to parse node id from {}", counterparty_node_id,);
+				return Err(Error::PeerInfoParseFailed);
+			}
+		};
+
+		log_info!(self.logger, "Disconnecting peer {}..", node_id,);
+
+		match self.peer_store.remove_peer(&node_id) {
+			Ok(()) => {}
+			Err(e) => log_error!(self.logger, "Failed to remove peer {}: {}", node_id, e),
+		}
+
+		self.peer_manager.disconnect_by_node_id(node_id);
+		Ok(())
+	}
+
 	/// Connect to a node and open a new channel. Disconnects and re-connects are handled automatically
 	///
 	/// Returns a temporary channel id