Merge pull request #476 from crazy-max/undock-run

undock: run and extract

__tests__/undock/undock.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Copyright 2024 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import {describe, expect, it, jest, test} from '@jest/globals';
+import * as semver from 'semver';
+
+import {Exec} from '../../src/exec';
+import {Undock} from '../../src/undock/undock';
+
+const tmpDir = fs.mkdtempSync(path.join(process.env.TEMP || os.tmpdir(), 'undock-undock-'));
+
+describe('run', () => {
+  it('extracts moby/moby-bin:26.1.5', async () => {
+    const undock = new Undock();
+    await expect(
+      (async () => {
+        // prettier-ignore
+        await undock.run({
+          source: 'moby/moby-bin:26.1.5',
+          dist: tmpDir,
+          all: true
+        });
+      })()
+    ).resolves.not.toThrow();
+  }, 100000);
+});
+
+describe('isAvailable', () => {
+  it('checks undock is available', async () => {
+    const execSpy = jest.spyOn(Exec, 'getExecOutput');
+    const undock = new Undock();
+    await undock.isAvailable();
+    // eslint-disable-next-line jest/no-standalone-expect
+    expect(execSpy).toHaveBeenCalledWith(`undock`, [], {
+      silent: true,
+      ignoreReturnCode: true
+    });
+  });
+});
+
+describe('printVersion', () => {
+  it('prints undock version', async () => {
+    const execSpy = jest.spyOn(Exec, 'exec');
+    const undock = new Undock();
+    await undock.printVersion();
+    expect(execSpy).toHaveBeenCalledWith(`undock`, ['--version'], {
+      failOnStdErr: false
+    });
+  });
+});
+
+describe('version', () => {
+  it('valid', async () => {
+    const undock = new Undock();
+    expect(semver.valid(await undock.version())).not.toBeUndefined();
+  });
+});
+
+describe('versionSatisfies', () => {
+  test.each([
+    ['v0.4.1', '>=0.3.2', true],
+    ['v0.8.0', '>0.6.0', true],
+    ['v0.8.0', '<0.3.0', false]
+  ])('given %p', async (version, range, expected) => {
+    const undock = new Undock();
+    expect(await undock.versionSatisfies(range, version)).toBe(expected);
+  });
+});

dev.Dockerfile

@@ -17,6 +17,7 @@
 ARG NODE_VERSION=20
 ARG DOCKER_VERSION=27.2.1
 ARG BUILDX_VERSION=0.17.1
+ARG UNDOCK_VERSION=0.8.0
 
 FROM node:${NODE_VERSION}-alpine AS base
 RUN apk add --no-cache cpio findutils git
@@ -75,6 +76,7 @@ RUN --mount=type=bind,target=.,rw \
 
 FROM docker:${DOCKER_VERSION} as docker
 FROM docker/buildx-bin:${BUILDX_VERSION} as buildx
+FROM crazymax/undock:${UNDOCK_VERSION} as undock
 
 FROM deps AS test
 RUN --mount=type=bind,target=.,rw \
@@ -83,6 +85,7 @@ RUN --mount=type=bind,target=.,rw \
     --mount=type=bind,from=docker,source=/usr/local/bin/docker,target=/usr/bin/docker \
     --mount=type=bind,from=buildx,source=/buildx,target=/usr/libexec/docker/cli-plugins/docker-buildx \
     --mount=type=bind,from=buildx,source=/buildx,target=/usr/bin/buildx \
+    --mount=type=bind,from=undock,source=/usr/local/bin/undock,target=/usr/bin/undock \
     --mount=type=secret,id=GITHUB_TOKEN \
   GITHUB_TOKEN=$(cat /run/secrets/GITHUB_TOKEN) yarn run test:coverage --coverageDirectory=/tmp/coverage
 

src/toolkit.ts

@@ -20,6 +20,7 @@ import {Bake as BuildxBake} from './buildx/bake';
 import {Install as BuildxInstall} from './buildx/install';
 import {Builder} from './buildx/builder';
 import {BuildKit} from './buildkit/buildkit';
+import {Undock} from './undock/undock';
 import {GitHub} from './github';
 
 export interface ToolkitOpts {
@@ -38,6 +39,7 @@ export class Toolkit {
   public buildxInstall: BuildxInstall;
   public builder: Builder;
   public buildkit: BuildKit;
+  public undock: Undock;
 
   constructor(opts: ToolkitOpts = {}) {
     this.github = new GitHub({token: opts.githubToken});
@@ -47,5 +49,6 @@ export class Toolkit {
     this.buildxInstall = new BuildxInstall();
     this.builder = new Builder({buildx: this.buildx});
     this.buildkit = new BuildKit({buildx: this.buildx});
+    this.undock = new Undock();
   }
 }

src/undock/undock.ts

@@ -0,0 +1,148 @@
+/**
+ * Copyright 2024 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as core from '@actions/core';
+import * as semver from 'semver';
+
+import {Exec} from '../exec';
+
+export interface UndockOpts {
+  binPath?: string;
+}
+
+export interface UndockRunOpts {
+  source: string;
+  dist: string;
+  logLevel?: string;
+  logCaller?: boolean;
+  cacheDir?: string;
+  platform?: string;
+  all?: boolean;
+  include?: Array<string>;
+  insecure?: boolean;
+  rmDist?: boolean;
+  wrap?: boolean;
+}
+
+export class Undock {
+  private readonly binPath: string;
+  private _version: string;
+  private _versionOnce: boolean;
+
+  constructor(opts?: UndockOpts) {
+    this.binPath = opts?.binPath || 'undock';
+    this._version = '';
+    this._versionOnce = false;
+  }
+
+  public async run(opts: UndockRunOpts): Promise<void> {
+    if (!opts.source) {
+      throw new Error('source is required');
+    }
+    if (!opts.dist) {
+      throw new Error('dist is required');
+    }
+    const args: Array<string> = [];
+    if (opts.logLevel) {
+      args.push(`--log-level=${opts.logLevel}`);
+    }
+    if (opts.logCaller) {
+      args.push('--log-caller');
+    }
+    if (opts.cacheDir) {
+      args.push(`--cachedir=${opts.cacheDir}`);
+    }
+    if (opts.platform) {
+      args.push(`--platform=${opts.platform}`);
+    }
+    if (opts.all) {
+      args.push('--all');
+    }
+    if (opts.include) {
+      opts.include.forEach(i => {
+        args.push(`--include=${i}`);
+      });
+    }
+    if (opts.insecure) {
+      args.push('--insecure');
+    }
+    if (opts.rmDist) {
+      args.push('--rm-dist');
+    }
+    if (opts.wrap) {
+      args.push('--wrap');
+    }
+    args.push(opts.source, opts.dist);
+    await Exec.exec(this.binPath, args, {
+      failOnStdErr: false
+    });
+  }
+
+  public async isAvailable(): Promise<boolean> {
+    const ok: boolean = await Exec.getExecOutput(this.binPath, [], {
+      ignoreReturnCode: true,
+      silent: true
+    })
+      .then(res => {
+        if (res.stderr.length > 0 && res.exitCode != 0) {
+          core.debug(`Undock.isAvailable cmd err: ${res.stderr.trim()}`);
+          return false;
+        }
+        return res.exitCode == 0;
+      })
+      .catch(error => {
+        core.debug(`Undock.isAvailable error: ${error}`);
+        return false;
+      });
+
+    core.debug(`Undock.isAvailable: ${ok}`);
+    return ok;
+  }
+
+  public async version(): Promise<string> {
+    if (this._versionOnce) {
+      return this._version;
+    }
+    this._versionOnce = true;
+    this._version = await Exec.getExecOutput(this.binPath, ['--version'], {
+      ignoreReturnCode: true,
+      silent: true
+    }).then(res => {
+      if (res.stderr.length > 0 && res.exitCode != 0) {
+        throw new Error(res.stderr.trim());
+      }
+      return res.stdout.trim();
+    });
+    return this._version;
+  }
+
+  public async printVersion() {
+    await Exec.exec(this.binPath, ['--version'], {
+      failOnStdErr: false
+    });
+  }
+
+  public async versionSatisfies(range: string, version?: string): Promise<boolean> {
+    const ver = version ?? (await this.version());
+    if (!ver) {
+      core.debug(`Undock.versionSatisfies false: undefined version`);
+      return false;
+    }
+    const res = semver.satisfies(ver, range) || /^[0-9a-f]{7}$/.exec(ver) !== null;
+    core.debug(`Undock.versionSatisfies ${ver} statisfies ${range}: ${res}`);
+    return res;
+  }
+}