@kumori/aurora-backend-handler 1.1.47 → 1.1.49

package/helpers/revision-helper.ts

@@ -159,12 +159,52 @@ const processRolesAndInstances = (
   return { roles, instances, usedCpu, usedMemory };
 };
 
+const getContainerError = (
+  revisionStatus: any,
+): { code: string; message: string; timestamp: string } | null => {
+  for (const roleData of Object.values<any>(revisionStatus?.runtime?.roles ?? {})) {
+    for (const instanceData of Object.values<any>(roleData.instances ?? {})) {
+      for (const container of Object.values<any>(instanceData.containers ?? {})) {
+        if (!container.status.ready) {
+          return {
+            code: container.status.status.waiting?.reason ?? "ContainerNotReady",
+            message: container.status.status.waiting?.message ?? "One or more containers are not ready for unknown reasons.",
+            timestamp: Date.now().toString(),
+          };
+        }
+      }
+    }
+  }
+  return null;
+};
+
+const handleRevisionStatus = (revisionStatus: any) => {
+  if (revisionStatus?.error) {
+    return {
+      code: revisionStatus.error.code,
+      message: revisionStatus.error.message,
+      timestamp: Date.now().toString(),
+    };
+  }
+
+  const containerError = getContainerError(revisionStatus);
+  if (containerError) return containerError;
+  if (revisionStatus?.runtime?.status) {
+    return revisionStatus.runtime.status;
+  }
+  return revisionStatus?.state;
+};
+
 const createRevision = (
   entityId: string,
   eventData: any,
   usedCpu: number,
   usedMemory: number,
 ): Revision => {
+  const status = handleRevisionStatus(eventData.status);
+  const explicitError = eventData.status?.error;
+  const containerError = !explicitError ? getContainerError(eventData.status) : null;
+
   return {
     id: entityId,
     schema: {},
@@ -199,30 +239,13 @@ const createRevision = (
       },
       cost: 0,
     },
-    status: handleRevisionStatus(eventData.status),
-    errorCode: eventData.status?.error ? eventData.status.error.code : handleRevisionStatus(eventData.status)?.code || "",
-    errorMsg: eventData.status?.error ? eventData.status.error.message : handleRevisionStatus(eventData.status)?.message || "",
+    status,
+    errorCode: explicitError ? explicitError.code : containerError ? containerError.code : "",
+    errorMsg: explicitError ? explicitError.message : containerError ? containerError.message : "",
     createdAt:
       (eventData.status && eventData.status.runtime?.status?.createdAt) || "",
   };
 };
-const handleRevisionStatus = (revisionStatus: any) => {
-  for (const roleData of Object.values<any>(revisionStatus.runtime.roles)) {
-    for (const instanceData of Object.values<any>(roleData.instances)) {
-      for (const container of Object.values<any>(instanceData.containers ?? {})) {
-        if (!container.status.ready) {
-          return {
-            code: container.status.status.waiting?.reason ?? "ContainerNotReady",
-            message: container.status.status.waiting?.message ?? "One or more containers are not ready for unknown reasons.",
-            timestamp: Date.now().toString(),
-          };
-        }
-      }
-    }
-  }
-
-  return revisionStatus?.state;
-};
 const updateServiceWithRevision = (
   existingService: Service,
   entityId: string,

package/helpers/service-helper.ts

@@ -123,48 +123,59 @@ const determineFinalStatusAndError = (
   eventData: any,
   pendingRevisionErrors: Array<{ service: string; revision: Revision }>,
   entityId: string,
+  currentRevision: Revision | undefined,
 ): {
   finalStatus: any;
   finalError: any;
   pendingErrorIndex: number;
 } => {
-  const incomingStatus = eventData.status.state;
-  const incomingTs = getTimestamp(incomingStatus.timestamp);
+  const incomingServiceStatus = eventData.status.state;
+  const incomingTs = getTimestamp(incomingServiceStatus.timestamp);
   const currentTs = getTimestamp(existingService?.status?.timestamp);
-
   const isNewer = !existingService || incomingTs > currentTs;
-  let finalStatus = existingService?.status;
-  let finalError = existingService?.error;
-
-  if (isNewer) {
-    finalStatus = incomingStatus;
-    if (eventData.status.error) {
-      finalError = eventData.status.error;
-    } else {
-      finalError = undefined;
-    }
-  }
 
   const pendingErrorIndex = pendingRevisionErrors.findIndex(
     (pending) => pending.service === entityId,
   );
+  const pendingError =
+    pendingErrorIndex !== -1 ? pendingRevisionErrors[pendingErrorIndex] : null;
+  const serviceError = isNewer ? eventData.status.error : undefined;
+  const revisionError =
+    currentRevision?.errorCode
+      ? {
+          code: currentRevision.errorCode,
+          message: currentRevision.errorMsg || "",
+          timestamp: currentRevision.status?.timestamp || "",
+        }
+      : null;
 
-  if (pendingErrorIndex !== -1) {
-    const pendingError = pendingRevisionErrors[pendingErrorIndex];
-    const pendingTs = getTimestamp(pendingError.revision.status.timestamp);
-    const currentDecisionTs = getTimestamp(finalStatus?.timestamp);
+  if (serviceError) {
+    return { finalStatus: incomingServiceStatus, finalError: serviceError, pendingErrorIndex };
+  }
+
+  if (revisionError) {
+    return { finalStatus: currentRevision!.status, finalError: revisionError, pendingErrorIndex };
+  }
 
-    if (pendingTs > currentDecisionTs) {
-      finalStatus = pendingError.revision.status;
-      finalError = {
+  if (pendingError) {
+    return {
+      finalStatus: pendingError.revision.status,
+      finalError: {
         code: pendingError.revision.errorCode || "",
         message: pendingError.revision.errorMsg || "",
-        timestamp: pendingError.revision.status.timestamp || "",
-      };
-    }
+        timestamp: pendingError.revision.status?.timestamp || "",
+      },
+      pendingErrorIndex,
+    };
+  }
+  if (currentRevision?.status && isNewer) {
+    return { finalStatus: currentRevision.status, finalError: undefined, pendingErrorIndex };
+  }
+  if (isNewer) {
+    return { finalStatus: incomingServiceStatus, finalError: undefined, pendingErrorIndex };
   }
 
-  return { finalStatus, finalError, pendingErrorIndex };
+  return { finalStatus: existingService?.status, finalError: existingService?.error, pendingErrorIndex };
 };
 
 export const handleServiceEvent = ({
@@ -203,6 +214,7 @@ export const handleServiceEvent = ({
       eventData,
       pendingRevisionErrors,
       entityId,
+      currentRevision,
     );
 
   const updatedPendingRevisionErrors = [...pendingRevisionErrors];

package/package.json

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