@firestartr/cli 1.53.0 → 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
 
 
@@ -372609,7 +372623,7 @@ 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 {
@@ -372710,34 +372724,83 @@ async function* doPlanJSONFormat(item, op, handler) {
     }
     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,
-            };
+            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');
+            }
         }
     }
 }
@@ -372780,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);
@@ -372796,23 +372860,30 @@ 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;
@@ -374149,6 +374220,7 @@ var sdk_metrics_build_src = __nccwpck_require__(84016);
 
 
 
+
 const INTERVAL_IN_SEGS = 60;
 class CRStateMetrics {
     constructor(kind, namespace, meter) {
@@ -374171,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() {
@@ -374199,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++;
@@ -374248,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",
+  "version": "1.53.1-release-candidate",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",