consistent naming for custom_service_signal

Author: liamaharon

node/src/command.rs

@@ -289,16 +289,21 @@ fn start_aura_service(arg_matches: &ArgMatches) -> Result<(), sc_cli::Error> {
     //
     // Passing this atomic bool is a hacky solution, allowing the node to set it to true to indicate
     // a Babe service should be spawned on exit instead of a regular shutdown.
-    let babe_switch = Arc::new(AtomicBool::new(false));
-    let babe_switch_clone = babe_switch.clone();
+    let custom_service_signal = Arc::new(AtomicBool::new(false));
+    let custom_service_signal_clone = custom_service_signal.clone();
     match runner.run_node_until_exit(|config| async move {
         let config = customise_config(arg_matches, config);
-        service::build_full::<AuraConsensus>(config, cli.eth, cli.sealing, Some(babe_switch_clone))
-            .await
+        service::build_full::<AuraConsensus>(
+            config,
+            cli.eth,
+            cli.sealing,
+            Some(custom_service_signal_clone),
+        )
+        .await
     }) {
         Ok(()) => Ok(()),
         Err(e) => {
-            if babe_switch.load(std::sync::atomic::Ordering::Relaxed) {
+            if custom_service_signal.load(std::sync::atomic::Ordering::Relaxed) {
                 start_babe_service(arg_matches)
             } else {
                 Err(e.into())

node/src/consensus/aura_consensus.rs

@@ -195,18 +195,18 @@ impl ConsensusMechanism for AuraConsensus {
         &self,
         task_manager: &mut TaskManager,
         client: Arc<FullClient>,
-        triggered: Option<Arc<std::sync::atomic::AtomicBool>>,
+        custom_service_signal: Option<Arc<std::sync::atomic::AtomicBool>>,
         sync_service: Arc<SyncingService<Block>>,
     ) -> Result<(), sc_service::Error> {
         let client_clone = client.clone();
-        let triggered_clone = triggered.clone();
+        let custom_service_signal_clone = custom_service_signal.clone();
         let slot_duration = self.slot_duration(&client)?;
         task_manager.spawn_essential_handle().spawn(
             "babe-switch",
             None,
             Box::pin(async move {
                 let client = client_clone;
-                let triggered = triggered_clone;
+                let custom_service_signal = custom_service_signal_clone;
                 loop {
                     // Check if the runtime is Babe once per block.
                     if let Ok(c) = sc_consensus_babe::configuration(&*client) {
@@ -222,8 +222,9 @@ impl ConsensusMechanism for AuraConsensus {
                         let syncing = sync_service.status().await.is_ok_and(|status| status.warp_sync.is_some() || status.state_sync.is_some());
                         if !c.authorities.is_empty() && !syncing {
                             log::info!("Babe runtime detected! Intentionally failing the essential handle `babe-switch` to trigger switch to Babe service.");
-                            if let Some(triggered) = triggered {
-                                triggered.store(true, std::sync::atomic::Ordering::SeqCst);
+							// Signal that the node stopped due to the custom service exiting.
+                            if let Some(custom_service_signal) = custom_service_signal {
+                                custom_service_signal.store(true, std::sync::atomic::Ordering::SeqCst);
                             };
                             break;
                         }

node/src/consensus/babe_consensus.rs

@@ -218,7 +218,7 @@ impl ConsensusMechanism for BabeConsensus {
         &self,
         _task_manager: &mut TaskManager,
         _client: Arc<FullClient>,
-        _triggered: Option<Arc<std::sync::atomic::AtomicBool>>,
+        _custom_service_signal: Option<Arc<std::sync::atomic::AtomicBool>>,
         _sync_service: Arc<SyncingService<Block>>,
     ) -> Result<(), sc_service::Error> {
         // No additional Babe handles required.

node/src/consensus/consensus_mechanism.rs

@@ -124,7 +124,7 @@ pub trait ConsensusMechanism {
         &self,
         task_manager: &mut TaskManager,
         client: Arc<FullClient>,
-        triggered: Option<Arc<AtomicBool>>,
+        custom_service_signal: Option<Arc<AtomicBool>>,
         sync_service: Arc<SyncingService<Block>>,
     ) -> Result<(), ServiceError>;