fix(#806): fixed restart behavior of hanami and sakura

In case the a hanami- or sakura-host was restarted, there
remained dead cluster and also dead hosts. The registration-
process between hanami and sakura was now fixed that a restart
of hanami doesn't break existing resources anymore and when
a sakura-instance is restarted, the meta-clusters are updated
correctly in hanami now. Also duplications of registered hosts
were now fixed.

Signed-off-by: Tobias Anker <tobias.anker@kitsunemimi.moe>

Author: kitsudaiki

.github/workflows/build_test.yml

@@ -1027,8 +1027,6 @@ jobs:
           echo "$ingress_ip_ryokan  local-ryokan" | sudo tee -a /etc/hosts
           ingress_ip_torii=$(kubectl get ingress torii-ingress -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
           echo "$ingress_ip_torii  local-torii" | sudo tee -a /etc/hosts
-          ingress_ip_sakura=$(kubectl get ingress sakura-ingress -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
-          echo "$ingress_ip_sakura  local-sakura" | sudo tee -a /etc/hosts
           ingress_ip_omamori=$(kubectl get ingress omamori-ingress -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
           echo "$ingress_ip_omamori  local-omamori" | sudo tee -a /etc/hosts
           cat /etc/hosts

.secrets.baseline

@@ -604,5 +604,5 @@
       }
     ]
   },
-  "generated_at": "2026-01-04T20:37:39Z"
+  "generated_at": "2026-01-11T17:41:38Z"
 }

CHANGELOG.md

@@ -29,6 +29,8 @@
 ### Fixed
 
 - fixed broken version-output of the pre-build docker images
+- restart of hanami and sakura instance in regard of the cluster was now fixed to avoid broken cluster and hosts after restart
+- restarts of the same sakura-host doesn't result in duplications in hanami anymore
 
 
 ## v0.10.0

example_configs/ainari/torii.toml

@@ -16,4 +16,4 @@ address = "http://127.0.0.1:11417"
 
 [ports]
 min_port = 10042
-max_port = 10043
+max_port = 10053

src/binaries/hanami/src/api/http_endpoints/sakura_host/register_host_internal_v1_0.rs

@@ -20,6 +20,7 @@ use validator::Validate;
 
 use crate::config;
 use crate::database::host_table;
+use crate::database::meta_cluster_table;
 
 use ainari_api::common_functions::*;
 use ainari_api::errors::ErrorResponse;
@@ -42,7 +43,7 @@ pub async fn register_host_internal(
     body.validate()
         .map_err(|e| ErrorResponse::BadRequest(format!("Invalid input: {e}")))?;
 
-    let host_uuid = Uuid::new_v4();
+    let mut host_uuid = Uuid::new_v4();
 
     // check registration key
     let conf_registration_key = &config::SAKURA_REGISTRATION_KEY.clone();
@@ -52,13 +53,29 @@ pub async fn register_host_internal(
         ));
     }
 
-    // add new host to database
-    host_table::add_new_host(&host_uuid, &body.name, &body.host_address, &context).map_err(
-        |e| {
-            log::error!("Failed to add host with UUID '{host_uuid}' to database with error: {e}.");
-            ErrorResponse::InternalError("Internal Error".to_string())
-        },
-    )?;
+    match host_table::get_host_by_address(&body.host_address, &context) {
+        Ok(host_data) => {
+            host_uuid = convert_uuid(&host_data.uuid)?;
+        }
+        Err(_) => {
+            // add new host to database if address not already exist
+            host_table::add_new_host(&host_uuid, &body.name, &body.host_address, &context)
+                .map_err(|e| {
+                    log::error!(
+                        "Failed to add host with UUID '{host_uuid}' to database with error: {e}."
+                    );
+                    ErrorResponse::InternalError("Internal Error".to_string())
+                })?;
+        }
+    };
+
+    // delete all cluster in the meta-table too, which are marked by the new host as deleted
+    for uuid in &body.deleted_uuids.list {
+        // if the deletion failed, it is most likely because the uuid is already deleted in hanami
+        // because of this, we ignore the response from the database at the moment
+        // TODO: handle response to filter the case that the uuid is already deleted
+        let _ = meta_cluster_table::force_delete_meta_cluster(uuid);
+    }
 
     // get new created host from database to get addtional information
     let host_data = host_table::get_host(&host_uuid, &context)

src/binaries/hanami/src/database/host_table.rs

@@ -102,6 +102,30 @@ pub fn add_host(host: &HostEntry) -> QueryResult<usize> {
     diesel::insert_into(hosts).values(host).execute(&mut *conn)
 }
 
+pub fn get_host_by_address(
+    host_address: &String,
+    _: &UserContext,
+) -> Result<HostEntry, enums::DbError> {
+    let mut conn = db_handle::DB_CONN.lock().expect("mutex poisoned");
+    use self::hosts::dsl::*;
+
+    let query = hosts
+        .filter(name.eq(host_address.to_string()).and(status.eq("ACTIVE")))
+        .into_boxed();
+
+    match query
+        .select(HostEntry::as_select())
+        .first::<HostEntry>(&mut *conn)
+    {
+        Ok(host) => Ok(host),
+        Err(diesel::result::Error::NotFound) => Err(enums::DbError::NotFound),
+        Err(e) => {
+            log::error!("Database-error: {e:?}");
+            Err(enums::DbError::InternalError)
+        }
+    }
+}
+
 pub fn get_host(host_uuid: &Uuid, _: &UserContext) -> Result<HostEntry, enums::DbError> {
     let mut conn = db_handle::DB_CONN.lock().expect("mutex poisoned");
     use self::hosts::dsl::*;
@@ -154,6 +178,7 @@ pub fn delete_host_admin(host_uuid: &Uuid, context: &UserContext) -> Result<(),
     }
 }
 
+#[allow(dead_code)]
 pub fn delete_all_host() -> Result<(), enums::DbError> {
     let mut conn = db_handle::DB_CONN.lock().expect("mutex poisoned");
     use self::hosts::dsl::*;

src/binaries/hanami/src/database/meta_cluster_table.rs

@@ -176,6 +176,26 @@ pub fn count_meta_clusters(context: &UserContext) -> QueryResult<i64> {
     query.select(count_star()).first::<i64>(&mut *conn)
 }
 
+pub fn force_delete_meta_cluster(meta_cluster_uuid: &Uuid) -> Result<(), enums::DbError> {
+    let mut conn = db_handle::DB_CONN.lock().expect("mutex poisoned");
+    use self::meta_clusters::dsl::*;
+    match diesel::update(meta_clusters.filter(uuid.eq(meta_cluster_uuid.to_string())))
+        .set((
+            status.eq("DELETED"),
+            deleted_at.eq(Utc::now().to_rfc3339()),
+            deleted_by.eq("HOST_INIT"),
+        ))
+        .execute(&mut *conn)
+    {
+        Ok(_) => Ok(()),
+        Err(diesel::result::Error::NotFound) => Err(enums::DbError::NotFound),
+        Err(e) => {
+            log::error!("Database-error: {e:?}");
+            Err(enums::DbError::InternalError)
+        }
+    }
+}
+
 pub fn delete_meta_cluster(
     meta_cluster_uuid: &Uuid,
     context: &UserContext,

src/binaries/hanami/src/database/mod.rs

@@ -16,10 +16,6 @@ pub mod db_handle;
 pub mod host_table;
 pub mod meta_cluster_table;
 
-use std::io;
-
-use ainari_common::enums;
-
 pub fn init_database() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize host-table
     match host_table::init_host_table() {
@@ -39,22 +35,5 @@ pub fn init_database() -> Result<(), Box<dyn std::error::Error>> {
         }
     };
 
-    // clear all host from the database. This is necessary, because after a restart,
-    // all host are broken and so the database doesn't match the real world.
-    // To "fix" this issue, all host have to be removed from the database as well.
-    match host_table::delete_all_host() {
-        Ok(_) => {}
-        Err(enums::DbError::InternalError) => {
-            let msg = "Error while deleting all host from DB".to_string();
-            log::error!("{msg}");
-            let error = io::Error::other(msg);
-            return Err(Box::new(error));
-        }
-        Err(enums::DbError::NotFound) => {
-            let error = io::Error::other("".to_string());
-            return Err(Box::new(error));
-        }
-    }
-
     Ok(())
 }

src/binaries/sakura/src/database/cluster_table.rs

@@ -172,6 +172,15 @@ pub fn get_cluster(
     }
 }
 
+pub fn list_deleted_clusters() -> QueryResult<Vec<ClusterEntry>> {
+    let mut conn = db_handle::DB_CONN.lock().expect("mutex poisoned");
+    use self::clusters::dsl::*;
+
+    let query = clusters.filter(status.eq("DELETED")).into_boxed();
+
+    query.select(ClusterEntry::as_select()).load(&mut *conn)
+}
+
 pub fn list_clusters(context: &UserContext) -> QueryResult<Vec<ClusterEntry>> {
     let mut conn = db_handle::DB_CONN.lock().expect("mutex poisoned");
     use self::clusters::dsl::*;

src/binaries/sakura/src/hanami_interaction.rs

@@ -17,7 +17,10 @@ use tokio::runtime::Builder;
 use tokio::task::LocalSet;
 
 use crate::config;
+use crate::database::cluster_table;
 
+use ainari_api::common_functions::convert_uuid;
+use ainari_api_structs::host_structs::UuidList;
 use ainari_clients::endpoints::*;
 use ainari_clients::host::register_sakura_host;
 use ainari_common::error::AinariError;
@@ -46,12 +49,34 @@ pub fn register_host() -> Result<(), AinariError> {
 
     log::debug!("read host-name: {host_name}");
 
+    let deleted_clusters = match cluster_table::list_deleted_clusters() {
+        Ok(clusters) => clusters,
+        Err(e) => {
+            log::error!("Failed to get list of clusters form database: '{e}'");
+            return Err(AinariError::Error("Internal Error".to_string()));
+        }
+    };
+
+    let mut resp = UuidList { list: Vec::new() };
+
+    for cluster in deleted_clusters {
+        let uuid = match convert_uuid(&cluster.uuid) {
+            Ok(uuid) => uuid,
+            Err(e) => {
+                log::error!("Failed to convert UUID: '{e}'");
+                return Err(AinariError::Error("Internal Error".to_string()));
+            }
+        };
+        resp.list.push(uuid);
+    }
+
     local.block_on(&rt, async {
         register_sakura_host(
             &endpoints.hanami,
             &config::INTERNAL_API_KEY,
             &host_name,
             &config::CONFIG.address,
+            resp,
             &config::SAKURA_REGISTRATION_KEY,
             config::CONFIG.skip_tls_verification,
         )