Return conflict for duplicate encryption-network creation

tinycloud-core/src/encryption_network/service.rs

@@ -9,7 +9,12 @@
 use std::sync::Arc;
 
 use base64::{engine::general_purpose::STANDARD, Engine as _};
-use sea_orm::{ActiveModelTrait, ActiveValue::Set, ColumnTrait, DbErr, EntityTrait, QueryFilter};
+use sea_orm::{
+    error::{RuntimeErr, SqlxError},
+    ActiveModelTrait,
+    ActiveValue::Set,
+    ColumnTrait, DbErr, EntityTrait, QueryFilter,
+};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use thiserror::Error;
@@ -450,7 +455,43 @@ impl EncryptionService {
             created_at: Set(now.clone()),
             updated_at: Set(now.clone()),
         };
-        model.insert(&self.db).await?;
+        if let Err(err) = model.insert(&self.db).await {
+            if is_supported_unique_violation(&err) {
+                let finalize_result: Result<bool, DbErr> = async {
+                    let Some(ceremony) =
+                        encryption_ceremony::Entity::find_by_id(ceremony_id.clone())
+                            .one(&self.db)
+                            .await?
+                    else {
+                        return Ok(false);
+                    };
+                    let mut ceremony_active: encryption_ceremony::ActiveModel = ceremony.into();
+                    ceremony_active.state = Set("failed".to_string());
+                    ceremony_active.failure = Set(Some("network_already_exists".to_string()));
+                    ceremony_active.completed_at = Set(Some(now_rfc3339()));
+                    ceremony_active.update(&self.db).await?;
+                    Ok(true)
+                }
+                .await;
+                match finalize_result {
+                    Ok(true) => {}
+                    Ok(false) => tracing::warn!(
+                        target: "tinycloud::encryption_network",
+                        event = "network_create_conflict_ceremony_update_failed",
+                        failure_kind = "missing_record",
+                        "could not mark losing network create ceremony as failed"
+                    ),
+                    Err(_) => tracing::warn!(
+                        target: "tinycloud::encryption_network",
+                        event = "network_create_conflict_ceremony_update_failed",
+                        failure_kind = "database_error",
+                        "could not mark losing network create ceremony as failed"
+                    ),
+                }
+                return Err(EncryptionServiceError::NetworkAlreadyExists);
+            }
+            return Err(err.into());
+        }
 
         encryption_network_member::ActiveModel {
             network_id: Set(network_id.to_string()),
@@ -1526,12 +1567,22 @@ pub(super) fn now_rfc3339() -> String {
         .format(&Rfc3339)
         .unwrap_or_else(|_| "1970-01-01T00:00:00Z".to_string())
 }
-
 pub(super) fn is_unique_violation(err: &DbErr) -> bool {
     let s = err.to_string().to_lowercase();
     s.contains("unique") || s.contains("primary") || s.contains("duplicate")
 }
 
+fn is_supported_unique_violation(err: &DbErr) -> bool {
+    let (DbErr::Conn(RuntimeErr::SqlxError(SqlxError::Database(database)))
+    | DbErr::Exec(RuntimeErr::SqlxError(SqlxError::Database(database)))
+    | DbErr::Query(RuntimeErr::SqlxError(SqlxError::Database(database)))) = err
+    else {
+        return false;
+    };
+
+    matches!(database.code().as_deref(), Some("23505" | "1555" | "2067"))
+}
+
 fn encode_base64(bytes: &[u8]) -> String {
     STANDARD.encode(bytes)
 }