add migration state to nexus API

Author: hawkw

clients/sled-agent-client/src/lib.rs

@@ -315,6 +315,7 @@ impl From<types::SledInstanceState>
             instance_state: s.instance_state.into(),
             propolis_id: s.propolis_id,
             vmm_state: s.vmm_state.into(),
+            migration_state: None,
         }
     }
 }

common/src/api/internal/nexus.rs

@@ -16,6 +16,7 @@ use omicron_uuid_kinds::UpstairsSessionKind;
 use parse_display::{Display, FromStr};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use std::fmt;
 use std::net::SocketAddr;
 use std::time::Duration;
 use strum::{EnumIter, IntoEnumIterator};
@@ -83,6 +84,47 @@ pub struct SledInstanceState {
 
     /// The most recent state of the sled's VMM process.
     pub vmm_state: VmmRuntimeState,
+
+    /// The current state of any in-progress migration for this instance, as
+    /// understood by this sled.
+    pub migration_state: Option<MigrationRuntimeState>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
+pub struct MigrationRuntimeState {
+    pub migration_id: Uuid,
+
+    pub state: MigrationState,
+}
+
+/// The state of an instance's live migration.
+#[derive(
+    Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema,
+)]
+#[serde(rename_all = "snake_case")]
+pub enum MigrationState {
+    /// The migration is in progress.
+    InProgress,
+    /// The migration has failed.
+    Failed,
+    /// The migration has completed.
+    Completed,
+}
+
+impl MigrationState {
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::InProgress => "in_progress",
+            Self::Completed => "completed",
+            Self::Failed => "failed",
+        }
+    }
+}
+
+impl fmt::Display for MigrationState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.label())
+    }
 }
 
 // Oximeter producer/collector objects.

nexus/db-model/src/migration_state.rs

@@ -4,39 +4,36 @@
 
 //! Database representation of a migration's state as understood by Nexus.
 
-use super::impl_enum_type;
-use serde::{Deserialize, Serialize};
+use super::impl_enum_wrapper;
+use omicron_common::api::internal::nexus;
+use serde::Deserialize;
+use serde::Serialize;
 use std::fmt;
+use std::io::Write;
 
-impl_enum_type!(
+impl_enum_wrapper!(
     #[derive(Clone, SqlType, Debug, QueryId)]
     #[diesel(postgres_type(name = "migration_state", schema = "public"))]
     pub struct MigrationStateEnum;
 
     #[derive(Clone, Copy, Debug, AsExpression, FromSqlRow, Serialize, Deserialize, PartialEq, Eq)]
     #[diesel(sql_type = MigrationStateEnum)]
-     // match the database representation when serializing
-    #[serde(rename_all = "snake_case")]
-    pub enum MigrationState;
+    pub struct MigrationState(pub nexus::MigrationState);
 
     // Enum values
     InProgress => b"in_progress"
     Completed => b"completed"
     Failed => b"failed"
 );
 
-impl MigrationState {
-    pub fn label(&self) -> &'static str {
-        match self {
-            Self::InProgress => "in_progress",
-            Self::Completed => "completed",
-            Self::Failed => "failed",
-        }
+impl fmt::Display for MigrationState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
     }
 }
 
-impl fmt::Display for MigrationState {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.label())
+impl From<nexus::MigrationState> for MigrationState {
+    fn from(s: nexus::MigrationState) -> Self {
+        Self(s)
     }
 }

sled-agent/src/common/instance.rs

@@ -229,6 +229,7 @@ impl InstanceStates {
             instance_state: self.instance.clone(),
             vmm_state: self.vmm.clone(),
             propolis_id: self.propolis_id,
+            migration_state: None, // TODO(eliza): add this
         }
     }
 

sled-agent/src/sim/collection.rs

@@ -451,6 +451,7 @@ mod test {
             instance_state: instance_vmm,
             vmm_state,
             propolis_id,
+            migration_state: None,
         };
 
         SimObject::new_simulated_auto(&state, logctx.log.new(o!()))

sled-agent/src/sim/sled_agent.rs

@@ -341,6 +341,7 @@ impl SledAgent {
                     instance_state: instance_runtime,
                     vmm_state: vmm_runtime,
                     propolis_id,
+                    migration_state: None,
                 },
                 None,
             )