@firestartr/cli 1.53.0-snapshot-12 → 1.53.0

package/build/index.js

@@ -360725,7 +360725,7 @@ function renderFeature(featureName, version, owner, repo, featureOwner, renderPa
     return features_renderer.render(extractPath, renderedPath, featureOwner, {}, featureArgs);
 }
 /*
- * This functionality does the same of the above
+ * This functionality does the same as the above
  * without downloading and extracting the feature
  */
 function renderFeatureFromPath(extractPath, renderedPath, featureOwner, featureArgs = {}) {
@@ -360907,7 +360907,7 @@ async function utils_renderFeature(featureName, featureVersion, featureOutputObj
 // this is the only way currently to make
 // work the system and inject our code
 // without having to download a feature
-let MOCK_FEATURES_FN = undefined;
+let MOCK_FEATURES_FN;
 function MOCK_FEATURES(mock) {
     MOCK_FEATURES_FN = mock;
     if (mock) {
@@ -364101,7 +364101,6 @@ class FeatureRepoChart extends BaseGithubChart {
         };
         // We do this to remove undefined variables from the template
         const crTemplate = JSON.parse(JSON.stringify(cr, null, 2));
-        console.log(crTemplate.spec);
         return crTemplate;
     }
     gvk() {
@@ -368421,6 +368420,7 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
     workItem.getItem = () => {
         return getItemByItemPath(informer_itemPath(pluralKind, workItem.item));
     };
+    workItem.isDeadLetter = false;
     workItem.handler = {
         finalize: unsetFinalizer,
         pluralKind,
@@ -368751,12 +368751,39 @@ function formatElapsedTimeWithDate(upsertTime) {
     return `${parts.slice(0, 2).join(', ')} ago`;
 }
 
+;// CONCATENATED MODULE: ../operator/src/processItemDLH.ts
+
+
+
+/*
+ * Dead-Letter Handler
+ *
+ * It manages failed WorkItems with an uncontrolled exception
+ * it always closes the WorkItem and tries to put the CR in an ERROR state
+ */
+async function deadLetterHandler(workItem) {
+    const { operation } = workItem;
+    const itemPath = workItem.handler.itemPath();
+    workItem.workStatus = WorkStatus.FINISHED;
+    workItem.isDeadLetter = true;
+    // we try to put the CR in a correct state
+    try {
+        await updateTransition(itemPath, operation, 'ERROR', 'True', 'Uncontrolled error (DLH)');
+        await updateTransition(itemPath, operation, 'PROVISIONED', 'False', 'Uncontrolled error (DLH)');
+        await updateTransition(itemPath, operation, 'PROVISIONING', 'False', 'Uncontrolled error (DLH)');
+    }
+    catch (err) {
+        operator_src_logger.error(`Error handling WorkItem in DeadLetter state: ${workItem.handler.itemPath()}: ${err}`);
+    }
+}
+
 ;// CONCATENATED MODULE: ../operator/src/processItem.ts
 
 
 
 
 
+
 const queue = [];
 const WEIGHTS = {
     RENAMED: 15,
@@ -368809,6 +368836,7 @@ function getQueueMetrics() {
         nItemsFinished: queue.filter((workItem) => workItem.workStatus === WorkStatus.FINISHED).length,
         nItemsPending: queue.filter((workItem) => workItem.workStatus === WorkStatus.PENDING).length,
         nItemsProcessing: queue.filter((workItem) => workItem.workStatus === WorkStatus.PROCESSING).length,
+        nItemsInDeadLetterHandling: queue.filter((workItem) => workItem.isDeadLetter === true).length,
         nItemsTypes: {
             nothing,
             retry,
@@ -368942,7 +368970,8 @@ async function runWorkItem(workItem) {
             return;
         }
         else {
-            operator_src_logger.error(`An error occurred while the processor was handling the '${workItem.operation}' operation for item '${workItem.item.kind}/${workItem.item.metadata.name}' in namespace '${workItem.item.metadata.namespace}'. Current work status is '${workItem.workStatus}'. The error was: '${e}'.`);
+            operator_src_logger.error(`An unmanaged error occurred while the processor was handling the '${workItem.operation}' operation for item '${workItem.item.kind}/${workItem.item.metadata.name}' in namespace '${workItem.item.metadata.namespace}'. Current work status is '${workItem.workStatus}'. The error was: '${e}'.`);
+            await deadLetterHandler(workItem);
             console.error(e);
         }
         return;
@@ -371227,6 +371256,7 @@ async function* markedToDeletion(item, op, handler) {
     // here we store the current callbacks that
     // are being used (synth|tf-apply...)
     let checkRunCtl;
+    let error = false;
     try {
         void cleanTerraformState();
         const type = 'DELETING';
@@ -371301,13 +371331,7 @@ async function* markedToDeletion(item, op, handler) {
         void handler.success();
     }
     catch (e) {
-        yield {
-            item,
-            reason: op,
-            type: 'ERROR',
-            status: 'True',
-            message: DESTROY_DEFAULT_ERROR_MESSAGE,
-        };
+        error = true;
         // if there is a current checkRun working
         // we close it with an error
         if (checkRunCtl)
@@ -371315,6 +371339,17 @@ async function* markedToDeletion(item, op, handler) {
         await handler.writeTerraformOutputInTfResult(item, e);
         void handler.error();
     }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: DESTROY_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
 }
 async function* nothing(item, op, handler) {
     yield {
@@ -371334,6 +371369,7 @@ async function* doApply(item, op, handler) {
     // here we store the current callbacks that
     // are being used (synth|tf-apply...)
     let checkRunCtl;
+    let error = false;
     try {
         cleanTerraformState();
         yield {
@@ -371440,43 +371476,48 @@ async function* doApply(item, op, handler) {
         handler.success();
     }
     catch (e) {
-        let error;
+        error = true;
+        let errorMsg;
         if (typeof e === 'object' && 'output' in e) {
-            error = e.output;
+            errorMsg = e.output;
         }
         else {
-            error = e;
+            errorMsg = e;
         }
-        await tryPublishApply(item, error, item.kind);
+        await tryPublishApply(item, errorMsg, item.kind);
         // if there is a current checkRun working
         // we close it with an error
         if (checkRunCtl)
-            checkRunCtl.fnOnError(error);
-        operator_src_logger.error(`Error applying item ${item.metadata.name}: ${error}`);
-        yield {
-            item,
-            reason: op,
-            type: 'ERROR',
-            status: 'True',
-            message: APPLY_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'PROVISIONED',
-            status: 'False',
-            message: APPLY_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'PROVISIONING',
-            status: 'False',
-            message: APPLY_DEFAULT_ERROR_MESSAGE,
-        };
+            checkRunCtl.fnOnError(errorMsg);
+        operator_src_logger.error(`Error applying item ${item.metadata.name}: ${errorMsg}`);
         handler.error();
+        if (errorMsg) {
+            await handler.writeTerraformOutputInTfResult(item, errorMsg);
+        }
+    }
+    finally {
         if (error) {
-            await handler.writeTerraformOutputInTfResult(item, error);
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONED',
+                status: 'False',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONING',
+                status: 'False',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
         }
     }
 }
@@ -372569,6 +372610,7 @@ async function* process_operation_observe(item, op, handler) {
     }
 }
 async function* doPlanJSONFormat(item, op, handler) {
+    let error = false;
     try {
         yield {
             item,
@@ -372654,36 +372696,9 @@ async function* doPlanJSONFormat(item, op, handler) {
         }
     }
     catch (e) {
+        error = true;
         console.error(e);
         operator_src_logger.error(`The Terraform processor encountered an error while observing the plan for item '${item.kind}/${item.metadata.name}': '${e}'.`);
-        yield {
-            item,
-            reason: op,
-            type: 'PROVISIONED',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'PLANNING',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'OUT_OF_SYNC',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'ERROR',
-            status: 'True',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
         const summaryText = tryCreateErrorSummary('Terraform Plan failed', e);
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], summaryText, 'completed', true);
@@ -372693,6 +372708,38 @@ async function* doPlanJSONFormat(item, op, handler) {
             await handler.writeTerraformOutputInTfResult(item, e);
         }
     }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONED',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PLANNING',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'OUT_OF_SYNC',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
 }
 async function* process_operation_created(item, op, handler) {
     for await (const transition of process_operation_doApply(item, op, handler)) {
@@ -372768,6 +372815,7 @@ async function* process_operation_sync(item, op, handler, syncPolicy, generalPol
     };
 }
 async function* process_operation_markedToDeletion(item, op, handler) {
+    let error = false;
     try {
         const type = 'DELETING';
         yield {
@@ -372848,19 +372896,24 @@ async function* process_operation_markedToDeletion(item, op, handler) {
         void handler.success();
     }
     catch (e) {
-        yield {
-            item,
-            reason: op,
-            type: 'ERROR',
-            status: 'True',
-            message: DESTROY_DEFAULT_ERROR_MESSAGE,
-        };
+        error = true;
         await handler.writeTerraformOutputInTfResult(item, e);
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addDestroyCommitStatus(item, 'failure', 'Destroy operation failed', `Terraform Destroy ${item.metadata.name}`);
         }
         void handler.error();
     }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: DESTROY_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
 }
 async function* process_operation_nothing(item, op, handler) {
     yield {
@@ -372879,6 +372932,7 @@ async function* process_operation_nothing(item, op, handler) {
  */
 async function* process_operation_doApply(item, op, handler) {
     const checkRunCtl = await TFCheckRun('apply', item);
+    let error = false;
     try {
         yield {
             item,
@@ -372962,36 +373016,41 @@ async function* process_operation_doApply(item, op, handler) {
         handler.success();
     }
     catch (e) {
+        error = true;
         checkRunCtl.fnOnError(e);
         console.error(e);
         await tryPublishApply(item, e, 'TFWorkspace');
         operator_src_logger.error(`The Terraform processor encountered an error during operation '${op}' for item '${item.kind}/${item.metadata.name}': '${e}'.`);
-        yield {
-            item,
-            reason: op,
-            type: 'ERROR',
-            status: 'True',
-            message: APPLY_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'PROVISIONED',
-            status: 'False',
-            message: APPLY_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'PROVISIONING',
-            status: 'False',
-            message: APPLY_DEFAULT_ERROR_MESSAGE,
-        };
         handler.error();
         if (e) {
             await handler.writeTerraformOutputInTfResult(item, e);
         }
     }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONED',
+                status: 'False',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONING',
+                status: 'False',
+                message: APPLY_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
 }
 async function* errorPolicyNotAllowsOp(item, op, handler, msg) {
     const reason = 'POLICY CONFLICT';
@@ -373393,6 +373452,7 @@ async function* processOperationPlan_plan(item, op, handler, format = 'plain-tex
     }
 }
 async function* doPlanPlainTextFormat(item, op, handler, action) {
+    let error = false;
     try {
         yield {
             item,
@@ -373452,32 +373512,12 @@ async function* doPlanPlainTextFormat(item, op, handler, action) {
         }
     }
     catch (e) {
+        error = true;
         const { prNumber, repo, org } = extractPrInfo(item, 'firestartr.dev/pull-request-plan');
         await publishPlan(item, JSON.stringify(e), prNumber, repo, org);
         operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_OBSERVING_ERROR', {
             metadata: { item, error: e },
         });
-        yield {
-            item,
-            reason: op,
-            type: 'PROVISIONED',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'PLANNING',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'ERROR',
-            status: 'True',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
         const summaryText = tryCreateErrorSummary('Terraform Plan failed', e);
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], summaryText, 'completed', true);
@@ -373487,8 +373527,34 @@ async function* doPlanPlainTextFormat(item, op, handler, action) {
             await handler.writeTerraformOutputInTfResult(item, e);
         }
     }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONED',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PLANNING',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
 }
 async function* processOperationPlan_doPlanJSONFormat(item, op, handler, action) {
+    let error = false;
     try {
         yield {
             item,
@@ -373571,43 +373637,48 @@ async function* processOperationPlan_doPlanJSONFormat(item, op, handler, action)
         }
     }
     catch (e) {
+        error = true;
         console.error(e);
         operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_DO_PLAN_ERROR', {
             metadata: { item, error: e },
         });
-        yield {
-            item,
-            reason: op,
-            type: 'PROVISIONED',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'PLANNING',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'OUT_OF_SYNC',
-            status: 'False',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
-        yield {
-            item,
-            reason: op,
-            type: 'ERROR',
-            status: 'True',
-            message: PLAN_DEFAULT_ERROR_MESSAGE,
-        };
         void handler.error();
         if (e) {
             await handler.writeTerraformOutputInTfResult(item, e);
         }
     }
+    finally {
+        if (error) {
+            yield {
+                item,
+                reason: op,
+                type: 'PROVISIONED',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'PLANNING',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'OUT_OF_SYNC',
+                status: 'False',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+            yield {
+                item,
+                reason: op,
+                type: 'ERROR',
+                status: 'True',
+                message: PLAN_DEFAULT_ERROR_MESSAGE,
+            };
+        }
+    }
 }
 /**
  * @description Adapts the CR to the format expected by the terraform provisioner
@@ -374232,11 +374303,15 @@ async function startQueueMetrics(meter, attributes) {
     const nWorkItemsPendingCounter = meter.createObservableGauge('firestartr_workitems_pending_total', { description: 'Number of workitems with PENDING status in the queue' });
     const nWorkItemsProcessingCounter = meter.createObservableGauge('firestartr_workitems_processing_total', { description: 'Number of workitems with PROCESSING status in the queue' });
     const nWorkItemsFinishedCounter = meter.createObservableGauge('firestartr_workitems_finished_total', { description: 'Number of workitems with FINISHED status in the queue' });
+    const nWorkItemsInDeadLetterHandling = meter.createObservableGauge('firestartr_workitems_dead_letter_handling_total', {
+        description: 'Number of workitems of the queue handled by the Dead Letter Handler',
+    });
     const queueMetrics = getQueueMetrics();
     let total = queueMetrics.nItems;
     let pending = queueMetrics.nItemsPending;
     let processing = queueMetrics.nItemsProcessing;
     let finished = queueMetrics.nItemsFinished;
+    let inDeadLetterHandling = queueMetrics.nItemsInDeadLetterHandling;
     nWorkItemsCounter.addCallback((observer) => observer.observe(total, { ...attributes, ...queueMetrics.nItemsTypes }));
     nWorkItemsPendingCounter.addCallback((observer) => observer.observe(pending, { ...attributes, ...queueMetrics.nItemsTypes }));
     nWorkItemsProcessingCounter.addCallback((observer) => observer.observe(processing, {
@@ -374244,12 +374319,17 @@ async function startQueueMetrics(meter, attributes) {
         ...queueMetrics.nItemsTypes,
     }));
     nWorkItemsFinishedCounter.addCallback((observer) => observer.observe(finished, { ...attributes, ...queueMetrics.nItemsTypes }));
+    nWorkItemsInDeadLetterHandling.addCallback((observer) => observer.observe(inDeadLetterHandling, {
+        ...attributes,
+        ...queueMetrics.nItemsTypes,
+    }));
     setInterval(() => {
         const queueMetrics = getQueueMetrics();
         total = queueMetrics.nItems;
         pending = queueMetrics.nItemsPending;
         processing = queueMetrics.nItemsProcessing;
         finished = queueMetrics.nItemsFinished;
+        inDeadLetterHandling = queueMetrics.nItemsInDeadLetterHandling;
     }, 1000);
 }
 async function startMemoryMetrics(meter, attributes) {

package/build/packages/operator/src/informer.d.ts

@@ -22,6 +22,7 @@ export type WorkItem = {
     onDelete: Function;
     process?: Function;
     upsertTime?: number;
+    isDeadLetter?: boolean;
 };
 type HandlerFinalizerFn = (kind: string, namespace: string, item: any | string, finalizer: string) => Promise<any>;
 type HandlerInformPlanFn = (prUrl: string, planText: string) => Promise<void>;

package/build/packages/operator/src/processItem.d.ts

@@ -4,6 +4,7 @@ export declare function getQueueMetrics(): {
     nItemsFinished: number;
     nItemsPending: number;
     nItemsProcessing: number;
+    nItemsInDeadLetterHandling: number;
     nItemsTypes: {
         nothing: number;
         retry: number;

package/build/packages/operator/src/processItemDLH.d.ts

@@ -0,0 +1,2 @@
+import { WorkItem } from './informer';
+export declare function deadLetterHandler(workItem: WorkItem): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "1.53.0-snapshot-12",
+  "version": "1.53.0",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",