migrator finished

bin/migrator/src/legacy/v0/mod.rs

@@ -157,6 +157,58 @@ pub enum Operation {
   AutoPull,
 }
 
+impl From<Operation> for monitor_types::entities::Operation {
+  fn from(value: Operation) -> Self {
+    use monitor_types::entities::Operation::*;
+    match value {
+      Operation::None => None,
+      Operation::CreateServer => CreateServer,
+      Operation::UpdateServer => UpdateServer,
+      Operation::DeleteServer => DeleteServer,
+      Operation::PruneImagesServer => PruneImagesServer,
+      Operation::PruneContainersServer => PruneContainersServer,
+      Operation::PruneNetworksServer => PruneNetworksServer,
+      Operation::RenameServer => RenameServer,
+      Operation::CreateBuild => CreateBuild,
+      Operation::UpdateBuild => UpdateBuild,
+      Operation::DeleteBuild => DeleteBuild,
+      Operation::BuildBuild => RunBuild,
+      Operation::CreateDeployment => CreateDeployment,
+      Operation::UpdateDeployment => UpdateDeployment,
+      Operation::DeleteDeployment => DeleteDeployment,
+      Operation::DeployContainer => DeployContainer,
+      Operation::StopContainer => StopContainer,
+      Operation::StartContainer => StartContainer,
+      Operation::RemoveContainer => RemoveContainer,
+      Operation::PullDeployment => None,
+      Operation::RecloneDeployment => None,
+      Operation::RenameDeployment => RenameDeployment,
+      Operation::CreateProcedure => None,
+      Operation::UpdateProcedure => None,
+      Operation::DeleteProcedure => None,
+      Operation::CreateCommand => None,
+      Operation::UpdateCommand => None,
+      Operation::DeleteCommand => None,
+      Operation::RunCommand => None,
+      Operation::CreateGroup => None,
+      Operation::UpdateGroup => None,
+      Operation::DeleteGroup => None,
+      Operation::ModifyUserEnabled => UpdateUserPermissions,
+      Operation::ModifyUserCreateServerPermissions => {
+        UpdateUserPermissions
+      }
+      Operation::ModifyUserCreateBuildPermissions => {
+        UpdateUserPermissions
+      }
+      Operation::ModifyUserPermissions => {
+        UpdateUserPermissionsOnTarget
+      }
+      Operation::AutoBuild => AutoBuild,
+      Operation::AutoPull => AutoPull,
+    }
+  }
+}
+
 #[derive(
   Serialize,
   Deserialize,

bin/migrator/src/legacy/v0/update.rs

@@ -1,8 +1,10 @@
+use monitor_types::entities::update::ResourceTarget;
 use mungos::mongodb::bson::serde_helpers::hex_string_as_object_id;
 use serde::{Deserialize, Serialize};
 
 use super::{
-  Build, Deployment, Group, Operation, Procedure, Server, Version,
+  unix_from_monitor_ts, Build, Deployment, Group, Operation,
+  Procedure, Server, Version,
 };
 
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
@@ -26,6 +28,34 @@ pub struct Update {
   pub version: Option<Version>,
 }
 
+impl TryFrom<Update> for monitor_types::entities::update::Update {
+  type Error = anyhow::Error;
+  fn try_from(value: Update) -> Result<Self, Self::Error> {
+    let target: Option<ResourceTarget> = value.target.into();
+    let update = Self {
+      id: value.id,
+      operation: value.operation.into(),
+      start_ts: unix_from_monitor_ts(&value.start_ts)?,
+      success: value.success,
+      operator: value.operator,
+      target: target.unwrap_or_default(),
+      logs: value
+        .logs
+        .into_iter()
+        .map(|log| log.try_into())
+        .collect::<anyhow::Result<
+        Vec<monitor_types::entities::update::Log>,
+      >>()?,
+      end_ts: value
+        .end_ts
+        .and_then(|ts| unix_from_monitor_ts(&ts).ok()),
+      status: value.status.into(),
+      version: value.version.map(|v| v.into()).unwrap_or_default(),
+    };
+    Ok(update)
+  }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct Log {
   pub stage: String,
@@ -37,6 +67,21 @@ pub struct Log {
   pub end_ts: String,
 }
 
+impl TryFrom<Log> for monitor_types::entities::update::Log {
+  type Error = anyhow::Error;
+  fn try_from(value: Log) -> Result<Self, Self::Error> {
+    Ok(Self {
+      stage: value.stage,
+      command: value.command,
+      stdout: value.stdout,
+      stderr: value.stderr,
+      success: value.success,
+      start_ts: unix_from_monitor_ts(&value.start_ts)?,
+      end_ts: unix_from_monitor_ts(&value.end_ts)?,
+    })
+  }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 #[serde(tag = "type", content = "id")]
 pub enum UpdateTarget {
@@ -50,63 +95,20 @@ pub enum UpdateTarget {
   Command(String),
 }
 
-impl From<&Build> for UpdateTarget {
-  fn from(build: &Build) -> Self {
-    Self::Build(build.id.clone())
-  }
-}
-
-impl From<&Build> for Option<UpdateTarget> {
-  fn from(build: &Build) -> Self {
-    Some(UpdateTarget::Build(build.id.clone()))
-  }
-}
-
-impl From<&Deployment> for UpdateTarget {
-  fn from(deployment: &Deployment) -> Self {
-    Self::Deployment(deployment.id.clone())
-  }
-}
-
-impl From<&Deployment> for Option<UpdateTarget> {
-  fn from(deployment: &Deployment) -> Self {
-    Some(UpdateTarget::Deployment(deployment.id.clone()))
-  }
-}
-
-impl From<&Server> for UpdateTarget {
-  fn from(server: &Server) -> Self {
-    Self::Server(server.id.clone())
-  }
-}
-
-impl From<&Server> for Option<UpdateTarget> {
-  fn from(server: &Server) -> Self {
-    Some(UpdateTarget::Server(server.id.clone()))
-  }
-}
-
-impl From<&Procedure> for UpdateTarget {
-  fn from(procedure: &Procedure) -> Self {
-    Self::Procedure(procedure.id.clone())
-  }
-}
-
-impl From<&Procedure> for Option<UpdateTarget> {
-  fn from(procedure: &Procedure) -> Self {
-    Some(UpdateTarget::Procedure(procedure.id.clone()))
-  }
-}
-
-impl From<&Group> for UpdateTarget {
-  fn from(group: &Group) -> Self {
-    Self::Group(group.id.clone())
-  }
-}
-
-impl From<&Group> for Option<UpdateTarget> {
-  fn from(group: &Group) -> Self {
-    Some(UpdateTarget::Group(group.id.clone()))
+impl From<UpdateTarget>
+  for Option<monitor_types::entities::update::ResourceTarget>
+{
+  fn from(value: UpdateTarget) -> Self {
+    use monitor_types::entities::update::ResourceTarget::*;
+    match value {
+      UpdateTarget::System => Some(System("system".to_string())),
+      UpdateTarget::Build(id) => Some(Build(id)),
+      UpdateTarget::Deployment(id) => Some(Deployment(id)),
+      UpdateTarget::Server(id) => Some(Server(id)),
+      UpdateTarget::Procedure(_) => None,
+      UpdateTarget::Group(_) => None,
+      UpdateTarget::Command(id) => None,
+    }
   }
 }
 
@@ -128,3 +130,16 @@ pub enum UpdateStatus {
   #[default]
   Complete,
 }
+
+impl From<UpdateStatus>
+  for monitor_types::entities::update::UpdateStatus
+{
+  fn from(value: UpdateStatus) -> Self {
+    use monitor_types::entities::update::UpdateStatus::*;
+    match value {
+      UpdateStatus::Queued => Queued,
+      UpdateStatus::InProgress => InProgress,
+      UpdateStatus::Complete => Complete,
+    }
+  }
+}

bin/migrator/src/main.rs

@@ -17,5 +17,7 @@ async fn main() -> anyhow::Result<()> {
 
   let state = State::load().await?;
 
+  state.migrate_all().await?;
+
   Ok(())
 }

bin/migrator/src/migrate.rs

@@ -1,6 +1,10 @@
+use anyhow::Context;
 use monitor_types::entities::{
+  build::Build,
   deployment::{Deployment, DeploymentConfig},
-  update::ResourceTarget,
+  server::Server,
+  update::{ResourceTarget, Update},
+  user::User,
 };
 use mungos::Indexed;
 
@@ -10,15 +14,155 @@ use crate::{
 };
 
 impl State {
-  pub async fn migrate_servers(
-    &self,
-    legacy_db: &str,
-    target_db: &str,
-  ) -> anyhow::Result<()> {
-    let source = self
-      .legacy_mungos
-      .collection::<v0::Deployment>(legacy_db, "deployments");
+  pub async fn migrate_all(&self) -> anyhow::Result<()> {
+    self.migrate_users().await?;
+    self.migrate_servers().await?;
+    self.migrate_deployments().await?;
+    self.migrate_builds().await?;
+    self.migrate_updates().await?;
+    Ok(())
+  }
 
-    todo!()
+  pub async fn migrate_users(&self) -> anyhow::Result<()> {
+    let users = self
+      .legacy
+      .users
+      .get_some(None, None)
+      .await
+      .context("failed to get legacy users")?
+      .into_iter()
+      .map(|s| {
+        let context =
+          format!("failed to convert user {}", s.username);
+        s.try_into().context(context)
+      })
+      .collect::<anyhow::Result<Vec<User>>>()?;
+
+    info!("migrating {} users...", users.len());
+
+    self
+      .target
+      .users
+      .create_many(users)
+      .await
+      .context("failed to create users on target")?;
+
+    info!("users have been migrated\n");
+
+    Ok(())
+  }
+
+  pub async fn migrate_servers(&self) -> anyhow::Result<()> {
+    let servers = self
+      .legacy
+      .servers
+      .get_some(None, None)
+      .await
+      .context("failed to get legacy servers")?
+      .into_iter()
+      .map(|s| {
+        let context = format!("failed to convert server {}", s.name);
+        s.try_into().context(context)
+      })
+      .collect::<anyhow::Result<Vec<Server>>>()?;
+
+    info!("migrating {} servers...", servers.len());
+
+    self
+      .target
+      .servers
+      .create_many(servers)
+      .await
+      .context("failed to create servers on target")?;
+
+    info!("servers have been migrated\n");
+
+    Ok(())
+  }
+
+  pub async fn migrate_deployments(&self) -> anyhow::Result<()> {
+    let deployments = self
+      .legacy
+      .deployments
+      .get_some(None, None)
+      .await
+      .context("failed to get legacy deployments")?
+      .into_iter()
+      .map(|s| {
+        let context =
+          format!("failed to convert deployment {}", s.name);
+        s.try_into().context(context)
+      })
+      .collect::<anyhow::Result<Vec<Deployment>>>()?;
+
+    info!("migrating {} deployments...", deployments.len());
+
+    self
+      .target
+      .deployments
+      .create_many(deployments)
+      .await
+      .context("failed to create deployments on target")?;
+
+    info!("deployments have been migrated\n");
+
+    Ok(())
+  }
+
+  pub async fn migrate_builds(&self) -> anyhow::Result<()> {
+    let builds = self
+      .legacy
+      .builds
+      .get_some(None, None)
+      .await
+      .context("failed to get legacy builds")?
+      .into_iter()
+      .map(|s| {
+        let context = format!("failed to convert build {}", s.name);
+        s.try_into().context(context)
+      })
+      .collect::<anyhow::Result<Vec<Build>>>()?;
+
+    info!("migrating {} builds...", builds.len());
+
+    self
+      .target
+      .builds
+      .create_many(builds)
+      .await
+      .context("failed to create builds on target")?;
+
+    info!("builds have been migrated\n");
+
+    Ok(())
+  }
+
+  pub async fn migrate_updates(&self) -> anyhow::Result<()> {
+    let updates = self
+      .legacy
+      .updates
+      .get_some(None, None)
+      .await
+      .context("failed to get legacy updates")?
+      .into_iter()
+      .map(|s| {
+        let context =
+          format!("failed to convert update | _id {}", s.id);
+        s.try_into().context(context)
+      })
+      .collect::<anyhow::Result<Vec<Update>>>()?;
+
+    info!("migrating {} updates...", updates.len());
+
+    self
+      .target
+      .updates
+      .create_many(updates)
+      .await
+      .context("failed to create updates on target")?;
+
+    info!("updates have been migrated\n");
+
+    Ok(())
   }
 }

bin/migrator/src/state.rs

@@ -14,7 +14,7 @@ struct Env {
 }
 
 pub struct State {
-  pub legacy_mungos: Mungos,
+  pub legacy: LegacyDbClient,
   pub target: DbClient,
 }
 
@@ -27,7 +27,10 @@ impl State {
     let target_mungos =
       Mungos::builder().uri(&env.target_uri).build().await?;
     let state = State {
-      legacy_mungos,
+      legacy: LegacyDbClient::new(
+        &legacy_mungos,
+        &env.legacy_db_name,
+      ),
       target: DbClient::new(&MongoConfig {
         uri: Some(env.target_uri),
         db_name: env.target_db_name,
@@ -47,3 +50,15 @@ pub struct LegacyDbClient {
   pub builds: Collection<Build>,
   pub updates: Collection<Update>,
 }
+
+impl LegacyDbClient {
+  pub fn new(mungos: &Mungos, db_name: &str) -> LegacyDbClient {
+    LegacyDbClient {
+      users: mungos.collection(db_name, "users"),
+      servers: mungos.collection(db_name, "servers"),
+      deployments: mungos.collection(db_name, "deployments"),
+      builds: mungos.collection(db_name, "builds"),
+      updates: mungos.collection(db_name, "updates"),
+    }
+  }
+}