feat: manage multiple ssh machines from one client (#3670)

1 files changed, 161 insertions, 0 deletions

diff --git a/src/remote/restart_policy.rs b/src/remote/restart_policy.rs
new file mode 100644
index 00000000..757efcc5
--- /dev/null
+++ b/src/remote/restart_policy.rs
@@ -0,0 +1,161 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum RemoteServerRestartReason {
+    EndpointProtocol,
+    SurfaceInterest,
+    HealthCheck,
+    DaemonDetach,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum RemoteInstallRunningServerPlan {
+    KeepRunning,
+    LiveHandoff,
+    StopRequired(RemoteServerRestartReason),
+}
+
+pub(super) fn remote_server_restart_reason(
+    endpoint_protocol_generation: Option<u32>,
+    detached_server_daemon: bool,
+    require_surface_interest: bool,
+    surface_interest: bool,
+    health_check: bool,
+) -> Option<RemoteServerRestartReason> {
+    if endpoint_protocol_generation != Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION)
+    {
+        return Some(RemoteServerRestartReason::EndpointProtocol);
+    }
+    if require_surface_interest && !surface_interest {
+        return Some(RemoteServerRestartReason::SurfaceInterest);
+    }
+    if require_surface_interest && !health_check {
+        return Some(RemoteServerRestartReason::HealthCheck);
+    }
+    if !detached_server_daemon {
+        return Some(RemoteServerRestartReason::DaemonDetach);
+    }
+    None
+}
+
+pub(super) fn remote_install_running_server_plan(
+    endpoint_protocol_generation: Option<u32>,
+    detached_server_daemon: bool,
+    surface_interest: bool,
+    health_check: bool,
+    live_handoff: bool,
+    live_handoff_enabled: bool,
+    require_surface_interest: bool,
+) -> RemoteInstallRunningServerPlan {
+    let Some(reason) = remote_server_restart_reason(
+        endpoint_protocol_generation,
+        detached_server_daemon,
+        require_surface_interest,
+        surface_interest,
+        health_check,
+    ) else {
+        return RemoteInstallRunningServerPlan::KeepRunning;
+    };
+
+    if live_handoff_enabled && live_handoff {
+        return RemoteInstallRunningServerPlan::LiveHandoff;
+    }
+    RemoteInstallRunningServerPlan::StopRequired(reason)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pre_floor_server_requires_update() {
+        assert_eq!(
+            remote_server_restart_reason(None, true, false, false, false),
+            Some(RemoteServerRestartReason::EndpointProtocol)
+        );
+    }
+
+    #[test]
+    fn compatible_server_can_keep_running() {
+        assert_eq!(
+            remote_server_restart_reason(
+                Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION),
+                true,
+                false,
+                false,
+                false
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn saved_endpoint_requires_surface_interest() {
+        assert_eq!(
+            remote_server_restart_reason(
+                Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION),
+                true,
+                true,
+                false,
+                false
+            ),
+            Some(RemoteServerRestartReason::SurfaceInterest)
+        );
+    }
+
+    #[test]
+    fn saved_endpoint_requires_health_checks() {
+        assert_eq!(
+            remote_server_restart_reason(
+                Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION),
+                true,
+                true,
+                true,
+                false
+            ),
+            Some(RemoteServerRestartReason::HealthCheck)
+        );
+    }
+
+    #[test]
+    fn saved_endpoint_accepts_complete_lifecycle_support() {
+        assert_eq!(
+            remote_server_restart_reason(
+                Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION),
+                true,
+                true,
+                true,
+                true
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn old_daemon_requires_restart() {
+        assert_eq!(
+            remote_server_restart_reason(
+                Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION),
+                false,
+                false,
+                false,
+                false
+            ),
+            Some(RemoteServerRestartReason::DaemonDetach)
+        );
+    }
+
+    #[test]
+    fn saved_endpoint_can_explicitly_live_handoff_for_surface_support() {
+        assert_eq!(
+            remote_install_running_server_plan(
+                Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION),
+                true,
+                false,
+                false,
+                true,
+                true,
+                true
+            ),
+            RemoteInstallRunningServerPlan::LiveHandoff
+        );
+    }
+}