relay_loop().await from main relay function (#829)

bridges/relays/generic/exchange/src/exchange_loop.rs

@@ -79,7 +79,7 @@ impl<BlockNumber: Clone + Copy> TransactionProofsRelayStorage for InMemoryStorag
 }
 
 /// Run proofs synchronization.
-pub fn run<P: TransactionProofPipeline>(
+pub async fn run<P: TransactionProofPipeline>(
 	storage: impl TransactionProofsRelayStorage<BlockNumber = BlockNumberOf<P>>,
 	source_client: impl SourceClient<P>,
 	target_client: impl TargetClient<P>,
@@ -119,7 +119,8 @@ pub fn run<P: TransactionProofPipeline>(
 				exit_signal.clone(),
 			)
 		},
-	);
+	)
+	.await;
 }
 
 /// Run proofs synchronization.

bridges/relays/generic/finality/src/finality_loop.rs

@@ -91,7 +91,7 @@ pub trait TargetClient<P: FinalitySyncPipeline>: RelayClient {
 }
 
 /// Run finality proofs synchronization loop.
-pub fn run<P: FinalitySyncPipeline>(
+pub async fn run<P: FinalitySyncPipeline>(
 	source_client: impl SourceClient<P>,
 	target_client: impl TargetClient<P>,
 	sync_params: FinalitySyncParams,
@@ -132,7 +132,8 @@ pub fn run<P: FinalitySyncPipeline>(
 				exit_signal.clone(),
 			)
 		},
-	);
+	)
+	.await;
 }
 
 /// Unjustified headers container. Ordered by header number.

bridges/relays/generic/headers/src/sync_loop.rs

@@ -112,7 +112,7 @@ impl<P: HeadersSyncPipeline> SyncMaintain<P> for () {}
 
 /// Run headers synchronization.
 #[allow(clippy::too_many_arguments)]
-pub fn run<P: HeadersSyncPipeline, TC: TargetClient<P>>(
+pub async fn run<P: HeadersSyncPipeline, TC: TargetClient<P>>(
 	source_client: impl SourceClient<P>,
 	source_tick: Duration,
 	target_client: TC,
@@ -159,7 +159,8 @@ pub fn run<P: HeadersSyncPipeline, TC: TargetClient<P>>(
 				exit_signal.clone(),
 			)
 		},
-	);
+	)
+	.await;
 }
 
 /// Run headers synchronization.

bridges/relays/generic/messages/src/message_lane_loop.rs

@@ -206,7 +206,7 @@ pub struct ClientsState<P: MessageLane> {
 }
 
 /// Run message lane service loop.
-pub fn run<P: MessageLane>(
+pub async fn run<P: MessageLane>(
 	params: Params,
 	source_client: impl SourceClient<P>,
 	target_client: impl TargetClient<P>,
@@ -251,7 +251,8 @@ pub fn run<P: MessageLane>(
 				exit_signal.clone(),
 			)
 		},
-	);
+	)
+	.await;
 }
 
 /// Run one-way message delivery loop until connection with target or source node is lost, or exit signal is received.

bridges/relays/generic/utils/src/relay_loop.rs

@@ -37,7 +37,7 @@ pub trait Client: Clone + Send + Sync {
 /// This function represents an outer loop, which in turn calls provided `loop_run` function to do
 /// actual job. When `loop_run` returns, this outer loop reconnects to failed client (source,
 /// target or both) and calls `loop_run` again.
-pub fn run<SC: Client, TC: Client, R, F>(
+pub async fn run<SC: Client, TC: Client, R, F>(
 	reconnect_delay: Duration,
 	mut source_client: SC,
 	mut target_client: TC,
@@ -46,50 +46,46 @@ pub fn run<SC: Client, TC: Client, R, F>(
 	R: Fn(SC, TC) -> F,
 	F: Future<Output = Result<(), FailedClient>>,
 {
-	let mut local_pool = futures::executor::LocalPool::new();
+	loop {
+		let result = loop_run(source_client.clone(), target_client.clone()).await;
 
-	local_pool.run_until(async move {
-		loop {
-			let result = loop_run(source_client.clone(), target_client.clone()).await;
-
-			match result {
-				Ok(()) => break,
-				Err(failed_client) => loop {
-					async_std::task::sleep(reconnect_delay).await;
-					if failed_client == FailedClient::Both || failed_client == FailedClient::Source {
-						match source_client.reconnect().await {
-							Ok(()) => (),
-							Err(error) => {
-								log::warn!(
-									target: "bridge",
-									"Failed to reconnect to source client. Going to retry in {}s: {:?}",
-									reconnect_delay.as_secs(),
-									error,
-								);
-								continue;
-							}
+		match result {
+			Ok(()) => break,
+			Err(failed_client) => loop {
+				async_std::task::sleep(reconnect_delay).await;
+				if failed_client == FailedClient::Both || failed_client == FailedClient::Source {
+					match source_client.reconnect().await {
+						Ok(()) => (),
+						Err(error) => {
+							log::warn!(
+								target: "bridge",
+								"Failed to reconnect to source client. Going to retry in {}s: {:?}",
+								reconnect_delay.as_secs(),
+								error,
+							);
+							continue;
 						}
 					}
-					if failed_client == FailedClient::Both || failed_client == FailedClient::Target {
-						match target_client.reconnect().await {
-							Ok(()) => (),
-							Err(error) => {
-								log::warn!(
-									target: "bridge",
-									"Failed to reconnect to target client. Going to retry in {}s: {:?}",
-									reconnect_delay.as_secs(),
-									error,
-								);
-								continue;
-							}
+				}
+				if failed_client == FailedClient::Both || failed_client == FailedClient::Target {
+					match target_client.reconnect().await {
+						Ok(()) => (),
+						Err(error) => {
+							log::warn!(
+								target: "bridge",
+								"Failed to reconnect to target client. Going to retry in {}s: {:?}",
+								reconnect_delay.as_secs(),
+								error,
+							);
+							continue;
 						}
 					}
+				}
 
-					break;
-				},
-			}
-
-			log::debug!(target: "bridge", "Restarting relay loop");
+				break;
+			},
 		}
-	});
+
+		log::debug!(target: "bridge", "Restarting relay loop");
+	}
 }