WIP connect/disconnect

Author: tnull

src/lib.rs

@@ -799,6 +799,71 @@ 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 on restart.
+	pub fn connect_peer(
+		&self, node_pubkey_and_address: &str, 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::try_from(node_pubkey_and_address.to_string())?;
+
+		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: &PublicKey) {
+		log_info!(
+			self.logger,
+			"Disconnecting peer {}..",
+			counterparty_node_id,
+			);
+
+		match self.peer_store.remove_peer(counterparty_node_id) {
+			Ok(()) => {},
+			Err(e) => log_error!(self.logger, "Failed to remove peer {}: {}", counterparty_node_id, e),
+		}
+		self.peer_manager.disconnect_by_node_id(*counterparty_node_id);
+	}
+
 	/// Connect to a node and open a new channel. Disconnects and re-connects are handled automatically
 	///
 	/// Returns a temporary channel id
@@ -1237,15 +1302,15 @@ async fn do_connect_peer(
 	pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc<PeerManager>,
 	logger: Arc<FilesystemLogger>,
 ) -> Result<(), Error> {
-	log_info!(logger, "connecting to peer: {}@{}", pubkey, peer_addr);
+	log_info!(logger, "Connecting to peer: {}@{}", pubkey, peer_addr);
 	match lightning_net_tokio::connect_outbound(Arc::clone(&peer_manager), pubkey, peer_addr).await
 	{
 		Some(connection_closed_future) => {
 			let mut connection_closed_future = Box::pin(connection_closed_future);
 			loop {
 				match futures::poll!(&mut connection_closed_future) {
 					std::task::Poll::Ready(_) => {
-						log_info!(logger, "peer connection closed: {}@{}", pubkey, peer_addr);
+						log_info!(logger, "Peer connection closed: {}@{}", pubkey, peer_addr);
 						return Err(Error::ConnectionFailed);
 					}
 					std::task::Poll::Pending => {}
@@ -1258,7 +1323,7 @@ async fn do_connect_peer(
 			}
 		}
 		None => {
-			log_error!(logger, "failed to connect to peer: {}@{}", pubkey, peer_addr);
+			log_error!(logger, "Failed to connect to peer: {}@{}", pubkey, peer_addr);
 			Err(Error::ConnectionFailed)
 		}
 	}