@firestartr/cli 0.1.26 → 0.1.27

package/build/index.js

@@ -237047,20 +237047,19 @@ exports.operatorSubcommands = {
         { name: "observeMode", type: Boolean, defaultValue: false },
         { name: "plan", type: Boolean },
         { name: "apply", type: Boolean },
-        { name: "cr", alias: "c", type: String },
+        { name: "claim", alias: "c", type: String },
         { name: "namespace", alias: "n", type: String },
     ],
     run: async (options) => {
         // This will show the command line options passed to the command
         console.table(options);
         if (options["plan"] || options["apply"]) {
-            if (!options["cr"])
-                throw `Error: Missing arg: --cr`;
+            if (!options["claim"])
+                throw `Error: Missing arg: --claim`;
             if (!options["namespace"])
                 throw `Error: Missing arg: --namespace`;
-            const claimContentFile = Buffer.from(options["cr"], 'base64').toString('utf8');
             const command = options["plan"] ? "plan" : "apply";
-            await (0, operator_1.execTfCommand)(command, claimContentFile, options["namespace"] || "default");
+            await (0, operator_1.execTfCommand)(command, options["claim"], options["namespace"] || "default");
             return;
         }
         if (!options["start"]) {
@@ -240299,14 +240298,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.tfPlanner = void 0;
+exports.kubectlCp = exports.tfPlanner = void 0;
 const client = __importStar(__nccwpck_require__(54851));
 const stream = __importStar(__nccwpck_require__(12781));
 const ctl_1 = __nccwpck_require__(46679);
 const catalog_common_1 = __importDefault(__nccwpck_require__(74100));
+const child_process_1 = __nccwpck_require__(32081);
 const deploymentName = catalog_common_1.default.environment.getFromEnvironment(catalog_common_1.default.types.envVars.operatorDeploymentName || "firestartr-firestartr-controller");
 const DEFAULT_OPERATOR_DEPLOY = deploymentName;
-async function tfPlanner(claim, namespace, debug, jobTtl, cmd = "plan") {
+async function tfPlanner(claimFilePath, claim, namespace, debug, jobTtl, cmd = "plan") {
     const { kc } = await (0, ctl_1.getConnection)();
     const k8sApi = kc.makeApiClient(client.AppsV1Api);
     const batchV1Api = kc.makeApiClient(client.BatchV1Api);
@@ -240330,7 +240330,7 @@ async function tfPlanner(claim, namespace, debug, jobTtl, cmd = "plan") {
     job.spec.template.spec.containers[0].command = [
         "sh",
         "-c",
-        `${executablePath} operator --${cmd} --cr ${Buffer.from(JSON.stringify(claim)).toString('base64')} --namespace ${namespace}`,
+        `${executablePath} operator --${cmd} --claim /tmp/claim.yaml --namespace ${namespace}`,
     ];
     if (debug) {
         job.spec.template.spec.containers[0].command[2] = job
@@ -240344,11 +240344,11 @@ async function tfPlanner(claim, namespace, debug, jobTtl, cmd = "plan") {
     job.spec.template.spec.restartPolicy = "Never";
     job.metadata = metadata;
     const createJobRes = await batchV1Api.createNamespacedJob(namespace, job);
-    await getLogs(namespace, job.metadata.name);
+    await copyClaimAndGetLogs(namespace, job.metadata.name, claimFilePath);
     await batchV1Api.deleteNamespacedJob(job.metadata.name, namespace);
 }
 exports.tfPlanner = tfPlanner;
-async function getLogs(namespace, jobName) {
+async function copyClaimAndGetLogs(namespace, jobName, sourcePath) {
     const { kc } = await (0, ctl_1.getConnection)();
     const k8sApi = kc.makeApiClient(client.CoreV1Api);
     const log = new client.Log(kc);
@@ -240375,7 +240375,12 @@ async function getLogs(namespace, jobName) {
             }
         }
     }
+    console.log("Waiting for pod to be running");
     await awaitPodStatus((phase) => phase != "Pending");
+    console.log("Pod is running");
+    console.log("Copying claim to pod");
+    await kubectlCp(sourcePath, namespace, pod.metadata.name);
+    console.log("Claim copied to pod");
     try {
         const req = await log.log(namespace, pod.metadata.name, pod.spec.containers[0].name, logStream, {
             follow: true,
@@ -240406,6 +240411,11 @@ async function getLogs(namespace, jobName) {
         return;
     }
 }
+function kubectlCp(sourcePath, namespace, podName) {
+    const command = `kubectl cp -n ${namespace} ${sourcePath} ${podName}:/tmp/claim.yaml`;
+    (0, child_process_1.execSync)(command);
+}
+exports.kubectlCp = kubectlCp;
 
 
 /***/ }),
@@ -240996,9 +241006,17 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.execTfCommand = void 0;
 const yaml = __importStar(__nccwpck_require__(26264));
 const ctx_1 = __nccwpck_require__(29296);
-async function execTfCommand(command, fileContent, namespace = "default") {
-    console.log(`execTfCommand: ${command} CR: ${fileContent}`);
-    const claim = yaml.load(fileContent);
+const fs = __importStar(__nccwpck_require__(57147));
+async function execTfCommand(command, filePath, namespace = "default") {
+    console.log(`execTfCommand: ${command} claim file path: ${filePath} namespace: ${namespace}`);
+    // The claim will be copied to the pod's filesystem
+    // and the operator will read it from there
+    // The operator should wait fort the claim file to be written
+    // before reading it
+    console.log(`Waiting for file ${filePath}`);
+    await waitForFile(filePath);
+    console.log(`File ${filePath} found`);
+    const claim = yaml.load(fs.readFileSync(filePath, 'utf8'));
     let ctx = null;
     switch (claim.kind) {
         case "TFWorkspaceClaim":
@@ -241015,6 +241033,23 @@ async function execTfCommand(command, fileContent, namespace = "default") {
     await ctx.exec("runProvision");
 }
 exports.execTfCommand = execTfCommand;
+function waitForFile(filePath) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error(`File not found within 60 seconds: ${filePath}`));
+        }, 65000);
+        const interval = setInterval(() => {
+            if (fs.existsSync(filePath)) {
+                clearInterval(interval);
+                clearTimeout(timeout);
+                // wait a bit more to make sure the file is fully written
+                setTimeout(() => {
+                    resolve();
+                }, 5000);
+            }
+        }, 500);
+    });
+}
 
 
 /***/ }),
@@ -245440,10 +245475,10 @@ class TFProjectManagerRemote {
         this.tfVarsJsonWriter.writeToTerraformProject(path.join(this.projectPath, "terraform.tfvars.json"));
     }
     async __configGit() {
-        fs.existsSync("/root/.gitconfig") && fs.rmSync("/root/.gitconfig");
+        fs.existsSync("/home/node/.gitconfig") && fs.rmSync("/home/node/.gitconfig");
         const org = catalog_common_1.default.environment.getFromEnvironment(catalog_common_1.default.types.envVars.org);
         const ghToken = await github_1.default.getGithubAppToken(org);
-        fs.writeFileSync("/root/.gitconfig", `[url "https://firestartr:${ghToken}@github.com"]
+        fs.writeFileSync("/home/node/.gitconfig", `[url "https://firestartr:${ghToken}@github.com"]
 insteadOf = https://github.com`);
     }
     async __init() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "private": false,
   "description": "Commandline tool",
   "main": "build/index.js",