LSPS1 service: Drop lock before enqueuing responses

.. which avoids a potential deadlock

Author: tnull

src/lsps1/service.rs

@@ -211,16 +211,18 @@ where
 			});
 		}
 
-		let mut outer_state_lock = self.per_peer_state.write().unwrap();
+		{
+			let mut outer_state_lock = self.per_peer_state.write().unwrap();
 
-		let inner_state_lock = outer_state_lock
-			.entry(*counterparty_node_id)
-			.or_insert(Mutex::new(PeerState::default()));
-		let mut peer_state_lock = inner_state_lock.lock().unwrap();
+			let inner_state_lock = outer_state_lock
+				.entry(*counterparty_node_id)
+				.or_insert(Mutex::new(PeerState::default()));
+			let mut peer_state_lock = inner_state_lock.lock().unwrap();
 
-		peer_state_lock
-			.pending_requests
-			.insert(request_id.clone(), LSPS1Request::CreateOrder(params.clone()));
+			peer_state_lock
+				.pending_requests
+				.insert(request_id.clone(), LSPS1Request::CreateOrder(params.clone()));
+		}
 
 		self.pending_events.enqueue(Event::LSPS1Service(
 			LSPS1ServiceEvent::RequestForPaymentDetails {
@@ -242,56 +244,68 @@ where
 		&self, request_id: RequestId, counterparty_node_id: &PublicKey, payment: OrderPayment,
 		created_at: chrono::DateTime<Utc>, expires_at: chrono::DateTime<Utc>,
 	) -> Result<(), APIError> {
-		let outer_state_lock = self.per_peer_state.read().unwrap();
-
-		match outer_state_lock.get(counterparty_node_id) {
-			Some(inner_state_lock) => {
-				let mut peer_state_lock = inner_state_lock.lock().unwrap();
-
-				match peer_state_lock.pending_requests.remove(&request_id) {
-					Some(LSPS1Request::CreateOrder(params)) => {
-						let order_id = self.generate_order_id();
-						let channel = OutboundCRChannel::new(
-							params.order.clone(),
-							created_at.clone(),
-							expires_at.clone(),
-							order_id.clone(),
-							payment.clone(),
-						);
-
-						peer_state_lock.insert_outbound_channel(order_id.clone(), channel);
-
-						let response = LSPS1Response::CreateOrder(CreateOrderResponse {
-							order: params.order,
-							order_id,
-							order_state: OrderState::Created,
-							created_at,
-							expires_at,
-							payment,
-							channel: None,
-						});
-						let msg = LSPS1Message::Response(request_id, response).into();
-						self.pending_messages.enqueue(counterparty_node_id, msg);
-					},
+		let (result, response) = {
+			let outer_state_lock = self.per_peer_state.read().unwrap();
+
+			match outer_state_lock.get(counterparty_node_id) {
+				Some(inner_state_lock) => {
+					let mut peer_state_lock = inner_state_lock.lock().unwrap();
+
+					match peer_state_lock.pending_requests.remove(&request_id) {
+						Some(LSPS1Request::CreateOrder(params)) => {
+							let order_id = self.generate_order_id();
+							let channel = OutboundCRChannel::new(
+								params.order.clone(),
+								created_at.clone(),
+								expires_at.clone(),
+								order_id.clone(),
+								payment.clone(),
+							);
+
+							peer_state_lock.insert_outbound_channel(order_id.clone(), channel);
+
+							let response = LSPS1Response::CreateOrder(CreateOrderResponse {
+								order: params.order,
+								order_id,
+								order_state: OrderState::Created,
+								created_at,
+								expires_at,
+								payment,
+								channel: None,
+							});
+
+							(Ok(()), Some(response))
+						},
+
+						_ => (
+							Err(APIError::APIMisuseError {
+								err: format!(
+									"No pending buy request for request_id: {:?}",
+									request_id
+								),
+							}),
+							None,
+						),
+					}
+				},
+				None => (
+					Err(APIError::APIMisuseError {
+						err: format!(
+							"No state for the counterparty exists: {:?}",
+							counterparty_node_id
+						),
+					}),
+					None,
+				),
+			}
+		};
 
-					_ => {
-						return Err(APIError::APIMisuseError {
-							err: format!("No pending buy request for request_id: {:?}", request_id),
-						})
-					},
-				}
-			},
-			None => {
-				return Err(APIError::APIMisuseError {
-					err: format!(
-						"No state for the counterparty exists: {:?}",
-						counterparty_node_id
-					),
-				})
-			},
+		if let Some(response) = response {
+			let msg = LSPS1Message::Response(request_id, response).into();
+			self.pending_messages.enqueue(counterparty_node_id, msg);
 		}
 
-		Ok(())
+		result
 	}
 
 	fn handle_get_order_request(
@@ -337,7 +351,7 @@ where
 			},
 			None => {
 				return Err(LightningError {
-					err: format!("Received error response for a create order request from an unknown counterparty ({:?})",counterparty_node_id),
+					err: format!("Received error response for a create order request from an unknown counterparty ({:?})", counterparty_node_id),
 					action: ErrorAction::IgnoreAndLog(Level::Info),
 				});
 			},
@@ -358,41 +372,55 @@ where
 		&self, request_id: RequestId, counterparty_node_id: PublicKey, order_id: OrderId,
 		order_state: OrderState, channel: Option<ChannelInfo>,
 	) -> Result<(), APIError> {
-		let outer_state_lock = self.per_peer_state.read().unwrap();
+		let (result, response) = {
+			let outer_state_lock = self.per_peer_state.read().unwrap();
 
-		match outer_state_lock.get(&counterparty_node_id) {
-			Some(inner_state_lock) => {
-				let mut peer_state_lock = inner_state_lock.lock().unwrap();
+			match outer_state_lock.get(&counterparty_node_id) {
+				Some(inner_state_lock) => {
+					let mut peer_state_lock = inner_state_lock.lock().unwrap();
 
-				if let Some(outbound_channel) =
-					peer_state_lock.outbound_channels_by_order_id.get_mut(&order_id)
-				{
-					let config = &outbound_channel.config;
-
-					let response = LSPS1Response::GetOrder(CreateOrderResponse {
-						order_id,
-						order: config.order.clone(),
-						order_state,
-						created_at: config.created_at,
-						expires_at: config.expires_at,
-						payment: config.payment.clone(),
-						channel,
-					});
-					let msg = LSPS1Message::Response(request_id, response).into();
-					self.pending_messages.enqueue(counterparty_node_id, msg);
-				} else {
-					return Err(APIError::APIMisuseError {
-						err: format!("Channel with order_id {} not found", order_id.0),
-					});
-				}
-			},
-			None => {
-				return Err(APIError::APIMisuseError {
-					err: format!("No existing state with counterparty {}", counterparty_node_id),
-				})
-			},
+					if let Some(outbound_channel) =
+						peer_state_lock.outbound_channels_by_order_id.get_mut(&order_id)
+					{
+						let config = &outbound_channel.config;
+
+						let response = LSPS1Response::GetOrder(CreateOrderResponse {
+							order_id,
+							order: config.order.clone(),
+							order_state,
+							created_at: config.created_at,
+							expires_at: config.expires_at,
+							payment: config.payment.clone(),
+							channel,
+						});
+						(Ok(()), Some(response))
+					} else {
+						(
+							Err(APIError::APIMisuseError {
+								err: format!("Channel with order_id {} not found", order_id.0),
+							}),
+							None,
+						)
+					}
+				},
+				None => (
+					Err(APIError::APIMisuseError {
+						err: format!(
+							"No existing state with counterparty {}",
+							counterparty_node_id
+						),
+					}),
+					None,
+				),
+			}
+		};
+
+		if let Some(response) = response {
+			let msg = LSPS1Message::Response(request_id, response).into();
+			self.pending_messages.enqueue(counterparty_node_id, msg);
 		}
-		Ok(())
+
+		result
 	}
 
 	fn generate_order_id(&self) -> OrderId {