@firestartr/cli 1.51.1-snapshot-0 → 1.51.1-snapshot-01

package/build/index.js

@@ -346931,6 +346931,7 @@ const DEFAULT_TIME_ZONE = 'Europe/Madrid';
 function validateCron(cronLine, tz = DEFAULT_TIME_ZONE) {
     try {
         const interval = cron_parser_dist.CronExpressionParser.parse(cronLine, {
+            // to enable the only minutes cron
             strict: false,
             tz,
         });
@@ -358187,6 +358188,7 @@ const GithubSchemas = [
                                     type: 'string',
                                 },
                             },
+                            additionalProperties: false,
                             required: ['enabled'],
                             oneOf: [
                                 {
@@ -367338,6 +367340,28 @@ async function needsProvisioningOnCreate(cr) {
     operator_src_logger.debug(`Skipping the provisioning process for custom resource '${cr.kind}/${cr.metadata.name}' because its current state is not handled.`);
     return false;
 }
+async function updateSyncTransition(itemPath, reason, lastSyncTime, nextSyncTime, message, status) {
+    operator_src_logger.info(`The item at '${itemPath}' transitioned to a new SYNCHRONIZED condition of '${status}'. The reason for the change is '${reason}' with the message: '${message}'.`);
+    const k8sItem = await getItemByItemPath(itemPath);
+    if (!('status' in k8sItem))
+        k8sItem.status = {};
+    if (!('conditions' in k8sItem.status))
+        k8sItem.status.conditions = [];
+    let conditionObject = getRelevantCondition(k8sItem.status.conditions, 'SYNCHRONIZED');
+    conditionObject = {
+        ...conditionObject,
+        reason,
+        status,
+        message,
+        observedGeneration: k8sItem.metadata.generation,
+        lastSyncTime,
+        lastUpdateTime: new Date().toJSON(),
+        nextSyncTime,
+    };
+    k8sItem.status.conditions = updateConditionByType(k8sItem.status.conditions, 'SYNCHRONIZED', conditionObject);
+    const itemParameters = itemPath.split('/');
+    await writeStatus(itemParameters[1], itemParameters[0], k8sItem);
+}
 async function updateTransition(itemPath, reason, type, statusValue, message = '', updateStatusOnly = false) {
     operator_src_logger.info(`The item at '${itemPath}' transitioned to a new status of '${statusValue}' (type: '${type}'). The reason for the change is '${reason}' with the message: '${message}'. This was a status-only update: '${updateStatusOnly}'.`);
     const k8sItem = await getItemByItemPath(itemPath);
@@ -367398,12 +367422,115 @@ function updateConditionByType(conditionList, type, newCondition) {
     return conditionList;
 }
 
-;// CONCATENATED MODULE: ../operator/src/syncer.ts
+;// CONCATENATED MODULE: ../operator/src/syncCtl.ts
+// Machinery for syncing
+
+
 
 
-const syncWatchers = {};
-const FORCE_REVISION_TIME = 60 * 1000;
 const DEFAULT_REVISION_TIME = '1m';
+async function createWatcherForItem(itemPath, itemCR) {
+    const item = itemCR ?? await getItemByItemPath(itemPath);
+    const syncStatus = await getSyncStatus(itemPath, item);
+    let nextTimeoutInMS = syncStatus.nextTimeoutInMS;
+    // we have lapsed last interval
+    // we calculate from the lastSyncTime
+    if (syncStatus.intervalLapsed) {
+        operator_src_logger.debug(`Next sync interval have been lapsed for ${itemPath}`);
+        if (syncStatus.syncMode === 'Period') {
+            operator_src_logger.debug(`Next sync interval have been lapsed for ${itemPath} the sync will start now`);
+            nextTimeoutInMS = -1;
+        }
+    }
+    const watcher = {
+        itemPath,
+        lastRevision: setTimeout(() => {
+            operator_src_logger.debug(`Item ${itemPath} needs revision`);
+            watcher.needsRevision = true;
+        }, nextTimeoutInMS),
+        needsRevision: false,
+    };
+    return watcher;
+}
+async function destroyWatcherForItem(watcher) {
+    clearTimeout(watcher.lastRevision);
+    operator_src_logger.debug(`Disabled SyncWatcher for ${watcher.itemPath}`);
+}
+async function getSyncSpecs(itemPath, itemCR) {
+    const item = itemCR ?? await getItemByItemPath(itemPath);
+    return {
+        item,
+        syncable: item.metadata.annotations &&
+            item.metadata.annotations['firestartr.dev/sync-enabled'] &&
+            item.metadata.annotations['firestartr.dev/sync-enabled'] === 'true',
+        period: item.metadata.annotations['firestartr.dev/sync-period'] ||
+            DEFAULT_REVISION_TIME,
+        schedule: item.metadata.annotations['firestartr.dev/sync-schedule'] || false,
+        scheduleTZ: item.metadata.annotations['firestartr.dev/sync-schedule-timezone'] ||
+            'Europe/Madrid',
+    };
+}
+async function getSyncStatus(itemPath, itemCR) {
+    const item = itemCR ?? await getItemByItemPath(itemPath);
+    const syncCondition = getConditionByType(item.status?.conditions ?? [], 'SYNCHRONIZED');
+    // no sync condition present
+    if (!syncCondition) {
+        return {
+            syncStatusPresent: false,
+        };
+    }
+    else {
+        const nextSyncDate = new Date(syncCondition.nextSyncTime);
+        const isLapsed = Date.now() >= nextSyncDate.getTime();
+        const mode = (await getSyncSpecs(itemPath, item)).schedule
+            ? 'Scheduled'
+            : 'Period';
+        return {
+            itemPath,
+            syncMode: mode,
+            conditions: [syncCondition],
+            syncStatusPresent: true,
+            nextTimeoutInMS: isLapsed ? -1 : nextSyncDate.getTime() - Date.now(),
+            intervalLapsed: isLapsed,
+        };
+    }
+}
+async function setSyncStatus(itemPath, reason, status, message) {
+    const item = await getItemByItemPath(itemPath);
+    const machinery = assessSyncCalculationMachinery(item);
+    const syncStatus = await machinery(item, reason, status, message);
+    syncStatus.itemPath = itemPath;
+    syncStatus.syncStatusPresent = true;
+    operator_src_logger.info(`Setting sync status for ${itemPath}: ${JSON.stringify(syncStatus)}`);
+    const syncTransition = syncStatus.conditions[0];
+    await updateSyncTransition(itemPath, syncTransition.reason, syncTransition.lastSyncTime, syncTransition.nextSyncTime, syncTransition.message, syncTransition.status);
+    return syncStatus;
+}
+function assessSyncCalculationMachinery(item) {
+    if (item.metadata.annotations['firestartr.dev/sync-schedule'] ?? false) {
+        return processScheduledSync;
+    }
+    else {
+        return processPeriodSync;
+    }
+}
+async function processPeriodSync(item, reason, status, message) {
+    const period = item.metadata.annotations['firestartr.dev/sync-period'];
+    const periodMS = helperCalculateRevisionTime(period);
+    return {
+        syncMode: 'Period',
+        conditions: [
+            {
+                reason,
+                type: 'SYNCHRONIZED',
+                message,
+                status,
+                lastSyncTime: new Date().toISOString(),
+                nextSyncTime: new Date(Date.now() + periodMS).toISOString(),
+            },
+        ],
+    };
+}
 function helperCalculateRevisionTime(period) {
     const [_, scalar, dimension] = period.split(/(\d+)/);
     const multiplier = dimension === 's'
@@ -367417,24 +367544,50 @@ function helperCalculateRevisionTime(period) {
                     : 1;
     return Number(scalar) * multiplier * 1000;
 }
+async function processScheduledSync(item, reason, status, message) {
+    const nextPeriod = catalog_common.cron.getCronNextInterval(item.metadata.annotations['firestartr.dev/sync-schedule'], item.metadata.annotations['firestartr.dev/sync-schedule-timezone'] ||
+        undefined);
+    const nextPeriodDate = new Date(nextPeriod);
+    return {
+        syncMode: 'Scheduled',
+        conditions: [
+            {
+                reason,
+                type: 'SYNCHRONIZED',
+                message,
+                status,
+                lastSyncTime: new Date().toISOString(),
+                nextSyncTime: nextPeriodDate.toISOString(),
+            },
+        ],
+    };
+}
+
+;// CONCATENATED MODULE: ../operator/src/syncer.ts
+
+
+
+const syncWatchers = {};
+const FORCE_REVISION_TIME = (/* unused pure expression or super */ null && (60 * 1000));
 async function syncer(enqueue) {
     // fork
     void loop(enqueue);
     return {
         addItem(itemPath) {
             operator_src_logger.info(`Added item of path '${itemPath}' for synchronization`);
-            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
+            getSyncSpecs(itemPath)
+                .then(async (itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
                     return;
                 }
-                syncWatchers[itemPath] = {
-                    itemPath,
-                    lastRevision: setInterval(() => {
-                        syncWatchers[itemPath].needsRevision = true;
-                    }, helperCalculateRevisionTime(itemSyncInfo.period)),
-                    needsRevision: false,
-                };
+                const syncCtl = await getSyncStatus(itemPath, itemSyncInfo.item);
+                syncWatchers[itemPath] = await createWatcherForItem(itemPath, itemSyncInfo.item);
                 operator_src_logger.info(`Configured synchronization for item at path '${itemPath}'`);
+                operator_src_logger.debug(`Sync information for '${itemPath}': ${JSON.stringify({ ...itemSyncInfo, item: null }, null)}`);
+            })
+                .catch((err) => {
+                operator_src_logger.error(`Error on sync [add item]: ${err}`);
+                throw `Error on sync [add item]: ${err}`;
             });
         },
         updateItem(itemPath) {
@@ -367443,27 +367596,24 @@ async function syncer(enqueue) {
             //  return
             //}
             operator_src_logger.debug(`Updated item of path '${itemPath}' during synchronization`);
-            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
-                if (!itemSyncInfo.syncable) {
-                    if (syncWatchers[itemPath]) {
-                        clearInterval(syncWatchers[itemPath].lastRevision);
-                        delete syncWatchers[itemPath];
-                        operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
-                    }
+            getSyncSpecs(itemPath)
+                .then(async (itemSyncInfo) => {
+                if (syncWatchers[itemPath]) {
+                    await destroyWatcherForItem(syncWatchers[itemPath]);
+                    delete syncWatchers[itemPath];
                 }
-                else {
-                    if (itemSyncInfo.syncable && syncWatchers[itemPath]) {
-                        clearInterval(syncWatchers[itemPath].lastRevision);
-                    }
-                    syncWatchers[itemPath] = {
-                        itemPath,
-                        lastRevision: setInterval(() => {
-                            syncWatchers[itemPath].needsRevision = true;
-                        }, helperCalculateRevisionTime(itemSyncInfo.period)),
-                        needsRevision: false,
-                    };
-                    operator_src_logger.debug(`Configured synchronization for item at path '${itemPath}' with watcher '${syncWatchers[itemPath]}'`);
+                // we need to chedk if the item is not syncable anymore
+                if (!itemSyncInfo.syncable) {
+                    operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
+                    return;
                 }
+                // if it is syncable we need to recalculate everything
+                syncWatchers[itemPath] = await createWatcherForItem(itemPath);
+                operator_src_logger.info(`Configured synchronization for item at path '${itemPath}' with watcher`);
+            })
+                .catch((err) => {
+                operator_src_logger.error(`Error on sync [updateItem]: ${err}`);
+                throw `Error on sync [updateItem]: ${err}`;
             });
         },
         deleteItem(itemPath) {
@@ -367471,10 +367621,15 @@ async function syncer(enqueue) {
                 operator_src_logger.debug(`Ignored deletion attempt for item at path '${itemPath}' as it was not found during synchronization`);
                 return;
             }
-            operator_src_logger.debug(`Deleted item of path '${itemPath}' during synchronization`);
-            clearInterval(syncWatchers[itemPath].lastRevision);
-            delete syncWatchers[itemPath];
-            operator_src_logger.debug(`Successfully deleted item at path '${itemPath}' during synchronization`);
+            destroyWatcherForItem(syncWatchers[itemPath])
+                .then(() => {
+                operator_src_logger.debug(`Deleted item of path '${itemPath}' during synchronization`);
+                delete syncWatchers[itemPath];
+            })
+                .catch((err) => {
+                operator_src_logger.error(`Error deleting item of path ${itemPath} for synchronization: ${err}`);
+                throw `Error deleting item of path ${itemPath} for synchronization: ${err}`;
+            });
         },
     };
 }
@@ -367484,23 +367639,14 @@ async function loop(enqueueIfNeeded) {
         const needRevisionItems = Object.values(syncWatchers).filter((watcher) => watcher.needsRevision);
         for (const watcher of needRevisionItems) {
             const item = await getItemIfNeededSync(watcher);
+            operator_src_logger.debug(`Item needs revision ${watcher.itemPath}`);
             if (item !== null) {
                 enqueueIfNeeded(item);
-                watcher.needsRevision = false;
             }
+            watcher.needsRevision = false;
         }
     }
 }
-async function itemIsSyncable(itemPath) {
-    const item = await getItemByItemPath(itemPath);
-    return {
-        syncable: item.metadata.annotations &&
-            item.metadata.annotations['firestartr.dev/sync-enabled'] &&
-            item.metadata.annotations['firestartr.dev/sync-enabled'] === 'true',
-        period: item.metadata.annotations['firestartr.dev/sync-period'] ||
-            DEFAULT_REVISION_TIME,
-    };
-}
 async function getItemIfNeededSync(watcher) {
     const item = await getItemByItemPath(watcher.itemPath);
     const isProvisioning = item.status?.conditions?.find((condition) => condition.type === 'PROVISIONING' && condition.status === 'True');
@@ -367509,13 +367655,7 @@ async function getItemIfNeededSync(watcher) {
     const isDeleting = item.status?.conditions?.find((condition) => condition.type === 'DELETING' && condition.status === 'True');
     if (isDeleting)
         return null;
-    const synchronizedCondition = item.status?.conditions?.find((condition) => condition.type === 'SYNCHRONIZED' && condition.status === 'True');
-    if (!synchronizedCondition)
-        return item;
-    const lastSync = new Date(synchronizedCondition.lastUpdateTime).getTime();
-    if (lastSync <= Date.now() - FORCE_REVISION_TIME)
-        return item;
-    return null;
+    return item;
 }
 function fWait(segs = 1) {
     return new Promise((ok) => {
@@ -367771,6 +367911,7 @@ var WorkStatus;
 
 
 
+
 const kindsWithFinalizer = [
     'FirestartrTerraformWorkspace',
     'FirestartrGithubGroup',
@@ -367890,14 +368031,17 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
         success: () => retryCtl.successReconciling(informer_itemPath(pluralKind, workItem.item)),
     };
     workItem.process = async function* (item, operation, handler) {
-        for await (const transition of compute(item, operation, handler)) {
-            yield transition;
-        }
-        if (operation === OperationType.RENAMED ||
+        const needsUpdateSyncContidions = operation === OperationType.RENAMED ||
             operation === OperationType.UPDATED ||
             operation === OperationType.SYNC ||
             operation === OperationType.CREATED ||
-            operation === OperationType.RETRY) {
+            operation === OperationType.RETRY;
+        await setSyncStatus(workItem.handler.itemPath(), operation, 'False', 'Sync process started');
+        for await (const transition of compute(item, operation, handler)) {
+            yield transition;
+        }
+        if (needsUpdateSyncContidions) {
+            await setSyncStatus(workItem.handler.itemPath(), operation, operation === OperationType.SYNC ? 'True' : 'False', 'Sync process finished');
             syncCtl.updateItem(informer_itemPath(pluralKind, item));
         }
         else {
@@ -372023,13 +372167,6 @@ function isDestroyRetry(item) {
     return false;
 }
 async function* process_operation_sync(item, op, handler, syncPolicy, generalPolicy) {
-    yield {
-        item,
-        reason: op,
-        type: 'SYNCHRONIZED',
-        status: 'False',
-        message: 'Sync process started',
-    };
     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);

package/build/packages/cdk8s_renderer/src/claims/base/schemas/index.d.ts

@@ -686,6 +686,7 @@ declare const schemas: {
                                     type: string;
                                 };
                             };
+                            additionalProperties: boolean;
                             required: string[];
                             oneOf: ({
                                 required: string[];

package/build/packages/cdk8s_renderer/src/claims/tfworkspaces/index.d.ts

@@ -41,6 +41,7 @@ export declare const TerraformSchemas: {
                                 type: string;
                             };
                         };
+                        additionalProperties: boolean;
                         required: string[];
                         oneOf: ({
                             required: string[];

package/build/packages/cdk8s_renderer/src/claims/tfworkspaces/terraform.schema.d.ts

@@ -41,6 +41,7 @@ declare const _default: {
                                 type: string;
                             };
                         };
+                        additionalProperties: boolean;
                         required: string[];
                         oneOf: ({
                             required: string[];

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

@@ -1,2 +1,4 @@
 export declare function needsProvisioningOnCreate(cr: any): Promise<boolean>;
+export declare function updateSyncTransition(itemPath: string, reason: string, lastSyncTime: string, nextSyncTime: string, message: string, status: string): Promise<void>;
 export declare function updateTransition(itemPath: string, reason: string, type: string, statusValue: string, message?: string, updateStatusOnly?: boolean): Promise<void>;
+export declare function getConditionByType(conditionList: Array<any>, type: string): any;

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

@@ -0,0 +1,26 @@
+export type Condition = {
+    type: string;
+    status: 'True' | 'False' | 'Unknown';
+    reason: string;
+    message: string;
+    lastSyncTime?: string;
+    nextSyncTime?: string;
+};
+export type SyncStatus = {
+    itemPath?: string;
+    conditions?: Condition[];
+    nextTimeoutInMS?: number;
+    syncStatusPresent?: boolean;
+    intervalLapsed?: boolean;
+    syncMode?: 'Scheduled' | 'Period';
+};
+export type SyncWatcher = {
+    itemPath: string;
+    lastRevision: any;
+    needsRevision: boolean;
+};
+export declare function createWatcherForItem(itemPath: string, itemCR?: any): Promise<SyncWatcher>;
+export declare function destroyWatcherForItem(watcher: SyncWatcher): Promise<void>;
+export declare function getSyncSpecs(itemPath: string, itemCR?: any): Promise<any>;
+export declare function getSyncStatus(itemPath: string, itemCR?: any): Promise<SyncStatus>;
+export declare function setSyncStatus(itemPath: string, reason: string, status: 'True' | 'False' | 'Unknown', message: string): Promise<SyncStatus>;

package/package.json

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