feat(backend): backend error handling strategy (#89)

Co-authored-by: Jackson Chen <[email protected]>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: 3 people

backend/src/build-system/__tests__/test.model-provider.spec.ts

@@ -1,5 +1,6 @@
 import {
   BuildExecutionState,
+  BuildHandler,
   BuildNode,
   BuildResult,
   BuildSequence,
@@ -12,6 +13,7 @@ import { ModelProvider } from 'src/common/model-provider';
 import { v4 as uuidv4 } from 'uuid';
 import { BuildMonitor } from './monitor';
 import { BuildHandlerManager } from './hanlder-manager';
+import { RetryHandler } from './retry-handler';
 
 /**
  * Global data keys used throughout the build process
@@ -50,11 +52,13 @@ export class BuilderContext {
     waiting: new Set(),
   };
 
+  private globalPromises: Set<Promise<any>> = new Set();
   private logger: Logger;
   private globalContext: Map<GlobalDataKeys | string, any> = new Map();
   private nodeData: Map<string, any> = new Map();
 
   private handlerManager: BuildHandlerManager;
+  private retryHandler: RetryHandler;
   private monitor: BuildMonitor;
   public model: ModelProvider;
   public virtualDirectory: VirtualDirectory;
@@ -63,6 +67,7 @@ export class BuilderContext {
     private sequence: BuildSequence,
     id: string,
   ) {
+    this.retryHandler = RetryHandler.getInstance();
     this.handlerManager = BuildHandlerManager.getInstance();
     this.model = ModelProvider.getInstance();
     this.monitor = BuildMonitor.getInstance();
@@ -157,7 +162,7 @@ export class BuilderContext {
           const batch = executableNodes.slice(i, i + concurrencyLimit);
 
           try {
-            const nodeExecutionPromises = batch.map(async (node) => {
+            batch.map(async (node) => {
               if (this.executionState.completed.has(node.id)) {
                 return;
               }
@@ -169,6 +174,7 @@ export class BuilderContext {
                 currentStep.id,
               );
 
+              let res;
               try {
                 if (!this.canExecute(node.id)) {
                   this.logger.log(
@@ -185,7 +191,8 @@ export class BuilderContext {
                 }
 
                 this.logger.log(`Executing node ${node.id} in parallel batch`);
-                await this.executeNodeById(node.id);
+                res = this.executeNodeById(node.id);
+                this.globalPromises.add(res);
 
                 this.monitor.endNodeExecution(
                   node.id,
@@ -205,8 +212,7 @@ export class BuilderContext {
               }
             });
 
-            await Promise.all(nodeExecutionPromises);
-
+            await Promise.all(this.globalPromises);
             const activeModelPromises = this.model.getAllActivePromises();
             if (activeModelPromises.length > 0) {
               this.logger.debug(
@@ -336,7 +342,7 @@ export class BuilderContext {
       this.executionState.completed.has(nodeId) ||
       this.executionState.pending.has(nodeId)
     ) {
-      this.logger.debug(`Node ${nodeId} is already completed or pending.`);
+      //this.logger.debug(`Node ${nodeId} is already completed or pending.`);
       return false;
     }
 
@@ -361,6 +367,7 @@ export class BuilderContext {
       this.executionState.pending.add(nodeId);
       const result = await this.invokeNodeHandler<T>(node);
       this.executionState.completed.add(nodeId);
+      this.logger.log(`${nodeId} is completed`);
       this.executionState.pending.delete(nodeId);
 
       this.nodeData.set(node.id, result.data);
@@ -438,10 +445,23 @@ export class BuilderContext {
 
   private async invokeNodeHandler<T>(node: BuildNode): Promise<BuildResult<T>> {
     const handler = this.handlerManager.getHandler(node.id);
+    this.logger.log(`sovling ${node.id}`);
     if (!handler) {
       throw new Error(`No handler found for node: ${node.id}`);
     }
-
-    return handler.run(this, node.options);
+    try {
+      return await handler.run(this, node.options);
+    } catch (e) {
+      this.logger.error(`retrying ${node.id}`);
+      const result = await this.retryHandler.retryMethod(
+        e,
+        (node) => this.invokeNodeHandler(node),
+        [node],
+      );
+      if (result === undefined) {
+        throw e;
+      }
+      return result as unknown as BuildResult<T>;
+    }
   }
 }

backend/src/build-system/__tests__/test.spec.ts

@@ -0,0 +1,149 @@
+// error.ts
+
+/**
+ * Base class representing retryable errors.
+ * Inherits from JavaScript's built-in Error class.
+ * Suitable for errors where the system can attempt to retry the operation.
+ */
+export class RetryableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'RetryableError';
+    Object.setPrototypeOf(this, new.target.prototype); // Fixes the inheritance chain for instanceof checks
+  }
+}
+
+/**
+ * Base class representing non-retryable errors.
+ * Inherits from JavaScript's built-in Error class.
+ * Suitable for errors where the system should not attempt to retry the operation.
+ */
+export class NonRetryableError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NonRetryableError';
+    Object.setPrototypeOf(this, new.target.prototype); // Fixes the inheritance chain for instanceof checks
+  }
+}
+
+// Below are specific error classes inheriting from the appropriate base classes
+
+/**
+ * Error: File Not Found.
+ * Indicates that a required file could not be found during file operations.
+ * Non-retryable error.
+ */
+export class FileNotFoundError extends NonRetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FileNotFoundError';
+  }
+}
+
+/**
+ * Error: File Modification Failed.
+ * Indicates issues encountered while modifying a file, such as insufficient permissions or disk errors.
+ * Non-retryable error.
+ */
+export class FileModificationError extends NonRetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FileModificationError';
+  }
+}
+
+/**
+ * Error: Model Service Unavailable.
+ * Indicates that the underlying model service cannot be reached or is down.
+ * Retryable error, typically temporary.
+ */
+export class ModelUnavailableError extends RetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ModelUnavailableError';
+  }
+}
+
+/**
+ * Error: Response Parsing Failed.
+ * Indicates that the system could not properly parse the response data.
+ * Retryable error, possibly due to temporary data format issues.
+ */
+export class ResponseParsingError extends RetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ResponseParsingError';
+  }
+}
+
+/**
+ * Error: Response Tag Error.
+ * Indicates that expected tags in the response are missing or invalid during content generation or parsing.
+ * Non-retryable error.
+ */
+export class ResponseTagError extends NonRetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ResponseTagError';
+  }
+}
+
+/**
+ * Error: Temporary Service Unavailable.
+ * Indicates that the service is unavailable due to temporary issues like server overload or maintenance.
+ * Retryable error, typically temporary.
+ */
+export class TemporaryServiceUnavailableError extends RetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'TemporaryServiceUnavailableError';
+  }
+}
+
+/**
+ * Error: Rate Limit Exceeded.
+ * Indicates that too many requests have been sent within a given time frame.
+ * Retryable error, may require waiting before retrying.
+ */
+export class RateLimitExceededError extends RetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'RateLimitExceededError';
+  }
+}
+
+/**
+ * Error: Missing Configuration.
+ * Indicates issues with system setup or missing configuration parameters.
+ * Non-retryable error, typically requires manual configuration fixes.
+ */
+export class MissingConfigurationError extends NonRetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'MissingConfigurationError';
+  }
+}
+
+/**
+ * Error: Invalid Parameter.
+ * Indicates that a function argument or configuration parameter is invalid.
+ * Non-retryable error, typically requires correcting the input parameters.
+ */
+export class InvalidParameterError extends NonRetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidParameterError';
+  }
+}
+
+/**
+ * Error: File Write Failed.
+ * Indicates issues encountered while writing to a file, such as insufficient permissions or disk errors.
+ * Non-retryable error.
+ */
+export class FileWriteError extends NonRetryableError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FileWriteError';
+  }
+}