attempt to fix test flake by reverting the reorder of the signer status check response

Author: kantai

stacks-signer/src/runloop.rs

@@ -500,6 +500,38 @@ impl<Signer: SignerTrait<T>, T: StacksMessageCodec + Clone + Send + Debug>
             "Running one pass for the signer. state={:?}, event={event:?}",
             self.state
         );
+
+        // This is the only event that we respond to from the outer signer runloop
+        if let Some(SignerEvent::StatusCheck) = event {
+            let state_info = StateInfo {
+                runloop_state: self.state,
+                reward_cycle_info: self.current_reward_cycle_info,
+                running_signers: self
+                    .stacks_signers
+                    .values()
+                    .map(|s| s.reward_cycle())
+                    .collect(),
+                signer_state_machines: self
+                    .stacks_signers
+                    .iter()
+                    .map(|(reward_cycle, signer)| {
+                        let ConfiguredSigner::RegisteredSigner(ref signer) = signer else {
+                            return (*reward_cycle, None);
+                        };
+                        (
+                            *reward_cycle,
+                            Some(signer.get_local_state_machine().clone()),
+                        )
+                    })
+                    .collect(),
+            };
+            info!("Signer status check requested: {state_info:?}");
+
+            if let Err(e) = res.send(state_info.into()) {
+                error!("Failed to send status check result: {e}.");
+            }
+        }
+
         if self.state == State::Uninitialized {
             if let Err(e) = self.initialize_runloop() {
                 error!("Failed to initialize signer runloop: {e}.");
@@ -514,6 +546,7 @@ impl<Signer: SignerTrait<T>, T: StacksMessageCodec + Clone + Send + Debug>
                 warn!("Signer may have an outdated view of the network.");
             }
         }
+
         let current_reward_cycle = self
             .current_reward_cycle_info
             .as_ref()
@@ -534,37 +567,6 @@ impl<Signer: SignerTrait<T>, T: StacksMessageCodec + Clone + Send + Debug>
             );
         }
 
-        // This is the only event that we respond to from the outer signer runloop
-        if let Some(SignerEvent::StatusCheck) = event {
-            let state_info = StateInfo {
-                runloop_state: self.state,
-                reward_cycle_info: self.current_reward_cycle_info,
-                running_signers: self
-                    .stacks_signers
-                    .values()
-                    .map(|s| s.reward_cycle())
-                    .collect(),
-                signer_state_machines: self
-                    .stacks_signers
-                    .iter()
-                    .map(|(reward_cycle, signer)| {
-                        let ConfiguredSigner::RegisteredSigner(ref signer) = signer else {
-                            return (*reward_cycle, None);
-                        };
-                        (
-                            *reward_cycle,
-                            Some(signer.get_local_state_machine().clone()),
-                        )
-                    })
-                    .collect(),
-            };
-            info!("Signer status check requested: {state_info:?}");
-
-            if let Err(e) = res.send(state_info.into()) {
-                error!("Failed to send status check result: {e}.");
-            }
-        }
-
         if self.state == State::NoRegisteredSigners && event.is_some() {
             let next_reward_cycle = current_reward_cycle.saturating_add(1);
             info!("Signer is not registered for the current reward cycle ({current_reward_cycle}). Reward set is not yet determined or signer is not registered for the upcoming reward cycle ({next_reward_cycle}).");

testnet/stacks-node/src/tests/signer/mod.rs

@@ -455,40 +455,46 @@ impl<S: Signer<T> + Send + 'static, T: SignerEventTrait + 'static> SignerTest<Sp
         let info_cur = self.get_peer_info();
         let current_rc = self.get_current_reward_cycle();
         let mut states = Vec::with_capacity(0);
-        wait_for(120, || {
-            states = self.get_all_states();
-            Ok(states.iter().enumerate().all(|(ix, signer_state)| {
-                let Some(Some(state_machine)) = signer_state
-                    .signer_state_machines
-                    .iter()
-                    .find_map(|(rc, state)| {
-                        if current_rc % 2 == *rc {
-                            Some(state.as_ref())
-                        } else {
-                            None
-                        }
-                    })
-                else {
-                    let rcs_set: Vec<_> = signer_state.signer_state_machines.iter().map(|(rc, state)| {
-                          (rc, state.is_some())
+        // fetch all the state machines *twice*
+        //  we do this because the state machines return before the signer runloop
+        //  invokes run_one_pass(), which is necessary to handle any pending updates to
+        //  the state machine.
+        // we get around this by just doing this twice
+        for _i in 0..2 {
+            wait_for(120, || {
+                states = self.get_all_states();
+                Ok(states.iter().enumerate().all(|(ix, signer_state)| {
+                    let Some(Some(state_machine)) = signer_state
+                        .signer_state_machines
+                        .iter()
+                        .find_map(|(rc, state)| {
+                            if current_rc % 2 == *rc {
+                                Some(state.as_ref())
+                            } else {
+                                None
+                            }
+                        })
+                    else {
+                        let rcs_set: Vec<_> = signer_state.signer_state_machines.iter().map(|(rc, state)| {
+                            (rc, state.is_some())
                         }).collect();
-                    warn!(
-                        "Local state machine for signer #{ix} not set for reward cycle #{current_rc} yet";
-                        "burn_block_height" => info_cur.burn_block_height,
-                        "rcs_set" => ?rcs_set
-                    );
-                    return false;
-                };
-
-                let LocalStateMachine::Initialized(state_machine) = state_machine else {
-                    warn!("Local state machine for signer #{ix} not initialized");
-                    return false;
-                };
-                state_machine.burn_block_height >= info_cur.burn_block_height
-            }))
-
-        })
-        .expect("Timed out while waiting to fetch local state machines from the signer set");
+                        warn!(
+                            "Local state machine for signer #{ix} not set for reward cycle #{current_rc} yet";
+                            "burn_block_height" => info_cur.burn_block_height,
+                            "rcs_set" => ?rcs_set
+                        );
+                        return false;
+                    };
+
+                    let LocalStateMachine::Initialized(state_machine) = state_machine else {
+                        warn!("Local state machine for signer #{ix} not initialized");
+                        return false;
+                    };
+                    state_machine.burn_block_height >= info_cur.burn_block_height
+                }))
+            })
+                .expect("Timed out while waiting to fetch local state machines from the signer set");
+        }
 
         let state_machines = states
             .into_iter()