Remove separate auto_promote, which is deterministic from up_state

upstairs/src/client.rs

@@ -548,23 +548,25 @@ impl DownstairsClient {
     ///
     /// # Panics
     /// If `self.client_task` is not `None`, or `self.target_addr` is `None`
-    pub(crate) fn reinitialize(
-        &mut self,
-        up_state: &UpstairsState,
-        auto_promote: bool,
-    ) {
+    pub(crate) fn reinitialize(&mut self, up_state: &UpstairsState) {
         // Clear this Downstair's repair address, and let the YesItsMe set it.
         // This works if this Downstairs is new, reconnecting, or was replaced
         // entirely; the repair address could have changed in any of these
         // cases.
         self.repair_addr = None;
         self.needs_replay = false;
 
-        if auto_promote {
-            self.promote_state = Some(PromoteState::Waiting);
-        } else {
-            self.promote_state = None;
-        }
+        // If the upstairs is already active (or trying to go active), then the
+        // downstairs should automatically call PromoteToActive when it reaches
+        // the relevant state.
+        self.promote_state = match up_state {
+            UpstairsState::Active | UpstairsState::GoActive(..) => {
+                Some(PromoteState::Waiting)
+            }
+            UpstairsState::Initializing
+            | UpstairsState::Deactivating { .. } => None,
+        };
+
         self.negotiation_state = NegotiationState::Start;
 
         let current = &self.state;
@@ -595,8 +597,8 @@ impl DownstairsClient {
 
         self.connection_id.update();
 
-        // Restart with a short delay
-        self.start_task(true, auto_promote);
+        // Restart with a short delay, connecting if we're auto-promoting
+        self.start_task(true, self.promote_state.is_some());
     }
 
     /// Sets the `needs_replay` flag

upstairs/src/downstairs.rs

@@ -505,7 +505,6 @@ impl Downstairs {
     pub(crate) fn reinitialize(
         &mut self,
         client_id: ClientId,
-        auto_promote: bool,
         up_state: &UpstairsState,
     ) {
         // If the IO task stops on its own, then under certain circumstances,
@@ -522,7 +521,7 @@ impl Downstairs {
 
         // Restart the IO task for that specific client, transitioning to a new
         // state.
-        self.clients[client_id].reinitialize(up_state, auto_promote);
+        self.clients[client_id].reinitialize(up_state);
 
         for i in ClientId::iter() {
             // Clear per-client delay, because we're starting a new session

upstairs/src/upstairs.rs

@@ -2008,17 +2008,8 @@ impl Upstairs {
         self.downstairs
             .notify_nexus_of_client_task_stopped(client_id, reason);
 
-        // If the upstairs is already active (or trying to go active), then the
-        // downstairs should automatically call PromoteToActive when it reaches
-        // the relevant state.
-        let auto_promote = match self.state {
-            UpstairsState::Active | UpstairsState::GoActive(..) => true,
-            UpstairsState::Initializing
-            | UpstairsState::Deactivating { .. } => false,
-        };
-
         self.downstairs
-            .reinitialize(client_id, auto_promote, &self.state);
+            .reinitialize(client_id, &self.state);
     }
 
     /// Sets both guest and per-client backpressure