test: introduce dgoss tests & github actions (#3)

* test: introduce dgoss tests & github actions

* ci: merge publish workflows & introduce prepare action

* fix: workflow file errors

* ci: fix action path

* ci: add image names

* ci: setup buildx before building

* ci: export image to docker for dgoss

* ci: checkout before running prepare

* ci: disable multi arch and version tests for now

* ci: testing publish action

* ci: some debug outputs

* ci: fix typo

* ci: fix tag-as-latest options

* ci: trying to get it working...

* ci: simplify github action

* ci: force build temporarily

* ci: re-enable previous steps & deps

* ci: introduce codecov-action

* ci: speed up pipeline by skipping unrelated platforms

Author: hertzg

.github/actions/publish/dockerTagger/action.yml

@@ -0,0 +1,19 @@
+name: Docker image tagger
+description: Action that generates docker tags based on github events
+
+inputs:
+  git-ref:
+    required: true
+    description: 'GitHub ref to base tags off of. (default: $github.ref)'
+    default: ${{ github.ref }}
+  image-names:
+    required: true
+    description: 'New line delimited list of repositories'
+
+outputs:
+  image-tags:
+    description: 'New line separated list of tags... can be directly used as "tags" for docker/build-push-action@v2'
+
+runs:
+  using: node12
+  main: index.js

.github/actions/publish/dockerTagger/git-ref.js

@@ -0,0 +1,18 @@
+const parseRef = ref => {
+  const [, type, ...rest] = ref.split('/');
+  return [type, rest.join('/')];
+};
+
+const isRefType = (parsedRef, type) => parsedRef[0] === type;
+const isHead = parsedRef => isRefType(parsedRef, 'heads');
+const isBranch = (parsedRef, branch) =>
+  isHead(parsedRef) && parsedRef[1] === branch;
+const isTag = parsedRef => isRefType(parsedRef, 'tags');
+
+module.exports = {
+  parseRef,
+  isRefType,
+  isHead,
+  isBranch,
+  isTag,
+};

.github/actions/publish/dockerTagger/helpers.js

@@ -0,0 +1,30 @@
+const { isBranch, isTag, isHead } = require('./git-ref');
+
+const isMaster = parsedRef => isBranch(parsedRef, 'master');
+const isVersionTag = parsedRef => isTag(parsedRef) && parsedRef[1].startsWith('v');
+
+const REF_TYPE = {
+  VERSION_TAG: 'version-tag',
+  MASTER_BRANCH: 'master-branch',
+  NON_MASTER_BRANCH: 'non-master-branch',
+};
+
+const getRefType = parsedRef => {
+  switch (true) {
+    case isVersionTag(parsedRef):
+      return REF_TYPE.VERSION_TAG;
+    case isMaster(parsedRef):
+      return REF_TYPE.MASTER_BRANCH;
+    case isHead(parsedRef):
+      return REF_TYPE.NON_MASTER_BRANCH;
+    default:
+      return;
+  }
+};
+
+module.exports = {
+  REF_TYPE,
+  isMaster,
+  isVersionTag,
+  getRefType,
+};

.github/actions/publish/dockerTagger/index.js

@@ -0,0 +1,16 @@
+const { getTagMatrix } = require('./tags');
+const { getConfig, setOutput, writeInfo, fail } = require('./io');
+
+const { gitRef, imageNames } = getConfig();
+
+const tags = getTagMatrix(gitRef, imageNames, 'git-');
+if (!tags.length) {
+  fail(
+    `Strategy (${JSON.stringify(
+      tags,
+    )}) produced no tags for git-ref "${gitRef}"`,
+  );
+}
+
+writeInfo(JSON.stringify({ outputs: { 'image-tags': tags } }, null, 2));
+setOutput('image-tags', tags.join('\n'));

.github/actions/publish/dockerTagger/io/index.js

@@ -0,0 +1,26 @@
+const { getInput, getInputLines } = require('./input');
+const {
+  writeDebug,
+  writeInfo,
+  writeWarning,
+  writeError,
+  setOutput,
+  fail,
+} = require('./output');
+
+const getConfig = () => ({
+  gitRef: getInput('git-ref'),
+  imageNames: getInputLines('image-names'),
+});
+
+module.exports = {
+  getInput,
+  getInputLines,
+  getConfig,
+  writeDebug,
+  writeInfo,
+  writeWarning,
+  writeError,
+  setOutput,
+  fail,
+};

.github/actions/publish/dockerTagger/io/input.js

@@ -0,0 +1,25 @@
+const { fail } = require('./output');
+
+const getRawInput = name =>
+  process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`];
+
+const getInput = (name, defaultValue = '') => getRawInput(name) || defaultValue;
+
+const getInputLines = (name, separator = '\n') => {
+  const input = getInput(name).trim();
+  return input ? input.split(separator).map(line => line.trim()) : [];
+};
+
+const validateEnum = (name, value, options = []) =>
+  options.includes(value)
+    ? value
+    : fail(`${name} can't be ${value}. Only ${options.join(', ')} allowed`);
+
+const getInputEnum = (name, options = [], defaultValue = '\n') =>
+  validateEnum(name, getInput(name, defaultValue), options);
+
+module.exports = {
+  getInput,
+  getInputEnum,
+  getInputLines,
+};

.github/actions/publish/dockerTagger/io/output.js

@@ -0,0 +1,64 @@
+const { EOL } = require('os');
+
+const sanitize = input => {
+  if (input === null || input === undefined) {
+    return '';
+  } else if (typeof input === 'string' || input instanceof String) {
+    return input;
+  }
+  return JSON.stringify(input);
+};
+
+const escapeData = s =>
+  sanitize(s)
+    .replace(/%/g, '%25')
+    .replace(/\r/g, '%0D')
+    .replace(/\n/g, '%0A');
+
+const escapeProperty = s =>
+  sanitize(s)
+    .replace(/%/g, '%25')
+    .replace(/\r/g, '%0D')
+    .replace(/\n/g, '%0A')
+    .replace(/:/g, '%3A')
+    .replace(/,/g, '%2C');
+
+const formatCommand = (name, value, props = {}) =>
+  `::${name} ${formatProperties(props)}::${escapeData(value)}`;
+
+const formatProperties = props =>
+  Object.entries(props)
+    .map(([key, prop]) => `${key}=${escapeProperty(prop)}`)
+    .join(',');
+
+const writeLine = line => process.stdout.write(`${line}${EOL}`);
+
+const setOutput = (name, data) =>
+  writeLine(formatCommand('set-output', data, { name }));
+
+const writeDebug = message => writeLine(formatCommand('debug', message));
+
+const writeInfo = message => writeLine(message);
+
+const ensureString = reason =>
+  reason instanceof Error ? reason.toString() : reason;
+
+const writeWarning = message =>
+  writeLine(formatCommand('warning', ensureString(message)));
+
+const writeError = message =>
+  writeLine(formatCommand('error', ensureString(message)));
+
+const fail = reason => {
+  writeError(reason);
+  process.exit(1);
+};
+
+module.exports = {
+  setOutput,
+  writeDebug,
+  writeInfo,
+  writeWarning,
+  writeError,
+  fail,
+};

.github/actions/publish/dockerTagger/tags.js

@@ -0,0 +1,38 @@
+const { parseRef } = require('./git-ref');
+const { REF_TYPE, getRefType } = require('./helpers');
+
+const refTypeTag = (refType, parsedRef, branchPrefix) => {
+  switch (refType) {
+    case REF_TYPE.VERSION_TAG:
+      return [parsedRef[1]];
+    case REF_TYPE.MASTER_BRANCH:
+      return ['master'];
+    case REF_TYPE.NON_MASTER_BRANCH:
+      return [`${branchPrefix}${parsedRef[1]}`];
+  }
+};
+
+const latestTag = refType =>
+  refType === REF_TYPE.VERSION_TAG ? ['latest'] : [];
+
+const getTags = (parsedRef, branchPrefix) => {
+  const refType = getRefType(parsedRef);
+  return [
+    ...refTypeTag(refType, parsedRef, branchPrefix),
+    ...latestTag(refType),
+  ];
+};
+
+const combine = (imageNames, tags) =>
+  tags
+    .flatMap(tag => imageNames.map(image => [image, tag]))
+    .map(([image, tag]) => `${image}:${tag}`);
+
+const getTagMatrix = (ref, imageNames, branchPrefix) => {
+  const parsedRef = parseRef(ref);
+  return combine(imageNames, getTags(parsedRef, branchPrefix));
+};
+
+module.exports = {
+  getTagMatrix,
+};

.github/workflows/cicd.yml

@@ -0,0 +1,96 @@
+name: CICD
+on:
+  push:
+    branches: '*'
+    tags: 'v*'
+    paths:
+      - '.github/workflows/cicd.yml'
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        node: ['14.x', '12.x', '10.x']
+        os: [ubuntu-latest]
+    steps:
+      - run: git config --global core.autocrlf false
+      - uses: actions/checkout@v2
+      - name: Use Node v${{ matrix.node }}
+        uses: actions/setup-node@v2
+        with:
+          check-latest: true
+          node-version: ${{ matrix.node }}
+      - uses: bahmutov/npm-install@v1
+      - run: yarn lint
+      - run: yarn test --ci --coverage --maxWorkers=2
+      - run: yarn build
+      - uses: codecov/codecov-action@v1
+        if: ${{ success() }}
+        continue-on-error: true
+
+  test-dgoss:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: docker/setup-buildx-action@v1
+      - name: Cache Docker layers
+        uses: actions/cache@v2
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-
+      - uses: actions/checkout@v2
+      - uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./Dockerfile
+          push: false
+          load: true
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache
+          tags: tesseract-server:goss
+      - uses: e1himself/goss-installation-action@v1.0.3
+      - run: dgoss run tesseract-server:goss
+
+  publish:
+    if: ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/master' }}
+    needs: [test, test-dgoss]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - id: dockerTagger
+        uses: ./.github/actions/publish/dockerTagger
+        with:
+          image-names: |
+            ghcr.io/hertzg/tesseract-server
+            hertzg/tesseract-server
+
+      - uses: docker/setup-qemu-action@v1
+      - uses: docker/setup-buildx-action@v1
+      - uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GHCR_PAT }}
+      - name: Cache Docker layers
+        uses: actions/cache@v2
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-
+      - name: Build & Push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64/v8
+          push: false
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache
+          tags: ${{ steps.dockerTagger.outputs.image-tags }}