@firestartr/cli 1.53.0-snapshot-13 → 1.53.1-release-candidate

package/build/index.js

@@ -367720,12 +367720,19 @@ function updateConditionByType(conditionList, type, newCondition) {
     return conditionList;
 }
 
+;// CONCATENATED MODULE: ../operator/src/utils/operationErrorMessages.ts
+const APPLY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform apply operation.';
+const DESTROY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform destroy operation.';
+const PLAN_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform plan operation.';
+const SYNC_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Sync operation.';
+
 ;// CONCATENATED MODULE: ../operator/src/syncCtl.ts
 // Machinery for syncing
 
 
 
 
+
 const DEFAULT_REVISION_TIME = '1m';
 async function createWatcherForItem(itemPath, itemCR) {
     const item = itemCR ?? (await getItemByItemPath(itemPath));
@@ -367788,7 +367795,7 @@ async function getSyncStatus(itemPath, itemCR) {
             : (await getSyncSpecs(itemPath, item)).schedule
                 ? 'Scheduled'
                 : 'Period';
-        return {
+        const syncStatus = {
             itemPath,
             syncMode: mode,
             conditions: [syncCondition],
@@ -367796,6 +367803,11 @@ async function getSyncStatus(itemPath, itemCR) {
             nextTimeoutInMS: isLapsed ? -1 : nextSyncDate.getTime() - Date.now(),
             intervalLapsed: isLapsed,
         };
+        if (syncCondition) {
+            syncStatus.hasSyncFailed =
+                syncCondition.message === SYNC_DEFAULT_ERROR_MESSAGE;
+        }
+        return syncStatus;
     }
 }
 async function setSyncStatus(itemPath, reason, status, message) {
@@ -368444,6 +368456,15 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
             yield transition;
         }
         if (needsUpdateSyncConditions) {
+            if (operation === OperationType.SYNC) {
+                // let's check if the process has not failed
+                const syncStatus = await getSyncStatus(workItem.handler.itemPath());
+                if (syncStatus.hasSyncFailed) {
+                    // we do not update sync because we are not going to trigger
+                    // a RETRY operation if the sync has failed
+                    return;
+                }
+            }
             await setSyncStatus(workItem.handler.itemPath(), operation, operation === OperationType.SYNC ? 'True' : 'False', 'Sync process finished');
             void syncCtl.updateItem(informer_itemPath(pluralKind, item));
         }
@@ -369464,9 +369485,7 @@ function provisionFeatureFiles(scope, feature) {
                 ? { ignoreChanges: ['content'] }
                 : {};
             const repoConfig = {
-                branch: file.targetBranch.length === 0
-                    ? defaultBranchName
-                    : file.targetBranch,
+                branch: file.targetBranch || defaultBranchName,
                 commitMessage: `feat: ${feature.spec.type} ${feature.spec.version}`,
                 content: cdktf_lib.Fn.base64decode(file.content),
                 file: file.path,
@@ -371164,11 +371183,6 @@ function helperCreateCheckRunName(cmd, item) {
     return `${item.kind} - ${cmd}`;
 }
 
-;// CONCATENATED MODULE: ../operator/src/utils/operationErrorMessages.ts
-const APPLY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform apply operation.';
-const DESTROY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform destroy operation.';
-const PLAN_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform plan operation.';
-
 ;// CONCATENATED MODULE: ../operator/cdktf.ts
 
 
@@ -371256,6 +371270,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';
@@ -371330,13 +371345,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)
@@ -371344,6 +371353,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 {
@@ -371363,6 +371383,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 {
@@ -371469,43 +371490,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,
+            };
         }
     }
 }
@@ -372597,7 +372623,8 @@ async function* process_operation_observe(item, op, handler) {
         yield transition;
     }
 }
-async function* doPlanJSONFormat(item, op, handler) {
+async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) { }) {
+    let error = false;
     try {
         yield {
             item,
@@ -372683,36 +372710,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);
@@ -372722,6 +372722,87 @@ async function* doPlanJSONFormat(item, op, handler) {
             await handler.writeTerraformOutputInTfResult(item, e);
         }
     }
+    finally {
+        if (error) {
+            if (op === OperationType.SYNC) {
+                // if there is an error on a sync we never put the state on error
+                // it would be problematic because the RETRY op kicks in
+                if (error) {
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'SYNCHRONIZED',
+                        status: 'True',
+                        message: SYNC_DEFAULT_ERROR_MESSAGE,
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'PROVISIONED',
+                        status: 'True',
+                        message: 'doPlanJSONFormat',
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'PLANNING',
+                        status: 'False',
+                        message: 'doPlanJSONFormat',
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'OUT_OF_SYNC',
+                        status: 'False',
+                        message: 'doPlanJSONFormat',
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'ERROR',
+                        status: 'False',
+                        message: 'doPlanJSONFormat',
+                    };
+                }
+                setResult('SYNC_ERROR_PLAN');
+            }
+            else {
+                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,
+                };
+            }
+        }
+        else {
+            if (op === OperationType.SYNC) {
+                setResult('SYNC_SUCCESS');
+            }
+        }
+    }
 }
 async function* process_operation_created(item, op, handler) {
     for await (const transition of process_operation_doApply(item, op, handler)) {
@@ -372762,6 +372843,7 @@ function isDestroyRetry(item) {
     return false;
 }
 async function* process_operation_sync(item, op, handler, syncPolicy, generalPolicy) {
+    let doResult = '';
     if (!syncPolicy) {
         operator_src_logger.debug(`The Terraform processor is only observing item '${item.kind}/${item.metadata.name}' because no sync policy was found for operation '${op}'.`);
         yield* doPlanJSONFormat(item, op, handler);
@@ -372778,25 +372860,33 @@ async function* process_operation_sync(item, op, handler, syncPolicy, generalPol
                 break;
             }
             case 'observe': {
-                yield* doPlanJSONFormat(item, op, handler);
+                yield* doPlanJSONFormat(item, op, handler, (result) => {
+                    doResult = result;
+                });
                 break;
             }
             default: {
                 operator_src_logger.debug(`The Terraform processor detected a sync policy '${syncPolicy}' for item '${item.kind}/${item.metadata.name}' that is not supported.`);
-                yield* doPlanJSONFormat(item, op, handler);
+                yield* doPlanJSONFormat(item, op, handler, (result) => {
+                    doResult = result;
+                });
                 break;
             }
         }
     }
-    yield {
-        item,
-        reason: op,
-        type: 'SYNCHRONIZED',
-        status: 'True',
-        message: 'Sync process finished',
-    };
+    operator_src_logger.debug(`doResult is ${doResult}`);
+    if (doResult === 'SYNC_SUCCESS') {
+        yield {
+            item,
+            reason: op,
+            type: 'SYNCHRONIZED',
+            status: 'True',
+            message: 'Sync process finished',
+        };
+    }
 }
 async function* process_operation_markedToDeletion(item, op, handler) {
+    let error = false;
     try {
         const type = 'DELETING';
         yield {
@@ -372877,19 +372967,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 {
@@ -372908,6 +373003,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,
@@ -372991,36 +373087,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';
@@ -373422,6 +373523,7 @@ async function* processOperationPlan_plan(item, op, handler, format = 'plain-tex
     }
 }
 async function* doPlanPlainTextFormat(item, op, handler, action) {
+    let error = false;
     try {
         yield {
             item,
@@ -373481,32 +373583,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);
@@ -373516,8 +373598,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,
@@ -373600,43 +373708,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
@@ -374107,6 +374220,7 @@ var sdk_metrics_build_src = __nccwpck_require__(84016);
 
 
 
+
 const INTERVAL_IN_SEGS = 60;
 class CRStateMetrics {
     constructor(kind, namespace, meter) {
@@ -374129,6 +374243,9 @@ class CRStateMetrics {
         this.deletedGauge = meter.createGauge('firestartr_deleted_total', {
             description: 'Total number of CRs in DELETED state',
         });
+        this.errorOnSyncGauge = meter.createGauge('firestartr_error_on_sync_total', {
+            description: 'Total number of CRs with failed SYNCs',
+        });
         this.namespace = namespace;
     }
     async start() {
@@ -374157,10 +374274,18 @@ class CRStateMetrics {
             let errorCount = 0;
             let planningCount = 0;
             let deletedCount = 0;
+            let errorOnSyncCount = 0;
             for (const item of items) {
                 const status = item.status?.conditions.find((condition) => condition.type !== 'SYNCHRONIZED' && condition.status === 'True');
                 if (!status)
                     continue;
+                const syncCondition = item.status.conditions.find((condition) => {
+                    return condition.type === 'SYNCHRONIZED';
+                });
+                if (syncCondition &&
+                    syncCondition.message === SYNC_DEFAULT_ERROR_MESSAGE) {
+                    errorOnSyncCount++;
+                }
                 switch (status.type) {
                     case 'PROVISIONED':
                         provisionedCount++;
@@ -374206,6 +374331,10 @@ class CRStateMetrics {
                 namespace: this.namespace,
                 kind: this.kind,
             });
+            this.errorOnSyncGauge.record(errorOnSyncCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
         }
         catch (err) {
             console.log(`CRStateMetrics: update ${err}`);

package/build/packages/operator/src/metrics/CRStates.d.ts

@@ -8,6 +8,7 @@ export default class CRStateMetrics {
     planningGauge: any;
     deletedGauge: any;
     errorGauge: any;
+    errorOnSyncGauge: any;
     onUpdate: boolean;
     namespace: string;
     kc: any;

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

@@ -14,6 +14,7 @@ export type SyncStatus = {
     syncStatusPresent?: boolean;
     intervalLapsed?: boolean;
     syncMode?: SyncMode;
+    hasSyncFailed?: boolean;
 };
 export type SyncWatcher = {
     itemPath: string;

package/build/packages/operator/src/utils/operationErrorMessages.d.ts

@@ -1,3 +1,4 @@
 export declare const APPLY_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Terraform apply operation.";
 export declare const DESTROY_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Terraform destroy operation.";
 export declare const PLAN_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Terraform plan operation.";
+export declare const SYNC_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Sync operation.";

package/package.json

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