@kumori/aurora-backend-handler 1.0.78 → 1.0.80

package/api/account-api-service.ts

@@ -319,7 +319,7 @@ export const createAccount = async (account: Account, security: Security) => {
           },
         },
       };
-    } else if (providerName === "oasix"  || providerName === "cloudos") {
+    } else if (providerName === "oasix") {
       accountBody = {
         tenant: account.tenant,
         account: account.name,
@@ -335,7 +335,8 @@ export const createAccount = async (account: Account, security: Security) => {
                   domain: account.cloudProvider?.domain || "",
                   project_name: account.cloudProvider?.project_name || "",
                 }
-              : {
+              : 
+              {
                   method: providerName,
                   // ovh: {
                   //   endpoint: "string",
@@ -431,7 +432,123 @@ export const createAccount = async (account: Account, security: Security) => {
           },
         },
       };
-    } else if (providerName === "opennebula") {
+    } 
+    else if (providerName === "cloudos") {
+      accountBody = {
+        tenant: account.tenant,
+        account: account.name,
+        provision_infrastructure: false,
+        spec: {
+          spec: {
+            api: providerName,
+            credentials: 
+            // account.cloudProvider.password
+            //   ? {
+            //       username: account.cloudProvider.username || "",
+            //       password: account.cloudProvider.password || "",
+            //       region: account.cloudProvider?.region || "",
+            //       domain: account.cloudProvider?.domain || "",
+            //       project_name: account.cloudProvider?.project_name || "",
+            //     }
+            //   : 
+              {
+                  method: providerName,
+                  // ovh: {
+                  //   endpoint: "string",
+                  //   application_key: "string",
+                  //   application_secret: "string",
+                  //   consumer_key: "string",
+                  // },
+                  openstack: {
+                    region_name: account.cloudProvider?.region || "",
+                    interface: account.cloudProvider?.interface || "",
+                    identity_api_version: Number(
+                      account.cloudProvider?.apiVersion || 3,
+                    ),
+                    auth_type: account.cloudProvider?.authType || "",
+                    auth: {
+                      auth_url: account.cloudProvider?.authUrl || "",
+                      application_credential_id:
+                        account.cloudProvider?.credentialId || "",
+                      application_credential_secret:
+                        account.cloudProvider?.credentialSecret || "",
+                    },
+                  },
+                },
+            highlyAvailable: true,
+            marks: {
+              vcpu: {
+                lowmark: account.usage.limit.cpu.min * 1000,
+                highmark: account.usage.limit.cpu.max * 1000,
+                unit: "m",
+              },
+              memory: {
+                lowmark: account.usage.limit.memory.min * 1000,
+                highmark: account.usage.limit.memory.max * 1000,
+                unit: "MB",
+              },
+              vstorage: {
+                lowmark: account.usage.limit.volatileStorage.min * 1000,
+                highmark: account.usage.limit.volatileStorage.max * 1000,
+                unit: "MB",
+              },
+              nrstorage: {
+                lowmark: account.usage.limit.nonReplicatedStorage.min * 1000,
+                highmark: account.usage.limit.nonReplicatedStorage.max * 1000,
+                unit: "MB",
+              },
+              rstorage: {
+                lowmark: account.usage.limit.persistentStorage.min * 1000,
+                highmark: account.usage.limit.persistentStorage.max * 1000,
+                unit: "MB",
+              },
+              storage: {
+                lowmark: account.usage.limit.storage.min * 1000,
+                highmark: account.usage.limit.storage.max * 1000,
+                unit: "MB",
+              },
+              cost: {
+                lowmark: account.usage.cost,
+                highmark: account.usage.cost,
+                unit: "EUR",
+              },
+              nodes: {
+                lowmark: account.nodes?.max || 0,
+                highmark: account.nodes?.max || 0,
+                unit: "",
+              },
+            },
+            iaasconfig: {
+              ...(account.flavors?.volatile?.[0] && {
+                volatile: account.flavors.volatile[0],
+              }),
+              ...(account.flavors?.persistent?.[0] && {
+                persistent: account.flavors.persistent[0],
+              }),
+              ...(account.flavors?.nonReplicated?.[0] && {
+                nonreplicated: account.flavors.nonReplicated[0],
+              }),
+              // shared: "classic",
+              ...(account.flavors?.small?.[0] && {
+                smallVMFlavor: account.flavors?.small?.[0],
+              }),
+              ...(account.flavors?.medium?.[0] && {
+                mediumVMFlavor: account.flavors.medium[0],
+              }),
+              // ...(account.flavors?.large?.[0] && { largeVMFlavor: account.flavors.large[0] }),
+            },
+          },
+          meta: {
+            labels: {
+              additionalProp1: "string",
+              additionalProp2: "string",
+              additionalProp3: "string",
+            },
+          },
+        },
+      };
+    }
+    else if (providerName === "opennebula") {
       accountBody = {
         tenant: account.tenant,
         account: account.name,
@@ -615,7 +732,7 @@ export const deleteAccount = async (account: Account, security: Security) => {
           },
         },
       };
-    } else if (providerName === "oasix" || providerName === "cloudos") {
+    } else if (providerName === "oasix") {
       payload = {
         tenant: account.tenant,
         account: account.name,
@@ -1088,7 +1205,7 @@ export const updateAccount = async (account: Account, security: Security) => {
           },
         },
       };
-    } else if (providerName === "oasix" || providerName === "cloudos") {
+    } else if (providerName === "oasix") {
       accountBody = {
         tenant: account.tenant,
         account: account.name,
@@ -1198,7 +1315,121 @@ export const updateAccount = async (account: Account, security: Security) => {
           },
         },
       };
-    } else if (providerName === "opennebula") {
+    } 
+    else if (providerName === "cloudos") {
+      accountBody = {
+        tenant: account.tenant,
+        account: account.name,
+        provision_infrastructure: false,
+        spec: {
+          api: providerName,
+          credentials: 
+          // account.cloudProvider.password
+          //   ? {
+          //       username: account.cloudProvider.username || "",
+          //       password: account.cloudProvider.password || "",
+          //       region: account.cloudProvider?.region || "",
+          //       domain: account.cloudProvider?.domain || "",
+          //       project_name: account.cloudProvider?.project_name || "",
+          //     }
+          //   : 
+            {
+                method: providerName,
+                // ovh: {
+                //   endpoint: "string",
+                //   application_key: "string",
+                //   application_secret: "string",
+                //   consumer_key: "string",
+                // },
+                openstack: {
+                  region_name: account.cloudProvider?.region || "",
+                  interface: account.cloudProvider?.interface || "",
+                  identity_api_version: Number(
+                    account.cloudProvider?.apiVersion || 3,
+                  ),
+                  auth_type: account.cloudProvider?.authType || "",
+                  auth: {
+                    auth_url: account.cloudProvider?.authUrl || "",
+                    application_credential_id:
+                      account.cloudProvider?.credentialId || "",
+                    application_credential_secret:
+                      account.cloudProvider?.credentialSecret || "",
+                  },
+                },
+              },
+          highlyAvailable: true,
+          marks: {
+            vcpu: {
+              lowmark: account.usage.limit.cpu.min * 1000,
+              highmark: account.usage.limit.cpu.max * 1000,
+              unit: "m",
+            },
+            memory: {
+              lowmark: account.usage.limit.memory.min * 1000,
+              highmark: account.usage.limit.memory.max * 1000,
+              unit: "MB",
+            },
+            vstorage: {
+              lowmark: account.usage.limit.volatileStorage.min * 1000,
+              highmark: account.usage.limit.volatileStorage.max * 1000,
+              unit: "MB",
+            },
+            nrstorage: {
+              lowmark: account.usage.limit.nonReplicatedStorage.min * 1000,
+              highmark: account.usage.limit.nonReplicatedStorage.max * 1000,
+              unit: "MB",
+            },
+            rstorage: {
+              lowmark: account.usage.limit.persistentStorage.min * 1000,
+              highmark: account.usage.limit.persistentStorage.max * 1000,
+              unit: "MB",
+            },
+            storage: {
+              lowmark: account.usage.limit.storage.min * 1000,
+              highmark: account.usage.limit.storage.max * 1000,
+              unit: "MB",
+            },
+            cost: {
+              lowmark: account.usage.cost,
+              highmark: account.usage.cost,
+              unit: "EUR",
+            },
+            nodes: {
+              lowmark: account.nodes?.min || 0,
+              highmark: account.nodes?.max || 0,
+              unit: "",
+            },
+          },
+          iaasconfig: {
+            ...(account.flavors?.volatile?.[0] && {
+              volatile: account.flavors.volatile[0],
+            }),
+            ...(account.flavors?.persistent?.[0] && {
+              persistent: account.flavors.persistent[0],
+            }),
+            ...(account.flavors?.nonReplicated?.[0] && {
+              nonreplicated: account.flavors.nonReplicated[0],
+            }),
+            // shared: "classic",
+            ...(account.flavors?.small?.[0] && {
+              smallVMFlavor: account.flavors?.small?.[0],
+            }),
+            ...(account.flavors?.medium?.[0] && {
+              mediumVMFlavor: account.flavors.medium[0],
+            }),
+            // ...(account.flavors?.large?.[0] && { largeVMFlavor: account.flavors.large[0] }),
+          },
+        },
+        meta: {
+          labels: {
+            additionalProp1: "string",
+            additionalProp2: "string",
+            additionalProp3: "string",
+          },
+        },
+      };
+    }
+    else if (providerName === "opennebula") {
       accountBody = {
         tenant: account.tenant,
         account: account.name,

package/helpers/revision-helper.ts

@@ -242,56 +242,12 @@ const updateServiceWithRevision = (
   const updatedService: Service = {
     ...existingService,
     revisions: updatedRevisions,
-    currentRevision:
-      Number(entityId) >= Number(existingService.currentRevision ?? 0)
-        ? entityId
-        : existingService.currentRevision,
     role: roles.length > 0 ? roles : existingService.role,
     usage: newRevision.usage,
     startedAt: newRevision.createdAt || existingService.startedAt,
   };
 
-  let deploymentErrorEvent: Service | null = null;
-
-  const incomingStatus = eventData.status.state;
-  const incomingTs = getTimestamp(incomingStatus.timestamp);
-  const currentTs = getTimestamp(existingService.status?.timestamp);
-  const incomingRevisionId = Number(entityId);
-  const currentRevisionId = Number(existingService.currentRevision ?? 0);
-
-  if (incomingTs > currentTs) {
-    updatedService.status = incomingStatus;
-    if (eventData.status.error) {
-      if (incomingRevisionId >= currentRevisionId) {
-        updatedService.error = {
-          code: eventData.status.error.code,
-          message: eventData.status.error.message,
-          timestamp:
-            eventData.status.error.timestamp || incomingStatus.timestamp,
-        };
-        deploymentErrorEvent = updatedService;
-      }
-    } else {
-      updatedService.error = undefined;
-    }
-  } else if (eventData.status.error) {
-    if (incomingRevisionId >= currentRevisionId) {
-      const incomingErrorTs = getTimestamp(eventData.status.error.timestamp);
-      const currentErrorTs = getTimestamp(existingService.error?.timestamp);
-      if (incomingErrorTs > currentErrorTs) {
-        updatedService.error = {
-          code: eventData.status.error.code,
-          message: eventData.status.error.message,
-          timestamp: eventData.status.error.timestamp,
-        };
-        deploymentErrorEvent = updatedService;
-      }
-    }
-  }
-
-  if (incomingRevisionId >= currentRevisionId && !eventData.status.error) {
-    updatedService.error = undefined;
-  }
+  const deploymentErrorEvent = eventData.status?.error ? updatedService : null;
 
   return { updatedService, deploymentErrorEvent };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumori/aurora-backend-handler",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "description": "backend handler",
   "main": "backend-handler.ts",
   "scripts": {

package/websocket-manager.ts

@@ -684,22 +684,17 @@ const handleEvent = async (message: WSMessage) => {
           roleMap.set(revisionResult.serviceId, revisionResult.roles);
         }
         if (revisionResult.updatedService) {
-          servicesMap.set(
-            revisionResult.serviceId,
-            revisionResult.updatedService,
-          );
+          const resolved = resolveServiceStatus(revisionResult.updatedService);
+          servicesMap.set(revisionResult.serviceId, resolved);
         }
         if (revisionResult.updatedEnvironment) {
           const envId = revisionResult.updatedService?.environment;
-          if (envId) {
+          if (envId)
             environmentsMap.set(envId, revisionResult.updatedEnvironment);
-          }
         }
         if (revisionResult.updatedAccount) {
           const accId = revisionResult.updatedService?.account;
-          if (accId) {
-            accountsMap.set(accId, revisionResult.updatedAccount);
-          }
+          if (accId) accountsMap.set(accId, revisionResult.updatedAccount);
         }
         if (revisionResult.pendingRevisionError) {
           pendingRevisionErrors.push(revisionResult.pendingRevisionError);
@@ -716,14 +711,12 @@ const handleEvent = async (message: WSMessage) => {
           getChannelsInfo(
             revisionResult.channelsFetchInfo.serviceId,
             revisionResult.channelsFetchInfo.tenantId,
-          )
-            .then((channelsInfo) => {})
-            .catch((error) => {
-              console.error("[ws] Error fetching channels info for revision", {
-                revisionServiceId: revisionResult.channelsFetchInfo?.serviceId,
-                error,
-              });
-            });
+          ).catch((error) => {
+            console.error(
+              "[ws] Error fetching channels info for revision",
+              error,
+            );
+          });
         }
         break;
       case "service":
@@ -742,25 +735,15 @@ const handleEvent = async (message: WSMessage) => {
         pendingRevisionErrors.push(
           ...serviceResult.updatedPendingRevisionErrors,
         );
-        servicesMap.set(serviceResult.serviceFullKey, serviceResult.service);
-
-        const savedService = servicesMap.get(serviceResult.serviceFullKey)!;
-        if (savedService.error && savedService.currentRevision) {
-          const currentRevId = Number(savedService.currentRevision);
-          const errorTs = Number(savedService.error.timestamp ?? 0);
-          if (currentRevId > errorTs) {
-            savedService.error = undefined;
-            servicesMap.set(serviceResult.serviceFullKey, savedService);
-          }
-        }
+
+        const resolvedService = resolveServiceStatus(serviceResult.service);
+        servicesMap.set(serviceResult.serviceFullKey, resolvedService);
 
         const projectLabel = eventData.meta?.labels?.project;
         if (projectLabel) {
           const tenant = tenantsMap.get(parentParts.tenant);
           if (tenant) {
-            if (!tenant.projects) {
-              tenant.projects = [];
-            }
+            if (!tenant.projects) tenant.projects = [];
             if (!tenant.projects.includes(projectLabel)) {
               tenant.projects.push(projectLabel);
               tenantsMap.set(parentParts.tenant, tenant);
@@ -770,7 +753,7 @@ const handleEvent = async (message: WSMessage) => {
           }
         }
         if (serviceResult.wasDeployed) {
-          eventHelper.service.publish.deployed(serviceResult.service);
+          eventHelper.service.publish.deployed(resolvedService);
         }
         const serviceState = eventData.status?.state?.code;
         if (serviceState === "SERVICE_READY") {
@@ -1158,7 +1141,7 @@ export const getReferenceDomain = () => {
 };
 const handleOperationSuccess = (operation: PendingOperation, response: any) => {
   const { action, entityType, entityName, originalData } = operation;
-   if (action === "UPDATE_CONFIG") {
+  if (action === "UPDATE_CONFIG") {
     const tenant = originalData?.payload?.tenant;
     const serviceName = originalData?.payload?.service;
     if (tenant && serviceName) {
@@ -1316,7 +1299,7 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
           eventHelper.service.publish.updated(svcSuccessResult.updatedService);
         }
       }
-      break;;
+      break;
     case "account":
       const accSuccessResult = handleAccountOperationSuccess({
         action,
@@ -1922,3 +1905,33 @@ export const updateUserComplete = (updatedUserData: UserData): User => {
     return user;
   }
 };
+const resolveServiceStatus = (service: Service): Service => {
+  const revisionKey = `${service.tenant}/${service.name}-${service.currentRevision}`;
+  const currentRevision = revisionsMap.get(revisionKey);
+
+  if (service.error) {
+    return service;
+  }
+
+  if (!currentRevision) {
+    return service;
+  }
+
+  if (currentRevision.errorCode) {
+    return {
+      ...service,
+      status: currentRevision.status,
+      error: {
+        code: currentRevision.errorCode,
+        message: currentRevision.errorMsg || "",
+        timestamp: currentRevision.status?.timestamp,
+      },
+    };
+  }
+
+  return {
+    ...service,
+    error: undefined,
+    status: currentRevision.status,
+  };
+};