Fix fetching charts when it's specified as <repo>/<chart> (#7)

Author: Nitive

e2e-tests/e2e.test.ts

@@ -1,4 +1,4 @@
-import { getAvailablePort } from "https://deno.land/x/port/mod.ts"
+import { getAvailablePort } from "https://deno.land/x/port@1.0.0/mod.ts"
 import * as fs from "https://deno.land/std@0.86.0/fs/mod.ts"
 import * as path from "https://deno.land/std@0.86.0/path/mod.ts"
 import * as yaml from "https://deno.land/std@0.86.0/encoding/yaml.ts"
@@ -17,9 +17,9 @@ function toText(bytes: Uint8Array): string {
   return new TextDecoder().decode(bytes)
 }
 
-async function runHelmDeno(args: string[]) {
+async function run(args: string[]) {
   const cmd = Deno.run({
-    cmd: [helmDenoBin, ...args],
+    cmd: args,
     env: {
       HELM_PLUGIN_DIR: helmPluginDir,
     },
@@ -37,6 +37,14 @@ async function runHelmDeno(args: string[]) {
   return { status, stdout: toText(output), stderr: toText(error) }
 }
 
+async function runHelm(args: string[]) {
+  return await run([Deno.env.get("HELM_BIN") as string, ...args])
+}
+
+async function runHelmDeno(args: string[]) {
+  return await run([helmDenoBin, ...args])
+}
+
 Deno.test({
   name: "should successfuly run `helm deno template` with deno chart",
   async fn() {
@@ -314,39 +322,26 @@ function sleep(ms: number): Promise<void> {
 
 async function startHelmRegistry() {
   const port = await getAvailablePort()
-  const cmd = Deno.run({
-    cmd: [
-      "docker",
-      "run",
-      "--rm",
-      "--detach",
-      `--publish=${port}:8080`,
-      "--env=STORAGE=local",
-      "--env=STORAGE_LOCAL_ROOTDIR=/home/chartmuseum/charts",
-      "chartmuseum/chartmuseum:v0.12.0@sha256:38c5ec3b30046d7a02a55b4c8bd8a0cd279538c2e36090973798a858e900b18e",
-    ],
-    stdout: "piped",
-    stderr: "piped",
-  })
-
-  const [status, stdout, stderr] = await Promise.all([
-    cmd.status(),
-    cmd.output(),
-    cmd.stderrOutput(),
+  const { status, stdout, stderr } = await run([
+    "docker",
+    "run",
+    "--rm",
+    "--detach",
+    `--publish=${port}:8080`,
+    "--env=STORAGE=local",
+    "--env=STORAGE_LOCAL_ROOTDIR=/home/chartmuseum/charts",
+    "chartmuseum/chartmuseum:v0.12.0@sha256:38c5ec3b30046d7a02a55b4c8bd8a0cd279538c2e36090973798a858e900b18e",
   ])
-  cmd.close()
 
   if (!status.success) {
-    throw new Error(
-      `Could not start chartmuseum ${new TextDecoder().decode(stderr)}`
-    )
+    throw new Error(`Could not start chartmuseum ${stderr}`)
   }
-  const containerID = new TextDecoder().decode(stdout)
+  const containerID = stdout.trim()
 
   let errorsCount = 0
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    if (errorsCount > 100) {
+    if (errorsCount > 10) {
       throw new Error("To many errors")
     }
     try {
@@ -364,24 +359,10 @@ async function startHelmRegistry() {
   return {
     url: `http://localhost:${port}`,
     async stop() {
-      // There is an error "response from daemon: 404 page not found"
-      // with full ID not sure why
-      const shortContainerID = containerID.slice(0, 12)
-      const cmd = Deno.run({
-        cmd: ["docker", "stop", shortContainerID],
-        stdout: "piped",
-        stderr: "piped",
-      })
-
-      const [status, , stderr] = await Promise.all([
-        cmd.status(),
-        cmd.output(),
-        cmd.stderrOutput(),
-      ])
-      cmd.close()
+      const { status, stderr } = await run(["docker", "stop", containerID])
 
       if (!status.success) {
-        const dockerStopError = new TextDecoder().decode(stderr)
+        const dockerStopError = stderr
         throw new Error(
           `Could not stop helm registry docker container ${containerID} ${dockerStopError}`
         )
@@ -663,3 +644,67 @@ Deno.test({
     assertEquals(status.success, true)
   },
 })
+
+Deno.test({
+  name:
+    "should successfuly run `helm deno template` with remote deno chart (with --repo option)",
+  ignore: !runAllTests,
+  async fn() {
+    const { status } = await runHelmDeno([
+      "template",
+      "ingress",
+      "nginx-ingress",
+      "--repo",
+      "https://charts.helm.sh/stable",
+      "--version",
+      "1.41.3",
+    ])
+
+    assertEquals(status.success, true)
+  },
+})
+
+async function addStableRepo() {
+  const tmpRepoName = `tmp-repo-${Math.random().toFixed(10).slice(2)}`
+  const repoAddCmd = await runHelm([
+    "repo",
+    "add",
+    tmpRepoName,
+    "https://charts.helm.sh/stable",
+  ])
+
+  assertEquals(repoAddCmd.status.success, true)
+  return {
+    name: tmpRepoName,
+    async cleanup() {
+      const repoAddCmd = await runHelm(["repo", "remove", tmpRepoName])
+
+      if (!repoAddCmd.status.success) {
+        throw new Error(`Could not remove repo ${tmpRepoName}`)
+      }
+    },
+  }
+}
+
+Deno.test({
+  name:
+    "should successfuly run `helm deno template` with remote chart (with helm repo add)",
+  ignore: !runAllTests,
+  async fn() {
+    const tmpRepo = await addStableRepo()
+
+    try {
+      const templateCmd = await runHelmDeno([
+        "template",
+        "ingress",
+        `${tmpRepo.name}/nginx-ingress`,
+        "--version",
+        "1.41.3",
+      ])
+
+      assertEquals(templateCmd.status.success, true)
+    } finally {
+      await tmpRepo.cleanup()
+    }
+  },
+})

src/helm/fetch.ts

@@ -4,24 +4,26 @@ import { parseHelmFetchArgs } from "../args/parse-helm-fetch-args.ts"
 import { withErrorMsg } from "../std/mod.ts"
 
 export async function fetchChart(
+  chartBlob: string,
+  tmpDirectory: string,
   chartPath: string,
-  destination: string,
   args: readonly string[]
 ): Promise<void> {
-  const destinationExists = await fs.exists(destination)
+  const destinationExists = await fs.exists(tmpDirectory)
   if (!destinationExists) {
-    return Promise.reject(`Could not find ${destination}`)
+    return Promise.reject(`Could not find ${tmpDirectory}`)
   }
+  const fetchDestination = path.join(tmpDirectory, "fetch-destination")
 
   const helm = Deno.env.get("HELM_BIN") as string
   const cmd = Deno.run({
     cmd: [
       helm,
       "fetch",
-      chartPath,
+      chartBlob,
       "--untar",
       "--untardir",
-      destination,
+      fetchDestination,
       ...parseHelmFetchArgs(args),
     ],
     stdout: "piped",
@@ -40,10 +42,21 @@ export async function fetchChart(
     return Promise.reject(new TextDecoder().decode(error))
   }
 
+  const directories = []
+  for await (const file of fs.expandGlob("*/", {
+    root: fetchDestination,
+  })) {
+    if (file.isDirectory && !file.path.endsWith(".tgz")) {
+      directories.push(file.path)
+    }
+  }
+
+  if (directories.length !== 1) {
+    throw new Error("Found more then one directory")
+  }
+
   await withErrorMsg(
-    fs.copy(path.join(destination, chartPath), destination, {
-      overwrite: true,
-    }),
-    `Could not fetch chart ${chartPath}`
+    fs.copy(directories[0], chartPath),
+    `Could not fetch chart ${chartBlob}`
   )
 }

src/helm/get-chart-context.ts

@@ -34,28 +34,32 @@ function normalizeRelease(r: HelmRelease): Release {
 
 export async function getChartContext(
   release: string,
-  chartPath: string,
+  tmpDir: string,
   args: readonly string[]
 ): Promise<ChartContext> {
-  const chartContextTemplatePath = path.join(
-    chartPath,
-    "templates/values-and-release.yaml"
-  )
+  const getValuesChartDir = path.join(tmpDir, "get-values-chart")
   try {
-    await fs.ensureDir(path.join(chartPath, "templates"))
+    await fs.ensureDir(path.join(getValuesChartDir, "templates"))
 
     await Deno.writeFile(
-      chartContextTemplatePath,
+      path.join(getValuesChartDir, "templates/values-and-release.yaml"),
       new TextEncoder().encode(valuesAndReleaseData)
     )
 
+    await Deno.writeFile(
+      path.join(getValuesChartDir, "Chart.yaml"),
+      new TextEncoder().encode(
+        "apiVersion: v2\nname: get-values\nversion: 1.0.0"
+      )
+    )
+
     const helm = Deno.env.get("HELM_BIN") as string
     const cmd = Deno.run({
       cmd: [
         helm,
         "template",
         release,
-        chartPath,
+        getValuesChartDir,
         ...parseHelmTemplateArgs(args),
       ],
       stdout: "piped",
@@ -86,6 +90,8 @@ export async function getChartContext(
       values: yaml.parse(x.values),
     }
   } finally {
-    await ignoreNotFoundError(Deno.remove(chartContextTemplatePath))
+    await ignoreNotFoundError(
+      Deno.remove(getValuesChartDir, { recursive: true })
+    )
   }
 }

src/index.ts

@@ -109,36 +109,38 @@ async function main() {
     return
   }
 
-  const workdir = await withErrorMsg(
+  const tmpDir = await withErrorMsg(
     Deno.makeTempDir({ prefix: "chart-" }),
     "Could not create temp directory"
   )
 
-  debug(`Temporary directory ${workdir} has been created`)
+  const tmpChartPath = path.join(tmpDir, "chart")
+
+  debug(`Temporary directory ${tmpDir} has been created`)
   const isLocalChart = await isChartExist(chartLocation)
 
   try {
     // Fetch chart into temporaty directory
     if (isLocalChart) {
       debug(`Copying chart ${chartLocation} to temporary directory`)
-      await copyChart(chartLocation, workdir)
+      await copyChart(chartLocation, tmpChartPath)
       debug(`Successfuly copied chart ${chartLocation} to temporary directory`)
     } else {
       debug(`Fetching chart ${chartLocation} to temporary directory`)
-      await fetchChart(chartLocation, workdir, args)
+      await fetchChart(chartLocation, tmpDir, tmpChartPath, args)
       debug(`Successfuly fetched chart ${chartLocation} to temporary directory`)
     }
 
-    const chartContext = await getChartContext(releaseName, workdir, args)
+    const chartContext = await getChartContext(releaseName, tmpDir, args)
     debug(`Chart context:\n${JSON.stringify(chartContext, null, 2)}`)
 
-    await renderDenoChart(chartContext, workdir, options)
+    await renderDenoChart(chartContext, tmpChartPath, options)
     debug("Deno templates were successfuly rendered")
 
     const helmExecuteArgs = [
       ...command,
       ...[releaseName].filter(Boolean),
-      workdir,
+      tmpChartPath,
       ...helmRestArgs,
     ]
     debug(`Executing: ${helmExecuteArgs.join(" ")}`)
@@ -148,8 +150,8 @@ async function main() {
   } catch (err) {
     const replaceChartPath = (str: string) => {
       return isLocalChart
-        ? str.replaceAll(workdir, chartLocation)
-        : str.replaceAll(`file://${workdir}`, "<chart-root>")
+        ? str.replaceAll(tmpChartPath, chartLocation)
+        : str.replaceAll(`file://${tmpChartPath}`, "<chart-root>")
     }
 
     // Replace paths in error or error stacktrace with readable value
@@ -165,7 +167,7 @@ async function main() {
   } finally {
     if (!options.keepTmpChart) {
       // Remove temporary directory
-      await ignoreNotFoundError(Deno.remove(workdir, { recursive: true }))
+      await ignoreNotFoundError(Deno.remove(tmpDir, { recursive: true }))
     }
   }
 }