@firestartr/cli 1.54.0 → 1.55.0-snapshot-0

package/build/index.js

@@ -359664,6 +359664,13 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                         },
                     },
                 },
+                filesTemplates: {
+                    type: 'array',
+                    description: 'a list of references to a different file where files key is filled by an expanded template',
+                    items: {
+                        type: 'string',
+                    },
+                },
             },
             required: ['args', 'feature_name', 'files', 'patches'],
             title: 'root',
@@ -359683,7 +359690,7 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
             additionalProperties: false,
             properties: {
                 $lit: {
-                    type: 'string',
+                    type: ['string', 'boolean'],
                 },
                 $ref: {
                     type: 'array',
@@ -359695,7 +359702,7 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                     type: 'string',
                 },
                 $default: {
-                    type: ['string', 'array'],
+                    type: ['string', 'array', 'boolean'],
                 },
             },
         },
@@ -359775,7 +359782,9 @@ function __validateFeatureConfig(featurePath) {
     }
 }
 function __validateFeatureConfigData(configData) {
-    const ajv = new (ajv_default())();
+    const ajv = new (ajv_default())({
+        allowUnionTypes: true,
+    });
     const validate = ajv.compile(src_schema);
     const valid = validate(configData);
     if (!valid) {
@@ -360609,10 +360618,14 @@ function addTraceabilityStamp(context, content) {
 
 
 
+
 function render(featurePath, featureRenderPath, entity, firestartrConfig = {}, featureArgs = {}) {
     const configData = validate_validate(featurePath);
     const context = buildContext(entity, configData.args, firestartrConfig, featureArgs);
     context.config = JSON.parse(renderContent(JSON.stringify(configData), context));
+    if ('filesTemplates' in context.config) {
+        expandFiles(featurePath, configData, context);
+    }
     const output = { files: [] };
     context.config.files.forEach((file) => {
         const { src, dest } = file;
@@ -360670,6 +360683,22 @@ function buildContext(entity, args, firestartrConfig, featureArgs) {
     context.traceability = featureArgs['traceability'] || {};
     return context;
 }
+function expandFiles(featurePath, configData, context) {
+    let files = [];
+    for (const tpl of configData.filesTemplates) {
+        const addToFiles = expandFilesTemplate(featurePath, tpl, context);
+        files = files.concat(addToFiles).flat(Infinity);
+    }
+    context.config.files = context.config.files.concat(files).flat(Infinity);
+}
+function expandFilesTemplate(featurePath, tplPath, context) {
+    const template = external_fs_default().readFileSync(external_path_default().join(featurePath, tplPath)).toString();
+    const renderedTemplate = renderContent(template, context);
+    const data = catalog_common.io.fromYaml(renderedTemplate) || { files: [] };
+    if (!data.files)
+        data.files = [];
+    return data.files.filter((file) => file);
+}
 function renderContent(template, ctx) {
     return mustache_mustache.render(template, ctx, {}, ['{{|', '|}}']);
 }
@@ -360739,7 +360768,7 @@ function loadAndValidateRenderTests(featurePath) {
         throw new Error(`render_tests.yaml is required but not found at ${file}`);
     }
     const raw = loadYaml(file);
-    const ajv = new (ajv_default())({ allErrors: true, strict: true });
+    const ajv = new (ajv_default())({ allErrors: true, strict: true, allowUnionTypes: true });
     const validate = ajv.compile(renderTestsSchema);
     const ok = validate(raw);
     if (!ok) {
@@ -368565,6 +368594,11 @@ const kindsWithFinalizer = [
     'FirestartrGithubOrgWebhook',
     'FirestartrGithubRepositorySecretsSection',
 ];
+const kindsWithDependants = [
+    'FirestartrDummyA',
+    'FirestartrDummyB',
+    'FirestartrGithubRepository',
+];
 /**
  * Observe whenever a new item is added, modified or deleted in a given kind
  * @param {string} pluralKind - Kind to observe
@@ -368675,6 +368709,28 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
         itemPath: () => informer_itemPath(pluralKind, workItem.item),
         error: () => retryCtl.errorReconciling(informer_itemPath(pluralKind, workItem.item)),
         success: () => retryCtl.successReconciling(informer_itemPath(pluralKind, workItem.item)),
+        needsBlocking: (item) => {
+            if (kindsWithDependants.indexOf(item.kind) === -1) {
+                return false;
+            }
+            if (item.metadata.finalizers &&
+                item.metadata.finalizers.indexOf('foregroundDeletion') !== -1) {
+                // it will block for five seconds
+                workItem.isBlocked = true;
+                const tTimeout = setTimeout(() => {
+                    workItem.isBlocked = false;
+                }, 1000 * 5);
+                workItem.fUnblock = () => {
+                    clearTimeout(tTimeout);
+                    workItem.isBlocked = false;
+                };
+                return true;
+            }
+            else {
+                workItem.isBlocked = false;
+                return false;
+            }
+        },
     };
     workItem.process = async function* (item, operation, handler) {
         const needsUpdateSyncConditions = operation === OperationType.RENAMED ||
@@ -368703,6 +368759,7 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
             operator_src_logger.debug(`The informer received an item with an operation type of '${operation}', which is not a specific operation.`);
         }
     };
+    workItem.isBlocked = false;
     queue(workItem);
 }
 function informer_itemPath(kind, item) {
@@ -368926,10 +368983,72 @@ function dummy_fWait(ms) {
     });
 }
 
+;// CONCATENATED MODULE: ../operator/src/ownership.ts
+
+
+
+async function getOwnerReferences(item) {
+    return item.metadata?.ownerReferences || [];
+}
+async function setOwnerReference(itemPath, namespace, ownerKind, ownerName, blockOwnerDeletion = true) {
+    let item = null;
+    try {
+        // we need to search for the owner's uuid
+        const owner = await getItemByItemPath(`${namespace}/${ownerKind}/${ownerName}`);
+        const ownerReference = {
+            apiVersion: owner.apiVersion,
+            kind: owner.kind,
+            name: ownerName,
+            controller: true,
+            blockOwnerDeletion,
+            uid: owner.metadata.uid,
+        };
+        // we get the item (to prevent race conditions)
+        item = await getItemByItemPath(itemPath);
+        const ownerReferences = item.metadata.ownerReferences ?? [];
+        const existingRefIndex = ownerReferences.findIndex((ref) => ref.uid === ownerReference.uid);
+        if (existingRefIndex === -1) {
+            // Reference does not exist, add it
+            ownerReferences.push(ownerReference);
+        }
+        else {
+            ownerReferences[existingRefIndex] = ownerReference;
+        }
+        await writeOwnerReferences(definitions_getPluralFromKind(item.kind), item.metadata.namespace, item, ownerReferences);
+    }
+    catch (err) {
+        operator_src_logger.error(err);
+        throw `Setting OwnerReferences to ${item.kind}/${item.metadata.name}: ${err}`;
+    }
+}
+async function writeOwnerReferences(kind, namespace, item, ownerReferences) {
+    operator_src_logger.debug(`The ctl is setting the ownerReferences for '${kind}/${item.metadata.name}' in namespace '${namespace}'.`);
+    const { kc, opts } = await ctl_getConnection();
+    const url = `${kc.getCurrentCluster().server}/apis/firestartr.dev/v1/namespaces/${namespace}/${kind}/${item.metadata.name}`;
+    opts.headers['Content-Type'] = 'application/json-patch+json';
+    opts.headers['Accept'] = '*';
+    const patch = {
+        op: 'replace',
+        path: '/metadata/ownerReferences',
+        value: ownerReferences,
+    };
+    const r = await fetch(url, {
+        method: 'PATCH',
+        headers: opts.headers,
+        body: JSON.stringify([patch]),
+    });
+    if (!r.ok) {
+        throw `Error on setOwnerReferences: ${namespace}/${kind}/${item['metadata']['name']}: ${r.statusText}`;
+    }
+    return r.json();
+}
+
 ;// CONCATENATED MODULE: ../operator/fdummies/index.ts
 
 
 
+
+
 function processFirestartrDummies(item, op, handler) {
     operator_src_logger.info(`FirestartrDummies Processor: ${op}`);
     try {
@@ -368960,11 +369079,19 @@ async function* updated(item, op, handler) {
     for await (const transition of doRun(item, op, handler)) {
         yield transition;
     }
+    await handleOwnerReferences(item, handler);
 }
 async function* created(item, op, handler) {
     for await (const transition of doRun(item, op, handler)) {
         yield transition;
     }
+    await handleOwnerReferences(item, handler);
+}
+async function handleOwnerReferences(item, handler) {
+    if ('needs' in item.spec) {
+        const needs = item.spec.needs;
+        await setOwnerReference(handler.itemPath(), item.metadata.namespace, definitions_getPluralFromKind(needs.kind), needs.name);
+    }
 }
 async function renamed() {
     throw new Error('Renamed operation not prepared');
@@ -369035,7 +369162,7 @@ async function* markedToDeletion(item, op, handler) {
             message: 'Destroying process started',
         };
         await handler.resolveReferences();
-        await processDummy(item);
+        await processDummy(item, op);
         yield {
             item,
             reason: op,
@@ -369104,7 +369231,7 @@ async function* doRun(item, op, handler) {
         };
         const deps = await handler.resolveReferences();
         operator_src_logger.info(`The dummy processor is applying and assessing dependencies for item '${item.kind}/${item.metadata.name}' with dependencies: '${deps}'.`);
-        await processDummy(item);
+        await processDummy(item, op);
         yield {
             item,
             reason: op,
@@ -369160,11 +369287,13 @@ async function* doRun(item, op, handler) {
         }
     }
 }
-async function processDummy(item) {
-    const s = item.spec?.computation?.numberOfSeconds;
-    operator_src_logger.info(`Processing dummy ${item.kind}/${item.metadata.name}: computing for ${s} seconds`);
+async function processDummy(item, op) {
+    const s = op === OperationType.MARKED_TO_DELETION
+        ? item.spec?.computation?.numberOfSecondsToDestroy
+        : item.spec?.computation?.numberOfSeconds;
+    operator_src_logger.info(`Processing dummy (op = ${op}) ${item.kind}/${item.metadata.name}: computing for ${s} seconds`);
     if (!s)
-        throw new Error('Unprocessable dummy: missing seconds section');
+        throw new Error('Unprocessable dummy: no seconds section');
     await fdummies_fWait(s * 1000);
 }
 function fdummies_fWait(ms) {
@@ -369197,7 +369326,8 @@ async function writeDownQueueStatus(queue) {
     let output = '';
     for (const workItem of queue) {
         const item = workItem.item;
-        output += `${item.kind}/${item.metadata.name} - ${workItem.workStatus} - ${workItem.operation} - (upsert ${formatElapsedTimeWithDate(workItem.upsertTime)})\n`;
+        const blockedText = workItem.isBlocked ? '[BLOCKED]' : '';
+        output += `${item.kind}/${item.metadata.name} - ${workItem.workStatus} - ${workItem.operation} ${blockedText} - (upsert ${formatElapsedTimeWithDate(workItem.upsertTime)})\n`;
     }
     return new Promise((ok, ko) => {
         external_fs_.writeFile('/tmp/queue', output, (err) => {
@@ -369390,7 +369520,9 @@ async function processItem(workItem) {
  * @returns {void}
  */
 async function processItem_loop() {
-    const nextWorkItem = () => sortQueue(queue).find((w) => w.workStatus === WorkStatus.PENDING);
+    const nextWorkItem = () => sortQueue(queue)
+        .filter((w) => !w.isBlocked)
+        .find((w) => w.workStatus === WorkStatus.PENDING);
     loopWorkItemDebug(queue);
     while (1) {
         const w = nextWorkItem();
@@ -369454,6 +369586,14 @@ async function runWorkItem(workItem) {
         return;
     try {
         const item = await workItem.getItem();
+        // we check if the workItem needs blocking
+        // if it does need it we return because we cannot
+        // process this item
+        if ('needsBlocking' in workItem.handler &&
+            workItem.handler.needsBlocking(item)) {
+            operator_src_logger.debug(`Item ${item.kind}/${item.metadata.namespace} needs blocking`);
+            return;
+        }
         workItem.workStatus = WorkStatus.PROCESSING;
         for await (const condition of workItem.process(item, workItem.operation, workItem.handler)) {
             if (workItem.handler === undefined)
@@ -371663,6 +371803,33 @@ function helperCreateCheckRunName(cmd, item) {
     return `${item.kind} - ${cmd}`;
 }
 
+;// CONCATENATED MODULE: ../operator/src/cdktf/ownership.ts
+
+
+
+const kindsWithFirestartrGithubRepositoryDependence = [
+    'FirestartrGithubRepositorySecretsSection',
+    'FirestartrGithubRepositoryFeature',
+];
+async function manageOwnershipReferences(item, handler, op) {
+    if (kindsWithFirestartrGithubRepositoryDependence.indexOf(item.kind) !== -1) {
+        await manageOwnershipReferencesForRepo(item, handler, op);
+    }
+}
+async function manageOwnershipReferencesForRepo(item, handler, op) {
+    try {
+        const repositoryTarget = item.spec?.repositoryTarget?.ref;
+        if (!repositoryTarget) {
+            throw `Item ${item.kind}/${item.metadata.namespace} is not correct: it does not have a repositoryTarget`;
+        }
+        await setOwnerReference(handler.itemPath(), item.metadata.namespace, definitions_getPluralFromKind(repositoryTarget.kind), repositoryTarget.name);
+    }
+    catch (err) {
+        operator_src_logger.error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
+        throw new Error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
+    }
+}
+
 ;// CONCATENATED MODULE: ../operator/cdktf.ts
 
 
@@ -371673,6 +371840,7 @@ function helperCreateCheckRunName(cmd, item) {
 
 
 
+
 function processOperation(item, op, handler) {
     operator_src_logger.info(`Processing operation ${op} on ${item.kind}/${item.metadata?.name}`);
     try {
@@ -371704,16 +371872,19 @@ async function* cdktf_created(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
 async function* cdktf_renamed(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
 async function* cdktf_updated(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
 async function* cdktf_retry(item, op, handler) {
     if ('deletionTimestamp' in item.metadata) {

package/build/packages/features_renderer/src/render.d.ts

@@ -1,3 +1,4 @@
 export default function render(featurePath: string, featureRenderPath: string, entity: any, firestartrConfig?: any, featureArgs?: any): any;
 export declare function buildContext(entity: any, args: any, firestartrConfig: any, featureArgs: any): any;
+export declare function expandFiles(featurePath: string, configData: any, context: any): void;
 export declare function renderContent(template: string, ctx: any): string;

package/build/packages/features_renderer/src/schema.d.ts

@@ -29,6 +29,13 @@ declare const _default: {
                         };
                     };
                 };
+                filesTemplates: {
+                    type: string;
+                    description: string;
+                    items: {
+                        type: string;
+                    };
+                };
             };
             required: string[];
             title: string;
@@ -48,7 +55,7 @@ declare const _default: {
             additionalProperties: boolean;
             properties: {
                 $lit: {
-                    type: string;
+                    type: string[];
                 };
                 $ref: {
                     type: string;

package/build/packages/operator/src/cdktf/ownership.d.ts

@@ -0,0 +1,2 @@
+import { OperationType } from '../informer';
+export declare function manageOwnershipReferences(item: any, handler: any, op: OperationType): Promise<void>;

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

@@ -23,6 +23,8 @@ export type WorkItem = {
     process?: Function;
     upsertTime?: number;
     isDeadLetter?: boolean;
+    isBlocked?: boolean;
+    fUnblock?: Function;
 };
 type HandlerFinalizerFn = (kind: string, namespace: string, item: any | string, finalizer: string) => Promise<any>;
 type HandlerInformPlanFn = (prUrl: string, planText: string) => Promise<void>;
@@ -44,6 +46,9 @@ export type WorkItemHandler = {
     itemPath: ItemPathFn;
     error: ErrorFn;
     success: SuccessFn;
+    isBlocked?: boolean;
+    needsBlocking?: (item: any) => boolean;
+    fUnblock?: Function;
 };
 /**
  * Observe whenever a new item is added, modified or deleted in a given kind

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

@@ -0,0 +1,4 @@
+import { OwnerReference } from './types';
+export declare function getOwnerReferences(item: any): Promise<OwnerReference[]>;
+export declare function setOwnerReference(itemPath: string, namespace: string, ownerKind: string, ownerName: string, blockOwnerDeletion?: boolean): Promise<void>;
+export declare function writeOwnerReferences(kind: string, namespace: string, item: any, ownerReferences: OwnerReference[]): Promise<any>;

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

@@ -0,0 +1,8 @@
+export interface OwnerReference {
+    apiVersion: string;
+    kind: string;
+    name: string;
+    uid: string;
+    controller?: boolean;
+    blockOwnerDeletion?: boolean;
+}

package/package.json

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