@firestartr/cli 1.51.1-snapshot-02 → 1.51.1-snapshot-04

package/build/index.js

@@ -346931,7 +346931,6 @@ 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,11 +358186,7 @@ const GithubSchemas = [
                                 schedule_timezone: {
                                     type: 'string',
                                 },
-                                policy: {
-                                    type: 'string',
-                                }
                             },
-                            additionalProperties: false,
                             required: ['enabled'],
                             oneOf: [
                                 {
@@ -365474,11 +365469,16 @@ class GroupGithubDecanter extends GithubDecanter {
         });
     }
     __decantMembers() {
-        this.__patchClaim({
-            op: 'add',
-            value: this.data.members.map((member) => `user:${member.name}`),
-            path: '/members',
-        });
+        if (this.data.groupDetails.name.includes(`${this.org}-all`)) {
+            importer_src_logger.debug(`Skipping adding members for virtual ${this.data.groupDetails.name} group`);
+        }
+        else {
+            this.__patchClaim({
+                op: 'add',
+                value: this.data.members.map((member) => `user:${member.name}`),
+                path: '/members',
+            });
+        }
     }
     __decantProviders() {
         this.__patchClaim({
@@ -367343,28 +367343,6 @@ 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);
@@ -367425,115 +367403,12 @@ function updateConditionByType(conditionList, type, newCondition) {
     return conditionList;
 }
 
-;// CONCATENATED MODULE: ../operator/src/syncCtl.ts
-// Machinery for syncing
-
-
+;// CONCATENATED MODULE: ../operator/src/syncer.ts
 
 
+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'
@@ -367547,50 +367422,24 @@ 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`);
-            getSyncSpecs(itemPath)
-                .then(async (itemSyncInfo) => {
+            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
                     return;
                 }
-                const syncCtl = await getSyncStatus(itemPath, itemSyncInfo.item);
-                syncWatchers[itemPath] = await createWatcherForItem(itemPath, itemSyncInfo.item);
+                syncWatchers[itemPath] = {
+                    itemPath,
+                    lastRevision: setInterval(() => {
+                        syncWatchers[itemPath].needsRevision = true;
+                    }, helperCalculateRevisionTime(itemSyncInfo.period)),
+                    needsRevision: false,
+                };
                 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) {
@@ -367599,24 +367448,27 @@ async function syncer(enqueue) {
             //  return
             //}
             operator_src_logger.debug(`Updated item of path '${itemPath}' during synchronization`);
-            getSyncSpecs(itemPath)
-                .then(async (itemSyncInfo) => {
-                if (syncWatchers[itemPath]) {
-                    await destroyWatcherForItem(syncWatchers[itemPath]);
-                    delete syncWatchers[itemPath];
-                }
-                // we need to chedk if the item is not syncable anymore
+            void itemIsSyncable(itemPath).then((itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
-                    operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
-                    return;
+                    if (syncWatchers[itemPath]) {
+                        clearInterval(syncWatchers[itemPath].lastRevision);
+                        delete syncWatchers[itemPath];
+                        operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
+                    }
+                }
+                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]}'`);
                 }
-                // 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) {
@@ -367624,15 +367476,10 @@ async function syncer(enqueue) {
                 operator_src_logger.debug(`Ignored deletion attempt for item at path '${itemPath}' as it was not found during synchronization`);
                 return;
             }
-            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}`;
-            });
+            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`);
         },
     };
 }
@@ -367642,14 +367489,23 @@ 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');
@@ -367658,7 +367514,13 @@ async function getItemIfNeededSync(watcher) {
     const isDeleting = item.status?.conditions?.find((condition) => condition.type === 'DELETING' && condition.status === 'True');
     if (isDeleting)
         return null;
-    return item;
+    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;
 }
 function fWait(segs = 1) {
     return new Promise((ok) => {
@@ -367914,7 +367776,6 @@ var WorkStatus;
 
 
 
-
 const kindsWithFinalizer = [
     'FirestartrTerraformWorkspace',
     'FirestartrGithubGroup',
@@ -368034,17 +367895,14 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
         success: () => retryCtl.successReconciling(informer_itemPath(pluralKind, workItem.item)),
     };
     workItem.process = async function* (item, operation, handler) {
-        const needsUpdateSyncContidions = operation === OperationType.RENAMED ||
-            operation === OperationType.UPDATED ||
-            operation === OperationType.SYNC ||
-            operation === OperationType.CREATED ||
-            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');
+        if (operation === OperationType.RENAMED ||
+            operation === OperationType.UPDATED ||
+            operation === OperationType.SYNC ||
+            operation === OperationType.CREATED ||
+            operation === OperationType.RETRY) {
             syncCtl.updateItem(informer_itemPath(pluralKind, item));
         }
         else {
@@ -372170,6 +372028,13 @@ 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

@@ -685,11 +685,7 @@ declare const schemas: {
                                 schedule_timezone: {
                                     type: string;
                                 };
-                                policy: {
-                                    type: string;
-                                };
                             };
-                            additionalProperties: boolean;
                             required: string[];
                             oneOf: ({
                                 required: string[];

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

@@ -40,11 +40,7 @@ export declare const TerraformSchemas: {
                             schedule_timezone: {
                                 type: string;
                             };
-                            policy: {
-                                type: string;
-                            };
                         };
-                        additionalProperties: boolean;
                         required: string[];
                         oneOf: ({
                             required: string[];

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

@@ -40,11 +40,7 @@ declare const _default: {
                             schedule_timezone: {
                                 type: string;
                             };
-                            policy: {
-                                type: string;
-                            };
                         };
-                        additionalProperties: boolean;
                         required: string[];
                         oneOf: ({
                             required: string[];

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

@@ -1,4 +1,2 @@
 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/package.json

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

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

@@ -1,26 +0,0 @@
-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>;