release nightly

Reviewed-on: https://gitea.com/gitea/act_runner/pulls/27

.editorconfig

@@ -1,21 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-charset = utf-8
-insert_final_newline = true
-trim_trailing_whitespace = true
-indent_style = tab
-indent_size = 4
-
-[{*.md,*_test.go}]
-indent_style = unset
-indent_size = unset
-
-[**/Dockerfile]
-indent_style = space
-indent_size = 2
-
-[*.{yml,yaml,js,json,sh,nuspec}]
-indent_style = space
-indent_size = 2

.gitea/workflows/release-nightly.yml

@@ -0,0 +1,22 @@
+name: goreleaser
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: https://github.com/goreleaser/goreleaser-action@v4
+        with:
+            distribution: goreleaser-pro
+            version: latest
+            args: release --nightly --clean
+        env:
+          GORELEASER_KEY: ${{ secrets.GORELEASER_KEY }}
+          S3_BUCKET: ${{ secrets.S3_BUCKET }}
+          S3_REGION: ${{ secrets.AWS_REGION }}
+          AWS_KEY_ID: ${{ secrets.AWS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

.gitea/workflows/test.yml

@@ -1,21 +1,23 @@
 name: checks
-on:
+on: 
   - push
   - pull_request
 
+env:
+  GOPROXY: https://goproxy.io,direct
+
 jobs:
   lint:
     name: check and test
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
+      - uses: actions/setup-go@v3
         with:
-          go-version-file: 'go.mod'
+          go-version: 1.20
+      - uses: actions/checkout@v3
       - name: vet checks
-        run: go vet -v ./...
+        run: make vet
       - name: build
-        run: go build -v ./...
+        run: make build
       - name: test
-        run: | # Test only the new packages in this fork. Add more packages as needed. 
-          go test -v ./pkg/jobparser
+        run: make test

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: cplee

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,88 +0,0 @@
-name: Bug report
-description: Use this template for reporting bugs/issues.
-labels:
-  - 'kind/bug'
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this bug report!
-  - type: textarea
-    id: act-debug
-    attributes:
-      label: Bug report info
-      render: plain text
-      description: |
-        Output of `act --bug-report`
-      placeholder: |
-        act --bug-report
-    validations:
-      required: true
-  - type: textarea
-    id: act-command
-    attributes:
-      label: Command used with act
-      description: |
-        Please paste your whole command
-      placeholder: |
-        act -P ubuntu-latest=node:12 -v -d ...
-      render: sh
-    validations:
-      required: true
-  - type: textarea
-    id: what-happened
-    attributes:
-      label: Describe issue
-      description: |
-        Also tell us what did you expect to happen?
-      placeholder: |
-        Describe issue
-    validations:
-      required: true
-  - type: input
-    id: repo
-    attributes:
-      label: Link to GitHub repository
-      description: |
-        Provide link to GitHub repository, you can skip it if the repository is private or you don't have it on GitHub, otherwise please provide it as it might help us troubleshoot problem
-      placeholder: |
-        https://github.com/nektos/act
-    validations:
-      required: false
-  - type: textarea
-    id: workflow
-    attributes:
-      label: Workflow content
-      description: |
-        Please paste your **whole** workflow here
-      placeholder: |
-        name: My workflow
-        on: ['push', 'schedule']
-        jobs:
-          test:
-            runs-on: ubuntu-latest
-          env:
-            KEY: VAL
-        [...]
-      render: yml
-    validations:
-      required: true
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant log output
-      description: |
-        Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks. Please verify that the log output doesn't contain any sensitive data.
-      render: sh
-      placeholder: |
-        Use `act -v` for verbose output
-    validations:
-      required: true
-  - type: textarea
-    id: additional-info
-    attributes:
-      label: Additional information
-      placeholder: |
-        Additional information that doesn't fit elsewhere
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -1,14 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Start a discussion
-    url: https://github.com/nektos/act/discussions/new
-    about: You can ask for help here!
-  - name: Ask on Gitter
-    url: https://gitter.im/nektos/act
-    about: You can ask for help here!
-  - name: Ask on Gitter (via Matrix)
-    url: https://matrix.to/#/#nektos_act:gitter.im?via=gitter.im&via=matrix.org
-    about: If you prefer Matrix over Gitter
-  - name: Want to contribute to act?
-    url: https://github.com/nektos/act/blob/master/CONTRIBUTING.md
-    about: Be sure to read contributing guidelines!

.github/ISSUE_TEMPLATE/feature_template.yml

@@ -1,28 +0,0 @@
-name: Feature request
-description: Use this template for requesting a feature/enhancement.
-labels:
-  - 'kind/feature-request'
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Please note that incompatibility with GitHub Actions should be opened as a bug report, not a new feature.
-  - type: input
-    id: act-version
-    attributes:
-      label: Act version
-      description: |
-        What version of `act` are you using? Version can be obtained via `act --version`
-        If you've built it from source, please provide commit hash
-      placeholder: |
-        act --version
-    validations:
-      required: true
-  - type: textarea
-    id: feature
-    attributes:
-      label: Feature description
-      description: Describe feature that you would like to see
-      placeholder: ...
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/wiki_issue.yml

@@ -1,18 +0,0 @@
-name: Wiki issue
-description: Report issue/improvement ragarding documentation (wiki)
-labels:
-  - 'kind/discussion'
-  - 'area/docs'
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this issue!
-  - type: textarea
-    id: details
-    attributes:
-      label: Details
-      description: |
-        Describe issue
-    validations:
-      required: true

.github/actions/choco/Dockerfile

@@ -1,20 +0,0 @@
-FROM alpine:3.17
-
-ARG CHOCOVERSION=1.1.0
-
-RUN apk add --no-cache bash ca-certificates git \
-  && apk --no-cache --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing add mono mono-dev \
-  && cert-sync /etc/ssl/certs/ca-certificates.crt \
-  && wget "https://github.com/chocolatey/choco/archive/${CHOCOVERSION}.tar.gz" -O- | tar -xzf - \
-  && cd choco-"${CHOCOVERSION}" \
-  && chmod +x build.sh zip.sh \
-  && ./build.sh -v \
-  && mv ./code_drop/chocolatey/console /opt/chocolatey \
-  && mkdir -p /opt/chocolatey/lib \
-  && rm -rf /choco-"${CHOCOVERSION}" \
-  && apk del mono-dev \
-  && rm -rf /var/cache/apk/*
-
-ENV ChocolateyInstall=/opt/chocolatey
-COPY entrypoint.sh /entrypoint.sh
-ENTRYPOINT ["/entrypoint.sh"]

.github/actions/choco/action.yml

@@ -1,16 +0,0 @@
-name: 'Chocolatey Packager'
-description: 'Create the choco package and push it'
-inputs:
-  version:
-    description: 'Version of package'
-    required: false
-  apiKey:
-    description: 'API Key for chocolately'
-    required: false
-  push:
-    description: 'Option for if package is going to be pushed'
-    required: false
-    default: 'false'
-runs:
-  using: 'docker'
-  image: 'Dockerfile'

.github/actions/choco/entrypoint.sh

@@ -1,31 +0,0 @@
-#!/bin/bash
-
-set -e
-
-function choco {
-  mono /opt/chocolatey/choco.exe "$@" --allow-unofficial --nocolor
-}
-
-function get_version {
-  local version=${INPUT_VERSION:-$(git describe --tags)}
-  version=(${version//[!0-9.-]/})
-  local version_parts=(${version//-/ })
-  version=${version_parts[0]}
-  if [ ${#version_parts[@]} -gt 1 ]; then
-    version=${version_parts}.${version_parts[1]}
-  fi
-  echo "$version"
-}
-
-## Determine the version to pack
-VERSION=$(get_version)
-echo "Packing version ${VERSION} of act"
-rm -f act-cli.*.nupkg
-mkdir -p tools
-cp LICENSE tools/LICENSE.txt
-cp VERIFICATION tools/VERIFICATION.txt
-cp dist/act_windows_amd64_v1/act.exe tools/
-choco pack act-cli.nuspec --version ${VERSION}
-if [[ "$INPUT_PUSH" == "true" ]]; then
-  choco push act-cli.${VERSION}.nupkg --api-key ${INPUT_APIKEY} -s https://push.chocolatey.org/ --timeout 180
-fi

.github/actions/run-tests/action.yml

@@ -1,77 +0,0 @@
-name: 'run-tests'
-description: 'Runs go test and upload a step summary'
-inputs:
-  filter:
-    description: 'The go test pattern for the tests to run'
-    required: false
-    default: ''
-  upload-logs-name:
-    description: 'Choose the name of the log artifact'
-    required: false
-    default: logs-${{ github.job }}-${{ strategy.job-index }}
-  upload-logs:
-    description: 'If true uploads logs of each tests as an artifact'
-    required: false
-    default: 'true'
-runs:
-  using: composite
-  steps:
-    - uses: actions/github-script@v6
-      with:
-        github-token: none # No reason to grant access to the GITHUB_TOKEN
-        script: |
-          let myOutput = '';
-          var fs = require('fs');
-          var uploadLogs = process.env.UPLOAD_LOGS === 'true';
-          if(uploadLogs) {
-            await io.mkdirP('logs');
-          }
-          var filename = null;
-          const options = {};
-          options.ignoreReturnCode = true;
-          options.env = Object.assign({}, process.env);
-          delete options.env.ACTIONS_RUNTIME_URL;
-          delete options.env.ACTIONS_RUNTIME_TOKEN;
-          delete options.env.ACTIONS_CACHE_URL;
-          options.listeners = {
-            stdout: (data) => {
-              for(line of data.toString().split('\n')) {
-                if(/^\s*(===\s[^\s]+\s|---\s[^\s]+:\s)/.test(line)) {
-                  if(uploadLogs) {
-                    var runprefix = "=== RUN   ";
-                    if(line.startsWith(runprefix)) {
-                      filename = "logs/" + line.substring(runprefix.length).replace(/[^A-Za-z0-9]/g, '-') + ".txt";
-                      fs.writeFileSync(filename, line + "\n");
-                    } else if(filename) {
-                      fs.appendFileSync(filename, line + "\n");
-                      filename = null;
-                    }
-                  }
-                  myOutput += line + "\n";
-                } else if(filename) {
-                  fs.appendFileSync(filename, line + "\n");
-                }
-              }
-            }
-          };
-          var args = ['test', '-v', '-cover', '-coverprofile=coverage.txt', '-covermode=atomic', '-timeout', '20m'];
-          var filter = process.env.FILTER;
-          if(filter) {
-            args.push('-run');
-            args.push(filter);
-          }
-          args.push('./...');
-          var exitcode = await exec.exec('go', args, options);
-          if(process.env.GITHUB_STEP_SUMMARY) {
-            core.summary.addCodeBlock(myOutput);
-            await core.summary.write();
-          }
-          process.exit(exitcode);
-      env:
-        FILTER: ${{ inputs.filter }}
-        UPLOAD_LOGS: ${{ inputs.upload-logs }}
-    - uses: actions/upload-artifact@v3
-      if: always() && inputs.upload-logs == 'true' && !env.ACT
-      with:
-        name: ${{ inputs.upload-logs-name }}
-        path: logs

.github/dependabot.yml

@@ -1,15 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  - package-ecosystem: 'github-actions'
-    directory: '/'
-    schedule:
-      interval: 'weekly'
-  - package-ecosystem: 'gomod'
-    directory: '/'
-    schedule:
-      interval: 'weekly'

.github/workflows/.gitignore

@@ -1 +0,0 @@
-test-*.yml

.github/workflows/checks.yml

@@ -1,181 +0,0 @@
-name: checks
-on: [pull_request, workflow_dispatch]
-
-concurrency:
-  cancel-in-progress: true
-  group: ${{ github.workflow }}-${{ github.ref }}
-
-env:
-  ACT_OWNER: ${{ github.repository_owner }}
-  ACT_REPOSITORY: ${{ github.repository }}
-  CGO_ENABLED: 0
-
-jobs:
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          check-latest: true
-      - uses: golangci/[email protected]
-        with:
-          version: v1.53
-          only-new-issues: true
-      - uses: megalinter/megalinter/flavors/[email protected]
-        env:
-          DEFAULT_BRANCH: master
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          VALIDATE_ALL_CODEBASE: false
-          GITHUB_STATUS_REPORTER: ${{ !env.ACT }}
-          GITHUB_COMMENT_REPORTER: ${{ !env.ACT }}
-
-  test-linux:
-    name: test-linux
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          check-latest: true
-      - uses: actions/cache@v3
-        if: ${{ !env.ACT }}
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-      - name: Run Tests
-        uses: ./.github/actions/run-tests
-        with:
-          upload-logs-name: logs-linux
-      - name: Run act from cli
-        run: go run main.go -P ubuntu-latest=node:16-buster-slim -C ./pkg/runner/testdata/ -W ./basic/push.yml
-      - name: Upload Codecov report
-        uses: codecov/[email protected]
-        with:
-          files: coverage.txt
-          fail_ci_if_error: true # optional (default = false)
-
-  test-host:
-    strategy:
-      matrix:
-        os:
-          - windows-latest
-          - macos-latest
-    name: test-${{matrix.os}}
-    runs-on: ${{matrix.os}}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          check-latest: true
-      - name: Run Tests
-        uses: ./.github/actions/run-tests
-        with:
-          filter: '^TestRunEventHostEnvironment$'
-          upload-logs-name: logs-${{ matrix.os }}
-
-  snapshot:
-    name: snapshot
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          check-latest: true
-      - uses: actions/cache@v3
-        if: ${{ !env.ACT }}
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-      - name: GoReleaser
-        uses: goreleaser/goreleaser-action@v5
-        with:
-          version: latest
-          args: release --snapshot --clean
-      - name: Capture x86_64 (64-bit) Linux binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-linux-amd64
-          path: dist/act_linux_amd64_v1/act
-      - name: Capture i386 (32-bit) Linux binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-linux-i386
-          path: dist/act_linux_386/act
-      - name: Capture arm64 (64-bit) Linux binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-linux-arm64
-          path: dist/act_linux_arm64/act
-      - name: Capture armv6 (32-bit) Linux binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-linux-armv6
-          path: dist/act_linux_arm_6/act
-      - name: Capture armv7 (32-bit) Linux binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-linux-armv7
-          path: dist/act_linux_arm_7/act
-      - name: Capture x86_64 (64-bit) Windows binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-windows-amd64
-          path: dist/act_windows_amd64_v1/act.exe
-      - name: Capture i386 (32-bit) Windows binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-windows-i386
-          path: dist/act_windows_386/act.exe
-      - name: Capture arm64 (64-bit) Windows binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-windows-arm64
-          path: dist/act_windows_arm64/act.exe
-      - name: Capture armv7 (32-bit) Windows binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-windows-armv7
-          path: dist/act_windows_arm_7/act.exe
-      - name: Capture x86_64 (64-bit) MacOS binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-macos-amd64
-          path: dist/act_darwin_amd64_v1/act
-      - name: Capture arm64 (64-bit) MacOS binary
-        if: ${{ !env.ACT }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: act-macos-arm64
-          path: dist/act_darwin_arm64/act
-      - name: Chocolatey
-        uses: ./.github/actions/choco
-        with:
-          version: v0.0.0-pr

.github/workflows/promote.yml

@@ -1,29 +0,0 @@
-name: promote
-on:
-  schedule:
-    - cron: '0 2 1 * *'
-  workflow_dispatch: {}
-
-jobs:
-  release:
-    name: promote
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          ref: master
-          token: ${{ secrets.GORELEASER_GITHUB_TOKEN }}
-      - uses: fregante/setup-git-user@v2
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          check-latest: true
-      - uses: actions/cache@v3
-        if: ${{ !env.ACT }}
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-      - run: make promote

.github/workflows/release.yml

@@ -1,61 +0,0 @@
-name: release
-on:
-  push:
-    tags:
-      - v*
-
-jobs:
-  release:
-    name: release
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-          check-latest: true
-      - uses: actions/cache@v3
-        if: ${{ !env.ACT }}
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-      - name: GoReleaser
-        uses: goreleaser/goreleaser-action@v5
-        with:
-          version: latest
-          args: release --clean
-        env:
-          GITHUB_TOKEN: ${{ secrets.GORELEASER_GITHUB_TOKEN }}
-      - name: Winget
-        uses: vedantmgoyal2009/winget-releaser@v2
-        with:
-          identifier: nektos.act
-          installers-regex: '_Windows_\w+\.zip$'
-          token: ${{ secrets.WINGET_TOKEN }}
-      - name: Chocolatey
-        uses: ./.github/actions/choco
-        with:
-          version: ${{ github.ref }}
-          apiKey: ${{ secrets.CHOCO_APIKEY }}
-          push: true
-      - name: GitHub CLI extension
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GORELEASER_GITHUB_TOKEN }}
-          script: |
-            const mainRef = (await github.rest.git.getRef({
-              owner: 'nektos',
-              repo: 'gh-act',
-              ref: 'heads/main',
-            })).data;
-            console.log(mainRef);
-            github.rest.git.createRef({
-              owner: 'nektos',
-              repo: 'gh-act',
-              ref: context.ref,
-              sha: mainRef.object.sha,
-            });

.github/workflows/stale.yml

@@ -1,23 +0,0 @@
-name: 'Close stale issues'
-on:
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  stale:
-    name: Stale
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@v9
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-issue-message: 'Issue is stale and will be closed in 14 days unless there is new activity'
-          stale-pr-message: 'PR is stale and will be closed in 14 days unless there is new activity'
-          stale-issue-label: 'stale'
-          exempt-issue-labels: 'stale-exempt,kind/feature-request'
-          stale-pr-label: 'stale'
-          exempt-pr-labels: 'stale-exempt'
-          remove-stale-when-updated: 'True'
-          operations-per-run: 500
-          days-before-stale: 180
-          days-before-close: 14

.gitignore

@@ -1,34 +1,4 @@
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, build with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-/dist/
-.todo
-
-*.nupkg
-.vscode/
-.idea/
-
-# Path for actions cache created when running tests
-pkg/runner/act/
-
-# act binary
-dist/local/act
-
-coverage.txt
-
+act_runner
 .env
-.secrets
-
-# megalinter
-report/
-act
+.runner
+coverage.txt

.gitleaksignore

@@ -1 +0,0 @@
-b910a42edfab7a02b08a52ecef203fd419725642:pkg/container/testdata/docker-pull-options/config.json:generic-api-key:4

.golangci.yml

@@ -1,51 +1,172 @@
-# Minimum golangci-lint version required: v1.46.0
-run:
-  timeout: 3m
+linters:
+  enable:
+    - gosimple
+    - deadcode
+    - typecheck
+    - govet
+    - errcheck
+    - staticcheck
+    - unused
+    - structcheck
+    - varcheck
+    - dupl
+    #- gocyclo # The cyclomatic complexety of a lot of functions is too high, we should refactor those another time.
+    - gofmt
+    - misspell
+    - gocritic
+    - bidichk
+    - ineffassign
+    - revive
+    - gofumpt
+    - depguard
+    - nakedret
+    - unconvert
+    - wastedassign
+    - nolintlint
+    - stylecheck
+  enable-all: false
+  disable-all: true
+  fast: false
 
-skip-dirs:
-  - report # megalinter results+fixes
+run:
+  go: 1.18
+  timeout: 10m
+  skip-dirs:
+    - node_modules
+    - public
+    - web_src
 
 linters-settings:
-  gocyclo:
-    # minimal code complexity to report, 30 by default (but we recommend 10-20)
-    min-complexity: 15
+  stylecheck:
+    checks: ["all", "-ST1005", "-ST1003"]
+  nakedret:
+    max-func-lines: 0
   gocritic:
     disabled-checks:
       - ifElseChain
-  importas:
-    aliases:
-      - pkg: 'github.com/sirupsen/logrus'
-        alias: log
-      - pkg: 'github.com/stretchr/testify/assert'
-        alias: assert
-  depguard:
+      - singleCaseSwitch # Every time this occurred in the code, there  was no other way.
+  revive:
+    ignore-generated-header: false
+    severity: warning
+    confidence: 0.8
+    errorCode: 1
+    warningCode: 1
     rules:
-      main:
-        deny:
-          - pkg: github.com/pkg/errors
-            desc: Please use "errors" package from standard library
-          - pkg: gotest.tools/v3
-            desc: Please keep tests unified using only github.com/stretchr/testify
-          - pkg: log
-            desc: Please keep logging unified using only github.com/sirupsen/logrus
-linters:
-  enable:
-    - megacheck
-    - govet
-    - revive
-    - gocyclo
-    - gosec
-    - unconvert
-    - dupl
-    - nakedret
-    - prealloc
-    - exportloopref
-    - gocritic
-    - goimports
-    - whitespace
-    - misspell
-    - depguard
-    - importas
-    - contextcheck
-    - nolintlint
-    - revive
+      - name: blank-imports
+      - name: context-as-argument
+      - name: context-keys-type
+      - name: dot-imports
+      - name: error-return
+      - name: error-strings
+      - name: error-naming
+      - name: exported
+      - name: if-return
+      - name: increment-decrement
+      - name: var-naming
+      - name: var-declaration
+      - name: package-comments
+      - name: range
+      - name: receiver-naming
+      - name: time-naming
+      - name: unexported-return
+      - name: indent-error-flow
+      - name: errorf
+      - name: duplicated-imports
+      - name: modifies-value-receiver
+  gofumpt:
+    extra-rules: true
+    lang-version: "1.18"
+  depguard:
+    # TODO: use depguard to replace import checks in gitea-vet
+    list-type: denylist
+    # Check the list against standard lib.
+    include-go-root: true
+    packages-with-error-message:
+      - github.com/unknwon/com: "use gitea's util and replacements"
+
+issues:
+  exclude-rules:
+    # Exclude some linters from running on tests files.
+    - path: _test\.go
+      linters:
+        - gocyclo
+        - errcheck
+        - dupl
+        - gosec
+        - unparam
+        - staticcheck
+    - path: models/migrations/v
+      linters:
+        - gocyclo
+        - errcheck
+        - dupl
+        - gosec
+    - linters:
+        - dupl
+      text: "webhook"
+    - linters:
+        - gocritic
+      text: "`ID' should not be capitalized"
+    - path: modules/templates/helper.go
+      linters:
+        - gocritic
+    - linters:
+        - unused
+        - deadcode
+      text: "swagger"
+    - path: contrib/pr/checkout.go
+      linters:
+        - errcheck
+    - path: models/issue.go
+      linters:
+        - errcheck
+    - path: models/migrations/
+      linters:
+        - errcheck
+    - path: modules/log/
+      linters:
+        - errcheck
+    - path: routers/api/v1/repo/issue_subscription.go
+      linters:
+        - dupl
+    - path: routers/repo/view.go
+      linters:
+        - dupl
+    - path: models/migrations/
+      linters:
+        - unused
+    - linters:
+        - staticcheck
+      text: "argument x is overwritten before first use"
+    - path: modules/httplib/httplib.go
+      linters:
+        - staticcheck
+    # Enabling this would require refactoring the methods and how they are called.
+    - path: models/issue_comment_list.go
+      linters:
+        - dupl
+    - linters:
+        - misspell
+      text: '`Unknwon` is a misspelling of `Unknown`'
+    - path: models/update.go
+      linters:
+        - unused
+    - path: cmd/dump.go
+      linters:
+        - dupl
+    - path: services/webhook/webhook.go
+      linters:
+        - structcheck
+    - text: "commentFormatting: put a space between `//` and comment text"
+      linters:
+        - gocritic
+    - text: "exitAfterDefer:"
+      linters:
+        - gocritic
+    - path: modules/graceful/manager_windows.go
+      linters:
+        - staticcheck
+      text: "svc.IsAnInteractiveSession is deprecated: Use IsWindowsService instead."
+    - path: models/user/openid.go
+      linters:
+        - golint

.goreleaser.yaml

@@ -0,0 +1,92 @@
+before:
+  hooks:
+    - go mod tidy
+
+builds:
+- env:
+  - CGO_ENABLED=0
+  goos:
+  - darwin
+  - linux
+  - windows
+  - freebsd
+  goarch:
+  - amd64
+  - arm
+  - arm64
+  - s390x
+  - ppc64le
+  goarm:
+  - "5"
+  - "6"
+  - "7"
+  ignore:
+    - goos: darwin
+      goarch: arm
+    - goos: darwin
+      goarch: ppc64le
+    - goos: darwin
+      goarch: s390x
+    - goos: windows
+      goarch: ppc64le
+    - goos: windows
+      goarch: s390x
+    - goos: windows
+      goarch: arm
+      goarm: "5"
+    - goos: windows
+      goarch: arm
+      goarm: "6"
+    - goos: windows
+      goarch: arm
+      goarm: "7"
+    - goos: freebsd
+      goarch: ppc64le
+    - goos: freebsd
+      goarch: s390x
+    - goos: freebsd
+      goarch: arm
+      goarm: "5"
+    - goos: freebsd
+      goarch: arm
+      goarm: "6"
+    - goos: freebsd
+      goarch: arm
+      goarm: "7"
+  flags:
+  - -trimpath
+  ldflags:
+  - -s -w
+  binary: >-
+    {{ .ProjectName }}-
+    {{- if .IsSnapshot }}{{ .Branch }}-
+    {{- else }}{{- .Version }}-{{ end }}
+    {{- .Os }}-
+    {{- if eq .Arch "amd64" }}amd64
+    {{- else if eq .Arch "amd64_v1" }}amd64
+    {{- else if eq .Arch "386" }}386
+    {{- else }}{{ .Arch }}{{ end }}
+    {{- if .Arm }}-{{ .Arm }}{{ end }}
+  no_unique_dist_dir: true
+
+blobs:
+  -
+    provider: s3
+    bucket: "{{ .Env.S3_BUCKET }}"
+    region: "{{ .Env.S3_REGION }}"
+    folder: "act_runner/{{.Version}}"
+
+archives:
+  - format: binary
+    name_template: "{{ .Binary }}"
+    allow_different_binary_count: true
+
+checksum:
+  name_template: 'checksums.txt'
+
+snapshot:
+  name_template: "{{ incpatch .Version }}"
+
+nightly:
+  publish_release: false
+  name_template: "{{ .Branch }}"

.goreleaser.yml

@@ -1,50 +0,0 @@
-before:
-  hooks:
-    - go mod tidy
-builds:
-  - env:
-      - CGO_ENABLED=0
-    goos:
-      - darwin
-      - linux
-      - windows
-    goarch:
-      - amd64
-      - '386'
-      - arm64
-      - arm
-    goarm:
-      - '6'
-      - '7'
-    ignore:
-      - goos: windows
-        goarm: '6'
-checksum:
-  name_template: 'checksums.txt'
-archives:
-  - name_template: >-
-      {{ .ProjectName }}_
-      {{- title .Os }}_
-      {{- if eq .Arch "amd64" }}x86_64
-      {{- else if eq .Arch "386" }}i386
-      {{- else }}{{ .Arch }}{{ end }}
-      {{- if .Arm }}v{{ .Arm }}{{ end }}
-    format_overrides:
-      - goos: windows
-        format: zip
-changelog:
-  groups:
-    - title: 'New Features'
-      regexp: "^.*feat[(\\w)]*:+.*$"
-      order: 0
-    - title: 'Bug fixes'
-      regexp: "^.*fix[(\\w)]*:+.*$"
-      order: 1
-    - title: 'Documentation updates'
-      regexp: "^.*docs[(\\w)]*:+.*$"
-      order: 2
-    - title: 'Other'
-      order: 999
-release:
-  prerelease: auto
-  mode: append

.markdownlint.yml

@@ -1,12 +0,0 @@
-# Default state for all rules
-default: true
-
-# MD013/line-length - Line length
-MD013:
-  line_length: 1024
-
-# MD033/no-inline-html - Inline HTML
-MD033: false
-
-# MD041/first-line-heading/first-line-h1 - First line in a file should be a top-level heading
-MD041: false

.mega-linter.yml

@@ -1,20 +0,0 @@
----
-APPLY_FIXES: none
-DISABLE:
-  - ACTION
-  - BASH
-  - COPYPASTE
-  - DOCKERFILE
-  - GO
-  - JAVASCRIPT
-  - SPELL
-DISABLE_LINTERS:
-  - YAML_YAMLLINT
-  - MARKDOWN_MARKDOWN_TABLE_FORMATTER
-  - MARKDOWN_MARKDOWN_LINK_CHECK
-  - REPOSITORY_CHECKOV
-  - REPOSITORY_TRIVY
-FILTER_REGEX_EXCLUDE: (.*testdata/*|install.sh|pkg/container/docker_cli.go|pkg/container/DOCKER_LICENSE|VERSION)
-MARKDOWN_MARKDOWNLINT_CONFIG_FILE: .markdownlint.yml
-PARALLEL: false
-PRINT_ALPACA: false

.mergify.yml

@@ -1,97 +0,0 @@
-pull_request_rules:
-  - name: warn on conflicts
-    conditions:
-      - -draft
-      - -closed
-      - -merged
-      - conflict
-    actions:
-      comment:
-        message: '@{{author}} this pull request is now in conflict 😩'
-      label:
-        add:
-          - conflict
-  - name: remove conflict label if not needed
-    conditions:
-      - -conflict
-    actions:
-      label:
-        remove:
-          - conflict
-  - name: warn on needs-work
-    conditions:
-      - -draft
-      - -closed
-      - -merged
-      - or:
-          - check-failure=lint
-          - check-failure=test-linux
-          - check-failure=codecov/patch
-          - check-failure=codecov/project
-          - check-failure=snapshot
-    actions:
-      comment:
-        message: '@{{author}} this pull request has failed checks 🛠'
-      label:
-        add:
-          - needs-work
-  - name: remove needs-work label if not needed
-    conditions:
-      - check-success=lint
-      - check-success=test-linux
-      - check-success=codecov/patch
-      - check-success=codecov/project
-      - check-success=snapshot
-    actions:
-      label:
-        remove:
-          - needs-work
-  - name: Automatic maintainer assignment
-    conditions:
-      - '-approved-reviews-by=@nektos/act-maintainers'
-      - -draft
-      - -merged
-      - -closed
-      - -conflict
-      - check-success=lint
-      - check-success=test-linux
-      - check-success=codecov/patch
-      - check-success=codecov/project
-      - check-success=snapshot
-    actions:
-      request_reviews:
-        teams:
-          - '@nektos/act-maintainers'
-  - name: Automatic merge on approval
-    conditions:
-      - '#changes-requested-reviews-by=0'
-      - or:
-          - 'approved-reviews-by=@nektos/act-committers'
-          - 'author~=^dependabot(|-preview)\[bot\]$'
-          - and:
-              - 'approved-reviews-by=@nektos/act-maintainers'
-              - '#approved-reviews-by>=2'
-          - and:
-              - 'author=@nektos/act-maintainers'
-              - 'approved-reviews-by=@nektos/act-maintainers'
-              - '#approved-reviews-by>=1'
-      - -draft
-      - -merged
-      - -closed
-      - check-success=lint
-      - check-success=test-linux
-      - check-success=codecov/patch
-      - check-success=codecov/project
-      - check-success=snapshot
-    actions:
-      queue:
-        method: squash
-        name: default
-queue_rules:
-  - name: default
-    conditions:
-      - check-success=lint
-      - check-success=test-linux
-      - check-success=codecov/patch
-      - check-success=codecov/project
-      - check-success=snapshot

.prettierignore

@@ -1,2 +0,0 @@
-**/testdata
-pkg/runner/res

.prettierrc.yml

@@ -1,7 +0,0 @@
-overrides:
-  - files: '*.yml'
-    options:
-      singleQuote: true
-  - files: '*.json'
-    options:
-      singleQuote: false

.vscode/extensions.json

@@ -1,9 +0,0 @@
-{
-  "recommendations": [
-    "editorconfig.editorconfig",
-    "golang.go",
-    "davidanson.vscode-markdownlint",
-    "esbenp.prettier-vscode",
-    "redhat.vscode-yaml"
-  ]
-}

.vscode/settings.json

@@ -1,14 +0,0 @@
-{
-  "go.lintTool": "golangci-lint",
-  "go.lintFlags": ["--fix"],
-  "go.testTimeout": "300s",
-  "[json]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[markdown]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[yaml]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  }
-}

CODEOWNERS

@@ -1 +0,0 @@
-*       @nektos/act-maintainers

CONTRIBUTING.md

@@ -1,69 +0,0 @@
-# Contributing to Act
-
-Help wanted! We'd love your contributions to Act. Please review the following guidelines before contributing. Also, feel free to propose changes to these guidelines by updating this file and submitting a pull request.
-
-- [I have a question...](#questions)
-- [I found a bug...](#bugs)
-- [I have a feature request...](#features)
-- [I have a contribution to share...](#process)
-
-## <a id="questions"></a> Have a Question?
-
-Please don't open a GitHub issue for questions about how to use `act`, as the goal is to use issues for managing bugs and feature requests. Issues that are related to general support will be closed and redirected to our gitter room.
-
-For all support related questions, please ask the question in our gitter room: [nektos/act](https://gitter.im/nektos/act).
-
-## <a id="bugs"></a> Found a Bug?
-
-If you've identified a bug in `act`, please [submit an issue](#issue) to our GitHub repo: [nektos/act](https://github.com/nektos/act/issues/new). Please also feel free to submit a [Pull Request](#pr) with a fix for the bug!
-
-## <a id="features"></a> Have a Feature Request?
-
-All feature requests should start with [submitting an issue](#issue) documenting the user story and acceptance criteria. Again, feel free to submit a [Pull Request](#pr) with a proposed implementation of the feature.
-
-## <a id="process"></a> Ready to Contribute
-
-### <a id="issue"></a> Create an issue
-
-Before submitting a new issue, please search the issues to make sure there isn't a similar issue doesn't already exist.
-
-Assuming no existing issues exist, please ensure you include required information when submitting the issue to ensure we can quickly reproduce your issue.
-
-We may have additional questions and will communicate through the GitHub issue, so please respond back to our questions to help reproduce and resolve the issue as quickly as possible.
-
-New issues can be created with in our [GitHub repo](https://github.com/nektos/act/issues/new).
-
-### <a id="pr"></a>Pull Requests
-
-Pull requests should target the `master` branch. Please also reference the issue from the description of the pull request using [special keyword syntax](https://help.github.com/articles/closing-issues-via-commit-messages/) to auto close the issue when the PR is merged. For example, include the phrase `fixes #14` in the PR description to have issue #14 auto close. Please send documentation updates for the [act user guide](https://nektosact.com) to [nektos/act-docs](https://github.com/nektos/act-docs).
-
-### <a id="style"></a> Styleguide
-
-When submitting code, please make every effort to follow existing conventions and style in order to keep the code as readable as possible. Here are a few points to keep in mind:
-
-- Please run `go fmt ./...` before committing to ensure code aligns with go standards.
-- We use [`golangci-lint`](https://golangci-lint.run/) for linting Go code, run `golangci-lint run --fix` before submitting PR. Editors such as Visual Studio Code or JetBrains IntelliJ; with Go support plugin will offer `golangci-lint` automatically.
-- There are additional linters and formatters for files such as Markdown documents or YAML/JSON:
-  - Please refer to the [Makefile](Makefile) or [`lint` job in our workflow](.github/workflows/checks.yml) to see how to those linters/formatters work.
-  - You can lint codebase by running `go run main.go -j lint --env RUN_LOCAL=true` or `act -j lint --env RUN_LOCAL=true`
-  - In `Makefile`, there are tools that require `npx` which is shipped with `nodejs`.
-  - Our `Makefile` exports `GITHUB_TOKEN` from `~/.config/github/token`, you have been warned.
-  - You can run `make pr` to cleanup dependencies, format/lint code and run tests.
-- All dependencies must be defined in the `go.mod` file.
-  - Advanced IDEs and code editors (like VSCode) will take care of that, but to be sure, run `go mod tidy` to validate dependencies.
-- For details on the approved style, check out [Effective Go](https://golang.org/doc/effective_go.html).
-- Before running tests, please be aware that they are multi-architecture so for them to not fail, you need to run `docker run --privileged --rm tonistiigi/binfmt --install amd64,arm64` before ([more info available in #765](https://github.com/nektos/act/issues/765)).
-
-Also, consider the original design principles:
-
-- **Polyglot** - There will be no prescribed language or framework for developing the microservices. The only requirement will be that the service will be run inside a container and exposed via an HTTP endpoint.
-- **Cloud Provider** - At this point, the tool will assume AWS for the cloud provider and will not be written in a cloud agnostic manner. However, this does not preclude refactoring to add support for other providers at a later time.
-- **Declarative** - All resource administration will be handled in a declarative vs. imperative manner. A file will be used to declared the desired state of the resources and the tool will simply assert the actual state matches the desired state. The tool will accomplish this by generating CloudFormation templates.
-- **Stateless** - The tool will not maintain its own state. Rather, it will rely on the CloudFormation stacks to determine the state of the platform.
-- **Secure** - All security will be managed by AWS IAM credentials. No additional authentication or authorization mechanisms will be introduced.
-
-### License
-
-By contributing your code, you agree to license your contribution under the terms of the [MIT License](LICENSE).
-
-All files are released with the MIT license.

IMAGES.md

@@ -1,67 +0,0 @@
-# List of Docker images for `act`
-
-**Warning:** Below badges with size for each image are displaying size of **compressed image size in registry. After pulling the image, size can be drastically different due to Docker uncompressing the image layers.**
-
-## Images based on [`buildpack-deps`][hub/_/buildpack-deps]
-
-**Note 1: `node` images are based on Debian root filesystem, while it is extremely similar to Ubuntu, there might be some differences**
-
-**Note 2: `node` `-slim` images don't have `python` installed, if you want to use actions or software that is depending on `python`, you need to specify image manually**
-
-| Image                                 | Size                                                       |
-| ------------------------------------- | ---------------------------------------------------------- |
-| [`node:16-bullseye`][hub/_/node]      | ![`bullseye-size`][hub/_/node/16-bullseye/size]            |
-| [`node:16-bullseye-slim`][hub/_/node] | ![`micro-bullseye-size`][hub/_/node/16-bullseye-slim/size] |
-| [`node:16-buster`][hub/_/node]        | ![`buster-size`][hub/_/node/16-buster/size]                |
-| [`node:16-buster-slim`][hub/_/node]   | ![`micro-buster-size`][hub/_/node/16-buster-slim/size]     |
-
-**Note: `catthehacker/ubuntu` images are based on Ubuntu root filesystem**
-
-| Image                                                        | GitHub Repository                                             |
-| ------------------------------------------------------------ | ------------------------------------------------------------- |
-| [`catthehacker/ubuntu:act-latest`][ghcr/catthehacker/ubuntu] | [`catthehacker/docker-images`][gh/catthehacker/docker_images] |
-| [`catthehacker/ubuntu:act-22.04`][ghcr/catthehacker/ubuntu]  | [`catthehacker/docker-images`][gh/catthehacker/docker_images] |
-| [`catthehacker/ubuntu:act-20.04`][ghcr/catthehacker/ubuntu]  | [`catthehacker/docker-images`][gh/catthehacker/docker_images] |
-| [`catthehacker/ubuntu:act-18.04`][ghcr/catthehacker/ubuntu]  | [`catthehacker/docker-images`][gh/catthehacker/docker_images] |
-
-## Images based on [`actions/virtual-environments`][gh/actions/virtual-environments]
-
-**Note: `nektos/act-environments-ubuntu` have been last updated in February, 2020. It's recommended to update the image manually after `docker pull` if you decide to use it.**
-
-| Image                                                                             | Size                                                                       | GitHub Repository                                       |
-| --------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------- |
-| [`nektos/act-environments-ubuntu:18.04`][hub/nektos/act-environments-ubuntu]      | ![`nektos:18.04`][hub/nektos/act-environments-ubuntu/18.04/size]           | [`nektos/act-environments`][gh/nektos/act-environments] |
-| [`nektos/act-environments-ubuntu:18.04-lite`][hub/nektos/act-environments-ubuntu] | ![`nektos:18.04-lite`][hub/nektos/act-environments-ubuntu/18.04-lite/size] | [`nektos/act-environments`][gh/nektos/act-environments] |
-| [`nektos/act-environments-ubuntu:18.04-full`][hub/nektos/act-environments-ubuntu] | ![`nektos:18.04-full`][hub/nektos/act-environments-ubuntu/18.04-full/size] | [`nektos/act-environments`][gh/nektos/act-environments] |
-
-| Image                                                         | GitHub Repository                                                                     |
-| ------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
-| [`catthehacker/ubuntu:full-latest`][ghcr/catthehacker/ubuntu] | [`catthehacker/virtual-environments-fork`][gh/catthehacker/virtual-environments-fork] |
-| [`catthehacker/ubuntu:full-20.04`][ghcr/catthehacker/ubuntu]  | [`catthehacker/virtual-environments-fork`][gh/catthehacker/virtual-environments-fork] |
-| [`catthehacker/ubuntu:full-18.04`][ghcr/catthehacker/ubuntu]  | [`catthehacker/virtual-environments-fork`][gh/catthehacker/virtual-environments-fork] |
-
-Feel free to make a pull request with your image added here
-
-[hub/_/buildpack-deps]: https://hub.docker.com/_/buildpack-deps
-[hub/_/node]: https://hub.docker.com/r/_/node
-[hub/_/node/16-bullseye/size]: https://img.shields.io/docker/image-size/_/node/16-bullseye
-[hub/_/node/16-bullseye-slim/size]: https://img.shields.io/docker/image-size/_/node/16-bullseye-slim
-[hub/_/node/16-buster/size]: https://img.shields.io/docker/image-size/_/node/16-buster
-[hub/_/node/16-buster-slim/size]: https://img.shields.io/docker/image-size/_/node/16-buster-slim
-[ghcr/catthehacker/ubuntu]: https://github.com/catthehacker/docker_images/pkgs/container/ubuntu
-[hub/nektos/act-environments-ubuntu]: https://hub.docker.com/r/nektos/act-environments-ubuntu
-[hub/nektos/act-environments-ubuntu/18.04/size]: https://img.shields.io/docker/image-size/nektos/act-environments-ubuntu/18.04
-[hub/nektos/act-environments-ubuntu/18.04-lite/size]: https://img.shields.io/docker/image-size/nektos/act-environments-ubuntu/18.04-lite
-[hub/nektos/act-environments-ubuntu/18.04-full/size]: https://img.shields.io/docker/image-size/nektos/act-environments-ubuntu/18.04-full
-
-<!--
-[hub/<username>/<image>]: https://hub.docker.com/r/[username]/[image]
-[hub/<username>/<image>/<tag>/size]: https://img.shields.io/docker/image-size/[username]/[image]/[tag]
--->
-
-<!-- GitHub repository links -->
-
-[gh/nektos/act-environments]: https://github.com/nektos/act-environments
-[gh/actions/virtual-environments]: https://github.com/actions/virtual-environments
-[gh/catthehacker/docker_images]: https://github.com/catthehacker/docker_images
-[gh/catthehacker/virtual-environments-fork]: https://github.com/catthehacker/virtual-environments-fork

LICENSE

@@ -1,7 +1,4 @@
-MIT License
-
 Copyright (c) 2022 The Gitea Authors
-Copyright (c) 2019
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -10,13 +7,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Makefile

@@ -1,113 +1,150 @@
-PREFIX ?= /usr/local
-VERSION ?= $(shell git describe --tags --dirty --always | sed -e 's/^v//')
-IS_SNAPSHOT = $(if $(findstring -, $(VERSION)),true,false)
-MAJOR_VERSION = $(word 1, $(subst ., ,$(VERSION)))
-MINOR_VERSION = $(word 2, $(subst ., ,$(VERSION)))
-PATCH_VERSION = $(word 3, $(subst ., ,$(word 1,$(subst -, , $(VERSION)))))
-NEW_VERSION ?= $(MAJOR_VERSION).$(MINOR_VERSION).$(shell echo $$(( $(PATCH_VERSION) + 1)) )
+DIST := dist
+EXECUTABLE := act_runner
+GOFMT ?= gofumpt -l
+DIST := dist
+DIST_DIRS := $(DIST)/binaries $(DIST)/release
+GO ?= go
+SHASUM ?= shasum -a 256
+HAS_GO = $(shell hash $(GO) > /dev/null 2>&1 && echo "GO" || echo "NOGO" )
+XGO_PACKAGE ?= src.techknowlogick.com/xgo@latest
+XGO_VERSION := go-1.18.x
+GXZ_PAGAGE ?= github.com/ulikunitz/xz/cmd/[email protected]
 
-fix = false
-ifeq (true,$(fix))
-	FIX = --fix
+LINUX_ARCHS ?= linux/amd64,linux/arm64
+DARWIN_ARCHS ?= darwin-12/amd64,darwin-12/arm64
+WINDOWS_ARCHS ?= windows/amd64
+GOFILES := $(shell find . -type f -name "*.go" ! -name "generated.*")
+
+ifneq ($(shell uname), Darwin)
+	EXTLDFLAGS = -extldflags "-static" $(null)
+else
+	EXTLDFLAGS =
 endif
 
-ACT ?= go run main.go
+ifeq ($(HAS_GO), GO)
+	GOPATH ?= $(shell $(GO) env GOPATH)
+	export PATH := $(GOPATH)/bin:$(PATH)
 
-HAS_TOKEN = $(if $(test -e ~/.config/github/token),true,false)
-ifeq (true,$(HAS_TOKEN))
-	export GITHUB_TOKEN := $(shell cat ~/.config/github/token)
+	CGO_EXTRA_CFLAGS := -DSQLITE_MAX_VARIABLE_NUMBER=32766
+	CGO_CFLAGS ?= $(shell $(GO) env CGO_CFLAGS) $(CGO_EXTRA_CFLAGS)
 endif
 
-.PHONY: pr
-pr: tidy format-all lint test
-
-.PHONY: build
-build:
-	go build -ldflags "-X main.version=$(VERSION)" -o dist/local/act main.go
-
-.PHONY: format
-format:
-	go fmt ./...
-
-.PHONY: format-all
-format-all:
-	go fmt ./...
-	npx prettier --write .
-
-.PHONY: test
-test:
-	go test ./...
-	$(ACT)
-
-.PHONY: lint-go
-lint-go:
-	golangci-lint run $(FIX)
-
-.PHONY: lint-js
-lint-js:
-	npx standard $(FIX)
-
-.PHONY: lint-md
-lint-md:
-	npx markdownlint . $(FIX)
-
-.PHONY: lint-rest
-lint-rest:
-	docker run --rm -it \
-		-v $(PWD):/tmp/lint \
-		-e GITHUB_STATUS_REPORTER=false \
-		-e GITHUB_COMMENT_REPORTER=false \
-		megalinter/megalinter-go:v5
-
-.PHONY: lint
-lint: lint-go lint-rest
-
-.PHONY: lint-fix
-lint-fix: lint-md lint-go
-
-.PHONY: fix
-fix:
-	make lint-fix fix=true
-
-.PHONY: tidy
-tidy:
-	go mod tidy
-
-.PHONY: install
-install: build
-	@cp dist/local/act $(PREFIX)/bin/act
-	@chmod 755 $(PREFIX)/bin/act
-	@act --version
-
-.PHONY: installer
-installer:
-	@GO111MODULE=off go get github.com/goreleaser/godownloader
-	godownloader -r nektos/act -o install.sh
-
-.PHONY: promote
-promote:
-	@git fetch --tags
-	@echo "VERSION:$(VERSION) IS_SNAPSHOT:$(IS_SNAPSHOT) NEW_VERSION:$(NEW_VERSION)"
-ifeq (false,$(IS_SNAPSHOT))
-	@echo "Unable to promote a non-snapshot"
-	@exit 1
+ifeq ($(OS), Windows_NT)
+	GOFLAGS := -v -buildmode=exe
+	EXECUTABLE ?= $(EXECUTABLE).exe
+else ifeq ($(OS), Windows)
+	GOFLAGS := -v -buildmode=exe
+	EXECUTABLE ?= $(EXECUTABLE).exe
+else
+	GOFLAGS := -v
+	EXECUTABLE ?= $(EXECUTABLE)
 endif
-ifneq ($(shell git status -s),)
-	@echo "Unable to promote a dirty workspace"
-	@exit 1
+
+STORED_VERSION_FILE := VERSION
+
+ifneq ($(DRONE_TAG),)
+	VERSION ?= $(subst v,,$(DRONE_TAG))
+	RELASE_VERSION ?= $(VERSION)
+else
+	ifneq ($(DRONE_BRANCH),)
+		VERSION ?= $(subst release/v,,$(DRONE_BRANCH))
+	else
+		VERSION ?= master
+	endif
+
+	STORED_VERSION=$(shell cat $(STORED_VERSION_FILE) 2>/dev/null)
+	ifneq ($(STORED_VERSION),)
+		RELASE_VERSION ?= $(STORED_VERSION)
+	else
+		RELASE_VERSION ?= $(shell git describe --tags --always | sed 's/-/+/' | sed 's/^v//')
+	endif
 endif
-	echo -n $(NEW_VERSION) > VERSION
-	git add VERSION
-	git commit -m "chore: bump VERSION to $(NEW_VERSION)"
-	git tag -a -m "releasing v$(NEW_VERSION)" v$(NEW_VERSION)
-	git push origin master
-	git push origin v$(NEW_VERSION)
 
-.PHONY: snapshot
-snapshot:
-	goreleaser build \
-		--clean \
-		--single-target \
-		--snapshot
+TAGS ?=
+LDFLAGS ?= -X 'main.Version=$(VERSION)'
 
-.PHONY: clean all
+all: build
+
+fmt:
+	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install mvdan.cc/gofumpt@latest; \
+	fi
+	$(GOFMT) -w $(GOFILES)
+
+vet:
+	$(GO) vet ./...
+
+.PHONY: fmt-check
+fmt-check:
+	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) install mvdan.cc/gofumpt@latest; \
+	fi
+	@diff=$$($(GOFMT) -d $(GOFILES)); \
+	if [ -n "$$diff" ]; then \
+		echo "Please run 'make fmt' and commit the result:"; \
+		echo "$${diff}"; \
+		exit 1; \
+	fi;
+
+test: fmt-check
+	@$(GO) test -v -cover -coverprofile coverage.txt ./... && echo "\n==>\033[32m Ok\033[m\n" || exit 1
+
+install: $(GOFILES)
+	$(GO) install -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)'
+
+build: $(EXECUTABLE)
+
+$(EXECUTABLE): $(GOFILES)
+	$(GO) build -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o $@
+
+.PHONY: deps-backend
+deps-backend:
+	$(GO) mod download
+	$(GO) install $(GXZ_PAGAGE)
+	$(GO) install $(XGO_PACKAGE)
+
+.PHONY: release
+release: release-windows release-linux release-darwin release-copy release-compress release-check
+
+$(DIST_DIRS):
+	mkdir -p $(DIST_DIRS)
+
+.PHONY: release-windows
+release-windows: | $(DIST_DIRS)
+	CGO_CFLAGS="$(CGO_CFLAGS)" $(GO) run $(XGO_PACKAGE) -go $(XGO_VERSION) -buildmode exe -dest $(DIST)/binaries -tags 'netgo osusergo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets '$(WINDOWS_ARCHS)' -out $(EXECUTABLE)-$(VERSION) .
+ifeq ($(CI),true)
+	cp -r /build/* $(DIST)/binaries/
+endif
+
+.PHONY: release-linux
+release-linux: | $(DIST_DIRS)
+	CGO_CFLAGS="$(CGO_CFLAGS)" $(GO) run $(XGO_PACKAGE) -go $(XGO_VERSION) -dest $(DIST)/binaries -tags 'netgo osusergo $(TAGS)' -ldflags '-linkmode external -extldflags "-static" $(LDFLAGS)' -targets '$(LINUX_ARCHS)' -out $(EXECUTABLE)-$(VERSION) .
+ifeq ($(CI),true)
+	cp -r /build/* $(DIST)/binaries/
+endif
+
+.PHONY: release-darwin
+release-darwin: | $(DIST_DIRS)
+	CGO_CFLAGS="$(CGO_CFLAGS)" $(GO) run $(XGO_PACKAGE) -go $(XGO_VERSION) -dest $(DIST)/binaries -tags 'netgo osusergo $(TAGS)' -ldflags '$(LDFLAGS)' -targets '$(DARWIN_ARCHS)' -out $(EXECUTABLE)-$(VERSION) .
+ifeq ($(CI),true)
+	cp -r /build/* $(DIST)/binaries/
+endif
+
+.PHONY: release-copy
+release-copy: | $(DIST_DIRS)
+	cd $(DIST); for file in `find . -type f -name "*"`; do cp $${file} ./release/; done;
+
+.PHONY: release-check
+release-check: | $(DIST_DIRS)
+	cd $(DIST)/release/; for file in `find . -type f -name "*"`; do echo "checksumming $${file}" && $(SHASUM) `echo $${file} | sed 's/^..//'` > $${file}.sha256; done;
+
+.PHONY: release-compress
+release-compress: | $(DIST_DIRS)
+	cd $(DIST)/release/; for file in `find . -type f -name "*"`; do echo "compressing $${file}" && $(GO) run $(GXZ_PAGAGE) -k -9 $${file}; done;
+
+clean:
+	$(GO) clean -x -i ./...
+	rm -rf coverage.txt $(EXECUTABLE) $(DIST)
+
+version:
+	@echo $(VERSION)

README.md

@@ -1,62 +1,61 @@
-## Forking rules
+# act runner
 
-This is a custom fork of [nektos/act](https://github.com/nektos/act/), for the purpose of serving [act_runner](https://gitea.com/gitea/act_runner).
+Act runner is a runner for Gitea based on [act](https://gitea.com/gitea/act).
 
-It cannot be used as command line tool anymore, but only as a library.
+## Prerequisites
 
-It's a soft fork, which means that it will track the latest release of nektos/act.
+Docker Engine Community version is required. To install Docker CE, follow the official [install instructions](https://docs.docker.com/engine/install/).
 
-Branches:
+## Quickstart
 
-- `main`: default branch, contains custom changes, based on the latest release(not the latest of the master branch) of nektos/act.
-- `nektos/master`: mirror for the master branch of nektos/act.
+### Build
 
-Tags:
+```bash
+make build
+```
 
-- `nektos/vX.Y.Z`: mirror for `vX.Y.Z` of [nektos/act](https://github.com/nektos/act/).
-- `vX.YZ.*`: based on `nektos/vX.Y.Z`, contains custom changes.
-  - Examples:
-    - `nektos/v0.2.23` -> `v0.223.*`
-    - `nektos/v0.3.1` -> `v0.301.*`, not ~~`v0.31.*`~~
-    - `nektos/v0.10.1` -> `v0.1001.*`, not ~~`v0.101.*`~~
-    - `nektos/v0.3.100` -> not ~~`v0.3100.*`~~, I don't think it's really going to happen, if it does, we can find a way to handle it.
+### Register
 
----
+```bash
+./act_runner register
+```
 
-![act-logo](https://raw.githubusercontent.com/wiki/nektos/act/img/logo-150.png)
+And you will be asked to input:
 
-# Overview [![push](https://github.com/nektos/act/workflows/push/badge.svg?branch=master&event=push)](https://github.com/nektos/act/actions) [![Join the chat at https://gitter.im/nektos/act](https://badges.gitter.im/nektos/act.svg)](https://gitter.im/nektos/act?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Go Report Card](https://goreportcard.com/badge/github.com/nektos/act)](https://goreportcard.com/report/github.com/nektos/act) [![awesome-runners](https://img.shields.io/badge/listed%20on-awesome--runners-blue.svg)](https://github.com/jonico/awesome-runners)
+1. Gitea instance URL, like `http://192.168.8.8:3000/`. You should use your gitea instance ROOT_URL as the instance argument
+ and you should not use `localhost` or `127.0.0.1` as instance IP;
+2. Runner token, you can get it from `http://192.168.8.8:3000/admin/runners`;
+3. Runner name, you can just leave it blank;
+4. Runner labels, you can just leave it blank.
 
-> "Think globally, `act` locally"
+The process looks like:
 
-Run your [GitHub Actions](https://developer.github.com/actions/) locally! Why would you want to do this? Two reasons:
+```text
+INFO Registering runner, arch=amd64, os=darwin, version=0.1.5.
+WARN Runner in user-mode.
+INFO Enter the Gitea instance URL (for example, https://gitea.com/):
+http://192.168.8.8:3000/
+INFO Enter the runner token:
+fe884e8027dc292970d4e0303fe82b14xxxxxxxx
+INFO Enter the runner name (if set empty, use hostname:Test.local ):
 
-- **Fast Feedback** - Rather than having to commit/push every time you want to test out the changes you are making to your `.github/workflows/` files (or for any changes to embedded GitHub actions), you can use `act` to run the actions locally. The [environment variables](https://help.github.com/en/actions/configuring-and-managing-workflows/using-environment-variables#default-environment-variables) and [filesystem](https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners#filesystems-on-github-hosted-runners) are all configured to match what GitHub provides.
-- **Local Task Runner** - I love [make](<https://en.wikipedia.org/wiki/Make_(software)>). However, I also hate repeating myself. With `act`, you can use the GitHub Actions defined in your `.github/workflows/` to replace your `Makefile`!
+INFO Enter the runner labels, leave blank to use the default labels (comma-separated, for example, self-hosted,ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster):
 
-# How Does It Work?
+INFO Registering runner, name=Test.local, instance=http://192.168.8.8:3000/, labels=[ubuntu-latest:docker://node:16-bullseye ubuntu-22.04:docker://node:16-bullseye ubuntu-20.04:docker://node:16-bullseye ubuntu-18.04:docker://node:16-buster].
+DEBU Successfully pinged the Gitea instance server
+INFO Runner registered successfully.
+```
 
-When you run `act` it reads in your GitHub Actions from `.github/workflows/` and determines the set of actions that need to be run. It uses the Docker API to either pull or build the necessary images, as defined in your workflow files and finally determines the execution path based on the dependencies that were defined. Once it has the execution path, it then uses the Docker API to run containers for each action based on the images prepared earlier. The [environment variables](https://help.github.com/en/actions/configuring-and-managing-workflows/using-environment-variables#default-environment-variables) and [filesystem](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#file-systems) are all configured to match what GitHub provides.
+You can also register with command line arguments.
 
-Let's see it in action with a [sample repo](https://github.com/cplee/github-actions-demo)!
+```bash
+./act_runner register --instance http://192.168.8.8:3000 --token <my_runner_token> --no-interactive
+```
 
-![Demo](https://raw.githubusercontent.com/wiki/nektos/act/quickstart/act-quickstart-2.gif)
+If the registry succeed, it will run immediately. Next time, you could run the runner directly.
 
-# Act User Guide
+### Run
 
-Please look at the [act user guide](https://nektosact.com) for more documentation.
-
-# Support
-
-Need help? Ask on [Gitter](https://gitter.im/nektos/act)!
-
-# Contributing
-
-Want to contribute to act? Awesome! Check out the [contributing guidelines](CONTRIBUTING.md) to get involved.
-
-## Manually building from source
-
-- Install Go tools 1.20+ - (<https://golang.org/doc/install>)
-- Clone this repo `git clone [email protected]:nektos/act.git`
-- Run unit tests with `make test`
-- Build and install: `make install`
+```bash
+./act_runner daemon
+```

VERIFICATION

@@ -1,5 +0,0 @@
-VERIFICATION
-Verification is intended to assist the Chocolatey moderators and community
-in verifying that this package's contents are trustworthy.
-
-Checksums: https://github.com/nektos/act/releases, in the checksums.txt file

VERSION

@@ -1 +0,0 @@
-0.2.61

act-cli.nuspec

@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Do not remove this test for UTF-8: if “Ω” doesn’t appear as greek uppercase omega letter enclosed in quotation marks, you should use an editor that supports UTF-8, not this one. -->
-<package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
-  <metadata>
-    <id>act-cli</id>
-    <version>0.0.0</version>
-    <packageSourceUrl>https://github.com/nektos/act</packageSourceUrl>
-    <owners>nektos</owners>
-    <title>act (GitHub Actions CLI)</title>
-    <authors>nektos</authors>
-    <projectUrl>https://github.com/nektos/act</projectUrl>
-    <iconUrl>https://raw.githubusercontent.com/wiki/nektos/act/img/logo-150.png</iconUrl>
-    <copyright>Nektos</copyright>
-    <licenseUrl>https://raw.githubusercontent.com/nektos/act/master/LICENSE</licenseUrl>
-    <requireLicenseAcceptance>true</requireLicenseAcceptance>
-    <projectSourceUrl>https://github.com/nektos/act</projectSourceUrl>
-    <docsUrl>https://raw.githubusercontent.com/nektos/act/master/README.md</docsUrl>
-    <bugTrackerUrl>https://github.com/nektos/act/issues</bugTrackerUrl>
-    <tags>act github-actions actions golang ci devops</tags>
-    <summary>Run your GitHub Actions locally 🚀</summary>
-    <description>Run your GitHub Actions locally 🚀</description>
-  </metadata>
-  <files>
-    <file src="tools/**" target="tools" />
-  </files>
-</package>

client/client.go

@@ -0,0 +1,14 @@
+package client
+
+import (
+	"code.gitea.io/actions-proto-go/ping/v1/pingv1connect"
+	"code.gitea.io/actions-proto-go/runner/v1/runnerv1connect"
+)
+
+// A Client manages communication with the runner.
+type Client interface {
+	pingv1connect.PingServiceClient
+	runnerv1connect.RunnerServiceClient
+	Address() string
+	Insecure() bool
+}

client/http.go

@@ -0,0 +1,76 @@
+package client
+
+import (
+	"context"
+	"crypto/tls"
+	"net/http"
+	"strings"
+
+	"code.gitea.io/actions-proto-go/ping/v1/pingv1connect"
+	"code.gitea.io/actions-proto-go/runner/v1/runnerv1connect"
+	"gitea.com/gitea/act_runner/core"
+	"github.com/bufbuild/connect-go"
+)
+
+func getHttpClient(endpoint string, insecure bool) *http.Client {
+	if strings.HasPrefix(endpoint, "https://") && insecure {
+		return &http.Client{
+			Transport: &http.Transport{
+				TLSClientConfig: &tls.Config{
+					InsecureSkipVerify: true,
+				},
+			},
+		}
+	}
+	return http.DefaultClient
+}
+
+// New returns a new runner client.
+func New(endpoint string, insecure bool, uuid, token string, opts ...connect.ClientOption) *HTTPClient {
+	baseURL := strings.TrimRight(endpoint, "/") + "/api/actions"
+
+	opts = append(opts, connect.WithInterceptors(connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {
+		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
+			if uuid != "" {
+				req.Header().Set(core.UUIDHeader, uuid)
+			}
+			if token != "" {
+				req.Header().Set(core.TokenHeader, token)
+			}
+			return next(ctx, req)
+		}
+	})))
+
+	return &HTTPClient{
+		PingServiceClient: pingv1connect.NewPingServiceClient(
+			getHttpClient(endpoint, insecure),
+			baseURL,
+			opts...,
+		),
+		RunnerServiceClient: runnerv1connect.NewRunnerServiceClient(
+			getHttpClient(endpoint, insecure),
+			baseURL,
+			opts...,
+		),
+		endpoint: endpoint,
+		insecure: insecure,
+	}
+}
+
+func (c *HTTPClient) Address() string {
+	return c.endpoint
+}
+
+func (c *HTTPClient) Insecure() bool {
+	return c.insecure
+}
+
+var _ Client = (*HTTPClient)(nil)
+
+// An HTTPClient manages communication with the runner API.
+type HTTPClient struct {
+	pingv1connect.PingServiceClient
+	runnerv1connect.RunnerServiceClient
+	endpoint string
+	insecure bool
+}

cmd/cmd.go

@@ -0,0 +1,63 @@
+package cmd
+
+import (
+	"context"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+const version = "0.1.5"
+
+type globalArgs struct {
+	EnvFile string
+}
+
+func Execute(ctx context.Context) {
+	// task := runtime.NewTask("gitea", 0, nil, nil)
+
+	var gArgs globalArgs
+
+	// ./act_runner
+	rootCmd := &cobra.Command{
+		Use:          "act [event name to run]\nIf no event name passed, will default to \"on: push\"",
+		Short:        "Run GitHub actions locally by specifying the event name (e.g. `push`) or an action name directly.",
+		Args:         cobra.MaximumNArgs(1),
+		Version:      version,
+		SilenceUsage: true,
+	}
+	rootCmd.PersistentFlags().StringVarP(&gArgs.EnvFile, "env-file", "", ".env", "Read in a file of environment variables.")
+
+	// ./act_runner register
+	var regArgs registerArgs
+	registerCmd := &cobra.Command{
+		Use:   "register",
+		Short: "Register a runner to the server",
+		Args:  cobra.MaximumNArgs(0),
+		RunE:  runRegister(ctx, &regArgs, gArgs.EnvFile), // must use a pointer to regArgs
+	}
+	registerCmd.Flags().BoolVar(&regArgs.NoInteractive, "no-interactive", false, "Disable interactive mode")
+	registerCmd.Flags().StringVar(&regArgs.InstanceAddr, "instance", "", "Gitea instance address")
+	registerCmd.Flags().BoolVar(&regArgs.Insecure, "insecure", false, "If check server's certificate if it's https protocol")
+	registerCmd.Flags().StringVar(&regArgs.Token, "token", "", "Runner token")
+	registerCmd.Flags().StringVar(&regArgs.RunnerName, "name", "", "Runner name")
+	registerCmd.Flags().StringVar(&regArgs.Labels, "labels", "", "Runner tags, comma separated")
+	rootCmd.AddCommand(registerCmd)
+
+	// ./act_runner daemon
+	daemonCmd := &cobra.Command{
+		Use:   "daemon",
+		Short: "Run as a runner daemon",
+		Args:  cobra.MaximumNArgs(1),
+		RunE:  runDaemon(ctx, gArgs.EnvFile),
+	}
+	// add all command
+	rootCmd.AddCommand(daemonCmd)
+
+	// hide completion command
+	rootCmd.CompletionOptions.HiddenDefaultCmd = true
+
+	if err := rootCmd.Execute(); err != nil {
+		os.Exit(1)
+	}
+}

cmd/daemon.go

@@ -0,0 +1,112 @@
+package cmd
+
+import (
+	"context"
+	"os"
+	"strings"
+
+	"gitea.com/gitea/act_runner/client"
+	"gitea.com/gitea/act_runner/config"
+	"gitea.com/gitea/act_runner/engine"
+	"gitea.com/gitea/act_runner/poller"
+	"gitea.com/gitea/act_runner/runtime"
+
+	"github.com/joho/godotenv"
+	"github.com/mattn/go-isatty"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+	"golang.org/x/sync/errgroup"
+)
+
+func runDaemon(ctx context.Context, envFile string) func(cmd *cobra.Command, args []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		log.Infoln("Starting runner daemon")
+
+		_ = godotenv.Load(envFile)
+		cfg, err := config.FromEnviron()
+		if err != nil {
+			log.WithError(err).
+				Fatalln("invalid configuration")
+		}
+
+		initLogging(cfg)
+
+		// require docker if a runner label uses a docker backend
+		needsDocker := false
+		for _, l := range cfg.Runner.Labels {
+			splits := strings.SplitN(l, ":", 2)
+			if len(splits) == 2 && strings.HasPrefix(splits[1], "docker://") {
+				needsDocker = true
+				break
+			}
+		}
+
+		if needsDocker {
+			// try to connect to docker daemon
+			// if failed, exit with error
+			if err := engine.Start(ctx); err != nil {
+				log.WithError(err).Fatalln("failed to connect docker daemon engine")
+			}
+		}
+
+		var g errgroup.Group
+
+		cli := client.New(
+			cfg.Client.Address,
+			cfg.Client.Insecure,
+			cfg.Runner.UUID,
+			cfg.Runner.Token,
+		)
+
+		runner := &runtime.Runner{
+			Client:        cli,
+			Machine:       cfg.Runner.Name,
+			ForgeInstance: cfg.Client.Address,
+			Environ:       cfg.Runner.Environ,
+			Labels:        cfg.Runner.Labels,
+		}
+
+		poller := poller.New(
+			cli,
+			runner.Run,
+			cfg.Runner.Capacity,
+		)
+
+		g.Go(func() error {
+			l := log.WithField("capacity", cfg.Runner.Capacity).
+				WithField("endpoint", cfg.Client.Address).
+				WithField("os", cfg.Platform.OS).
+				WithField("arch", cfg.Platform.Arch)
+			l.Infoln("polling the remote server")
+
+			if err := poller.Poll(ctx); err != nil {
+				l.Errorf("poller error: %v", err)
+			}
+			poller.Wait()
+			return nil
+		})
+
+		err = g.Wait()
+		if err != nil {
+			log.WithError(err).
+				Errorln("shutting down the server")
+		}
+		return err
+	}
+}
+
+// initLogging setup the global logrus logger.
+func initLogging(cfg config.Config) {
+	isTerm := isatty.IsTerminal(os.Stdout.Fd())
+	log.SetFormatter(&log.TextFormatter{
+		DisableColors: !isTerm,
+		FullTimestamp: true,
+	})
+
+	if cfg.Debug {
+		log.SetLevel(log.DebugLevel)
+	}
+	if cfg.Trace {
+		log.SetLevel(log.TraceLevel)
+	}
+}

cmd/dir.go

@@ -1,27 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"path/filepath"
-
-	log "github.com/sirupsen/logrus"
-)
-
-var (
-	UserHomeDir  string
-	CacheHomeDir string
-)
-
-func init() {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		log.Fatal(err)
-	}
-	UserHomeDir = home
-
-	if v := os.Getenv("XDG_CACHE_HOME"); v != "" {
-		CacheHomeDir = v
-	} else {
-		CacheHomeDir = filepath.Join(UserHomeDir, ".cache")
-	}
-}

cmd/graph.go

@@ -1,38 +0,0 @@
-package cmd
-
-import (
-	"os"
-
-	"github.com/nektos/act/pkg/common"
-	"github.com/nektos/act/pkg/model"
-)
-
-func drawGraph(plan *model.Plan) error {
-	drawings := make([]*common.Drawing, 0)
-
-	jobPen := common.NewPen(common.StyleSingleLine, 96)
-	arrowPen := common.NewPen(common.StyleNoLine, 97)
-	for i, stage := range plan.Stages {
-		if i > 0 {
-			drawings = append(drawings, arrowPen.DrawArrow())
-		}
-
-		ids := make([]string, 0)
-		for _, r := range stage.Runs {
-			ids = append(ids, r.String())
-		}
-		drawings = append(drawings, jobPen.DrawBoxes(ids...))
-	}
-
-	maxWidth := 0
-	for _, d := range drawings {
-		if d.GetWidth() > maxWidth {
-			maxWidth = d.GetWidth()
-		}
-	}
-
-	for _, d := range drawings {
-		d.Draw(os.Stdout, maxWidth)
-	}
-	return nil
-}

cmd/input.go

@@ -1,112 +0,0 @@
-package cmd
-
-import (
-	"path/filepath"
-
-	log "github.com/sirupsen/logrus"
-)
-
-// Input contains the input for the root command
-type Input struct {
-	actor                              string
-	workdir                            string
-	workflowsPath                      string
-	autodetectEvent                    bool
-	eventPath                          string
-	reuseContainers                    bool
-	bindWorkdir                        bool
-	secrets                            []string
-	vars                               []string
-	envs                               []string
-	inputs                             []string
-	platforms                          []string
-	dryrun                             bool
-	forcePull                          bool
-	forceRebuild                       bool
-	noOutput                           bool
-	envfile                            string
-	inputfile                          string
-	secretfile                         string
-	varfile                            string
-	insecureSecrets                    bool
-	defaultBranch                      string
-	privileged                         bool
-	usernsMode                         string
-	containerArchitecture              string
-	containerDaemonSocket              string
-	containerOptions                   string
-	noWorkflowRecurse                  bool
-	useGitIgnore                       bool
-	githubInstance                     string
-	containerCapAdd                    []string
-	containerCapDrop                   []string
-	autoRemove                         bool
-	artifactServerPath                 string
-	artifactServerAddr                 string
-	artifactServerPort                 string
-	noCacheServer                      bool
-	cacheServerPath                    string
-	cacheServerAddr                    string
-	cacheServerPort                    uint16
-	jsonLogger                         bool
-	noSkipCheckout                     bool
-	remoteName                         string
-	replaceGheActionWithGithubCom      []string
-	replaceGheActionTokenWithGithubCom string
-	matrix                             []string
-	actionCachePath                    string
-	actionOfflineMode                  bool
-	logPrefixJobID                     bool
-	networkName                        string
-	useNewActionCache                  bool
-	localRepository                    []string
-	maxParallel                        int
-}
-
-func (i *Input) resolve(path string) string {
-	basedir, err := filepath.Abs(i.workdir)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if path == "" {
-		return path
-	}
-	if !filepath.IsAbs(path) {
-		path = filepath.Join(basedir, path)
-	}
-	return path
-}
-
-// Envfile returns path to .env
-func (i *Input) Envfile() string {
-	return i.resolve(i.envfile)
-}
-
-// Secretfile returns path to secrets
-func (i *Input) Secretfile() string {
-	return i.resolve(i.secretfile)
-}
-
-func (i *Input) Varfile() string {
-	return i.resolve(i.varfile)
-}
-
-// Workdir returns path to workdir
-func (i *Input) Workdir() string {
-	return i.resolve(".")
-}
-
-// WorkflowsPath returns path to workflow file(s)
-func (i *Input) WorkflowsPath() string {
-	return i.resolve(i.workflowsPath)
-}
-
-// EventPath returns the path to events file
-func (i *Input) EventPath() string {
-	return i.resolve(i.eventPath)
-}
-
-// Inputfile returns the path to the input file
-func (i *Input) Inputfile() string {
-	return i.resolve(i.inputfile)
-}

cmd/list.go

@@ -1,107 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/nektos/act/pkg/model"
-)
-
-func printList(plan *model.Plan) error {
-	type lineInfoDef struct {
-		jobID   string
-		jobName string
-		stage   string
-		wfName  string
-		wfFile  string
-		events  string
-	}
-	lineInfos := []lineInfoDef{}
-
-	header := lineInfoDef{
-		jobID:   "Job ID",
-		jobName: "Job name",
-		stage:   "Stage",
-		wfName:  "Workflow name",
-		wfFile:  "Workflow file",
-		events:  "Events",
-	}
-
-	jobs := map[string]bool{}
-	duplicateJobIDs := false
-
-	jobIDMaxWidth := len(header.jobID)
-	jobNameMaxWidth := len(header.jobName)
-	stageMaxWidth := len(header.stage)
-	wfNameMaxWidth := len(header.wfName)
-	wfFileMaxWidth := len(header.wfFile)
-	eventsMaxWidth := len(header.events)
-
-	for i, stage := range plan.Stages {
-		for _, r := range stage.Runs {
-			jobID := r.JobID
-			line := lineInfoDef{
-				jobID:   jobID,
-				jobName: r.String(),
-				stage:   strconv.Itoa(i),
-				wfName:  r.Workflow.Name,
-				wfFile:  r.Workflow.File,
-				events:  strings.Join(r.Workflow.On(), `,`),
-			}
-			if _, ok := jobs[jobID]; ok {
-				duplicateJobIDs = true
-			} else {
-				jobs[jobID] = true
-			}
-			lineInfos = append(lineInfos, line)
-			if jobIDMaxWidth < len(line.jobID) {
-				jobIDMaxWidth = len(line.jobID)
-			}
-			if jobNameMaxWidth < len(line.jobName) {
-				jobNameMaxWidth = len(line.jobName)
-			}
-			if stageMaxWidth < len(line.stage) {
-				stageMaxWidth = len(line.stage)
-			}
-			if wfNameMaxWidth < len(line.wfName) {
-				wfNameMaxWidth = len(line.wfName)
-			}
-			if wfFileMaxWidth < len(line.wfFile) {
-				wfFileMaxWidth = len(line.wfFile)
-			}
-			if eventsMaxWidth < len(line.events) {
-				eventsMaxWidth = len(line.events)
-			}
-		}
-	}
-
-	jobIDMaxWidth += 2
-	jobNameMaxWidth += 2
-	stageMaxWidth += 2
-	wfNameMaxWidth += 2
-	wfFileMaxWidth += 2
-
-	fmt.Printf("%*s%*s%*s%*s%*s%*s\n",
-		-stageMaxWidth, header.stage,
-		-jobIDMaxWidth, header.jobID,
-		-jobNameMaxWidth, header.jobName,
-		-wfNameMaxWidth, header.wfName,
-		-wfFileMaxWidth, header.wfFile,
-		-eventsMaxWidth, header.events,
-	)
-	for _, line := range lineInfos {
-		fmt.Printf("%*s%*s%*s%*s%*s%*s\n",
-			-stageMaxWidth, line.stage,
-			-jobIDMaxWidth, line.jobID,
-			-jobNameMaxWidth, line.jobName,
-			-wfNameMaxWidth, line.wfName,
-			-wfFileMaxWidth, line.wfFile,
-			-eventsMaxWidth, line.events,
-		)
-	}
-	if duplicateJobIDs {
-		fmt.Print("\nDetected multiple jobs with the same job name, use `-W` to specify the path to the specific workflow.\n")
-	}
-	return nil
-}

cmd/notices.go

@@ -1,140 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	log "github.com/sirupsen/logrus"
-)
-
-type Notice struct {
-	Level   string `json:"level"`
-	Message string `json:"message"`
-}
-
-func displayNotices(input *Input) {
-	select {
-	case notices := <-noticesLoaded:
-		if len(notices) > 0 {
-			noticeLogger := log.New()
-			if input.jsonLogger {
-				noticeLogger.SetFormatter(&log.JSONFormatter{})
-			} else {
-				noticeLogger.SetFormatter(&log.TextFormatter{
-					DisableQuote:     true,
-					DisableTimestamp: true,
-					PadLevelText:     true,
-				})
-			}
-
-			fmt.Printf("\n")
-			for _, notice := range notices {
-				level, err := log.ParseLevel(notice.Level)
-				if err != nil {
-					level = log.InfoLevel
-				}
-				noticeLogger.Log(level, notice.Message)
-			}
-		}
-	case <-time.After(time.Second * 1):
-		log.Debugf("Timeout waiting for notices")
-	}
-}
-
-var noticesLoaded = make(chan []Notice)
-
-func loadVersionNotices(version string) {
-	go func() {
-		noticesLoaded <- getVersionNotices(version)
-	}()
-}
-
-const NoticeURL = "https://api.nektosact.com/notices"
-
-func getVersionNotices(version string) []Notice {
-	if os.Getenv("ACT_DISABLE_VERSION_CHECK") == "1" {
-		return nil
-	}
-
-	noticeURL, err := url.Parse(NoticeURL)
-	if err != nil {
-		log.Error(err)
-		return nil
-	}
-	query := noticeURL.Query()
-	query.Add("os", runtime.GOOS)
-	query.Add("arch", runtime.GOARCH)
-	query.Add("version", version)
-
-	noticeURL.RawQuery = query.Encode()
-
-	client := &http.Client{}
-	req, err := http.NewRequest("GET", noticeURL.String(), nil)
-	if err != nil {
-		log.Debug(err)
-		return nil
-	}
-
-	etag := loadNoticesEtag()
-	if etag != "" {
-		log.Debugf("Conditional GET for notices etag=%s", etag)
-		req.Header.Set("If-None-Match", etag)
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		log.Debug(err)
-		return nil
-	}
-
-	newEtag := resp.Header.Get("Etag")
-	if newEtag != "" {
-		log.Debugf("Saving notices etag=%s", newEtag)
-		saveNoticesEtag(newEtag)
-	}
-
-	defer resp.Body.Close()
-	notices := []Notice{}
-	if resp.StatusCode == 304 {
-		log.Debug("No new notices")
-		return nil
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&notices); err != nil {
-		log.Debug(err)
-		return nil
-	}
-
-	return notices
-}
-
-func loadNoticesEtag() string {
-	p := etagPath()
-	content, err := os.ReadFile(p)
-	if err != nil {
-		log.Debugf("Unable to load etag from %s: %e", p, err)
-	}
-	return strings.TrimSuffix(string(content), "\n")
-}
-
-func saveNoticesEtag(etag string) {
-	p := etagPath()
-	err := os.WriteFile(p, []byte(strings.TrimSuffix(etag, "\n")), 0o600)
-	if err != nil {
-		log.Debugf("Unable to save etag to %s: %e", p, err)
-	}
-}
-
-func etagPath() string {
-	dir := filepath.Join(CacheHomeDir, "act")
-	if err := os.MkdirAll(dir, 0o777); err != nil {
-		log.Fatal(err)
-	}
-	return filepath.Join(dir, ".notices.etag")
-}

cmd/platforms.go

@@ -1,22 +0,0 @@
-package cmd
-
-import (
-	"strings"
-)
-
-func (i *Input) newPlatforms() map[string]string {
-	platforms := map[string]string{
-		"ubuntu-latest": "node:16-buster-slim",
-		"ubuntu-22.04":  "node:16-bullseye-slim",
-		"ubuntu-20.04":  "node:16-buster-slim",
-		"ubuntu-18.04":  "node:16-buster-slim",
-	}
-
-	for _, p := range i.platforms {
-		pParts := strings.Split(p, "=")
-		if len(pParts) == 2 {
-			platforms[strings.ToLower(pParts[0])] = pParts[1]
-		}
-	}
-	return platforms
-}

cmd/register.go

@@ -0,0 +1,305 @@
+package cmd
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"runtime"
+	"strings"
+	"time"
+
+	pingv1 "code.gitea.io/actions-proto-go/ping/v1"
+	"gitea.com/gitea/act_runner/client"
+	"gitea.com/gitea/act_runner/config"
+	"gitea.com/gitea/act_runner/register"
+
+	"github.com/bufbuild/connect-go"
+	"github.com/joho/godotenv"
+	"github.com/mattn/go-isatty"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+// runRegister registers a runner to the server
+func runRegister(ctx context.Context, regArgs *registerArgs, envFile string) func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		log.SetReportCaller(false)
+		isTerm := isatty.IsTerminal(os.Stdout.Fd())
+		log.SetFormatter(&log.TextFormatter{
+			DisableColors:    !isTerm,
+			DisableTimestamp: true,
+		})
+		log.SetLevel(log.DebugLevel)
+
+		log.Infof("Registering runner, arch=%s, os=%s, version=%s.",
+			runtime.GOARCH, runtime.GOOS, version)
+
+		// runner always needs root permission
+		if os.Getuid() != 0 {
+			// TODO: use a better way to check root permission
+			log.Warnf("Runner in user-mode.")
+		}
+
+		if regArgs.NoInteractive {
+			if err := registerNoInteractive(envFile, regArgs); err != nil {
+				return err
+			}
+		} else {
+			go func() {
+				if err := registerInteractive(envFile); err != nil {
+					// log.Errorln(err)
+					os.Exit(2)
+					return
+				}
+				os.Exit(0)
+			}()
+
+			c := make(chan os.Signal, 1)
+			signal.Notify(c, os.Interrupt)
+			<-c
+		}
+
+		return nil
+	}
+}
+
+// registerArgs represents the arguments for register command
+type registerArgs struct {
+	NoInteractive bool
+	InstanceAddr  string
+	Insecure      bool
+	Token         string
+	RunnerName    string
+	Labels        string
+}
+
+type registerStage int8
+
+const (
+	StageUnknown              registerStage = -1
+	StageOverwriteLocalConfig registerStage = iota + 1
+	StageInputInstance
+	StageInputToken
+	StageInputRunnerName
+	StageInputCustomLabels
+	StageWaitingForRegistration
+	StageExit
+)
+
+var defaultLabels = []string{
+	"ubuntu-latest:docker://node:16-bullseye",
+	"ubuntu-22.04:docker://node:16-bullseye", // There's no node:16-bookworm yet
+	"ubuntu-20.04:docker://node:16-bullseye",
+	"ubuntu-18.04:docker://node:16-buster",
+}
+
+type registerInputs struct {
+	InstanceAddr string
+	Insecure     bool
+	Token        string
+	RunnerName   string
+	CustomLabels []string
+}
+
+func (r *registerInputs) validate() error {
+	if r.InstanceAddr == "" {
+		return fmt.Errorf("instance address is empty")
+	}
+	if r.Token == "" {
+		return fmt.Errorf("token is empty")
+	}
+	if len(r.CustomLabels) > 0 {
+		return validateLabels(r.CustomLabels)
+	}
+	return nil
+}
+
+func validateLabels(labels []string) error {
+	for _, label := range labels {
+		values := strings.SplitN(label, ":", 2)
+		if len(values) > 2 {
+			return fmt.Errorf("Invalid label: %s", label)
+		}
+		// len(values) == 1, label for non docker execution environment
+		// TODO: validate value format, like docker://node:16-buster
+	}
+	return nil
+}
+
+func (r *registerInputs) assignToNext(stage registerStage, value string) registerStage {
+	// must set instance address and token.
+	// if empty, keep current stage.
+	if stage == StageInputInstance || stage == StageInputToken {
+		if value == "" {
+			return stage
+		}
+	}
+
+	// set hostname for runner name if empty
+	if stage == StageInputRunnerName && value == "" {
+		value, _ = os.Hostname()
+	}
+
+	switch stage {
+	case StageOverwriteLocalConfig:
+		if value == "Y" || value == "y" {
+			return StageInputInstance
+		}
+		return StageExit
+	case StageInputInstance:
+		r.InstanceAddr = value
+		return StageInputToken
+	case StageInputToken:
+		r.Token = value
+		return StageInputRunnerName
+	case StageInputRunnerName:
+		r.RunnerName = value
+		return StageInputCustomLabels
+	case StageInputCustomLabels:
+		r.CustomLabels = defaultLabels
+		if value != "" {
+			r.CustomLabels = strings.Split(value, ",")
+		}
+
+		if validateLabels(r.CustomLabels) != nil {
+			log.Infoln("Invalid labels, please input again, leave blank to use the default labels (for example, ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster)")
+			return StageInputCustomLabels
+		}
+		return StageWaitingForRegistration
+	}
+	return StageUnknown
+}
+
+func registerInteractive(envFile string) error {
+	var (
+		reader = bufio.NewReader(os.Stdin)
+		stage  = StageInputInstance
+		inputs = new(registerInputs)
+	)
+
+	// check if overwrite local config
+	_ = godotenv.Load(envFile)
+	cfg, _ := config.FromEnviron()
+	if f, err := os.Stat(cfg.Runner.File); err == nil && !f.IsDir() {
+		stage = StageOverwriteLocalConfig
+	}
+
+	for {
+		printStageHelp(stage)
+
+		cmdString, err := reader.ReadString('\n')
+		if err != nil {
+			return err
+		}
+		stage = inputs.assignToNext(stage, strings.TrimSpace(cmdString))
+
+		if stage == StageWaitingForRegistration {
+			log.Infof("Registering runner, name=%s, instance=%s, labels=%v.", inputs.RunnerName, inputs.InstanceAddr, inputs.CustomLabels)
+			if err := doRegister(&cfg, inputs); err != nil {
+				log.Errorf("Failed to register runner: %v", err)
+			} else {
+				log.Infof("Runner registered successfully.")
+			}
+			return nil
+		}
+
+		if stage == StageExit {
+			return nil
+		}
+
+		if stage <= StageUnknown {
+			log.Errorf("Invalid input, please re-run act command.")
+			return nil
+		}
+	}
+}
+
+func printStageHelp(stage registerStage) {
+	switch stage {
+	case StageOverwriteLocalConfig:
+		log.Infoln("Runner is already registered, overwrite local config? [y/N]")
+	case StageInputInstance:
+		log.Infoln("Enter the Gitea instance URL (for example, https://gitea.com/):")
+	case StageInputToken:
+		log.Infoln("Enter the runner token:")
+	case StageInputRunnerName:
+		hostname, _ := os.Hostname()
+		log.Infof("Enter the runner name (if set empty, use hostname:%s ):\n", hostname)
+	case StageInputCustomLabels:
+		log.Infoln("Enter the runner labels, leave blank to use the default labels (comma-separated, for example, self-hosted,ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster):")
+	case StageWaitingForRegistration:
+		log.Infoln("Waiting for registration...")
+	}
+}
+
+func registerNoInteractive(envFile string, regArgs *registerArgs) error {
+	_ = godotenv.Load(envFile)
+	cfg, _ := config.FromEnviron()
+	inputs := &registerInputs{
+		InstanceAddr: regArgs.InstanceAddr,
+		Insecure:     regArgs.Insecure,
+		Token:        regArgs.Token,
+		RunnerName:   regArgs.RunnerName,
+		CustomLabels: defaultLabels,
+	}
+	regArgs.Labels = strings.TrimSpace(regArgs.Labels)
+	if regArgs.Labels != "" {
+		inputs.CustomLabels = strings.Split(regArgs.Labels, ",")
+	}
+	if inputs.RunnerName == "" {
+		inputs.RunnerName, _ = os.Hostname()
+		log.Infof("Runner name is empty, use hostname '%s'.", inputs.RunnerName)
+	}
+	if err := inputs.validate(); err != nil {
+		log.WithError(err).Errorf("Invalid input, please re-run act command.")
+		return nil
+	}
+	if err := doRegister(&cfg, inputs); err != nil {
+		log.Errorf("Failed to register runner: %v", err)
+		return nil
+	}
+	log.Infof("Runner registered successfully.")
+	return nil
+}
+
+func doRegister(cfg *config.Config, inputs *registerInputs) error {
+	ctx := context.Background()
+
+	// initial http client
+	cli := client.New(
+		inputs.InstanceAddr,
+		inputs.Insecure,
+		"", "",
+	)
+
+	for {
+		_, err := cli.Ping(ctx, connect.NewRequest(&pingv1.PingRequest{
+			Data: inputs.RunnerName,
+		}))
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+		}
+		if ctx.Err() != nil {
+			break
+		}
+		if err != nil {
+			log.WithError(err).
+				Errorln("Cannot ping the Gitea instance server")
+			// TODO: if ping failed, retry or exit
+			time.Sleep(time.Second)
+		} else {
+			log.Debugln("Successfully pinged the Gitea instance server")
+			break
+		}
+	}
+
+	cfg.Runner.Name = inputs.RunnerName
+	cfg.Runner.Token = inputs.Token
+	cfg.Runner.Labels = inputs.CustomLabels
+	_, err := register.New(cli).Register(ctx, cfg.Runner)
+	return err
+}

cmd/register_test.go

@@ -0,0 +1,10 @@
+package cmd
+
+import "testing"
+
+func TestValidateLabels(t *testing.T) {
+	labels := []string{"ubuntu-latest:docker://node:16-buster", "self-hosted"}
+	if err := validateLabels(labels); err != nil {
+		t.Errorf("validateLabels() error = %v", err)
+	}
+}

cmd/root.go

@@ -1,721 +0,0 @@
-package cmd
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"runtime/debug"
-	"strings"
-
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/adrg/xdg"
-	"github.com/andreaskoch/go-fswatch"
-	docker_container "github.com/docker/docker/api/types/container"
-	"github.com/joho/godotenv"
-	gitignore "github.com/sabhiram/go-gitignore"
-	log "github.com/sirupsen/logrus"
-	"github.com/spf13/cobra"
-	"go.yaml.in/yaml/v4"
-
-	"github.com/nektos/act/pkg/artifactcache"
-	"github.com/nektos/act/pkg/artifacts"
-	"github.com/nektos/act/pkg/common"
-	"github.com/nektos/act/pkg/container"
-	"github.com/nektos/act/pkg/model"
-	"github.com/nektos/act/pkg/runner"
-)
-
-// Execute is the entry point to running the CLI
-func Execute(ctx context.Context, version string) {
-	input := new(Input)
-	rootCmd := &cobra.Command{
-		Use:               "act [event name to run] [flags]\n\nIf no event name passed, will default to \"on: push\"\nIf actions handles only one event it will be used as default instead of \"on: push\"",
-		Short:             "Run GitHub actions locally by specifying the event name (e.g. `push`) or an action name directly.",
-		Args:              cobra.MaximumNArgs(1),
-		RunE:              newRunCommand(ctx, input),
-		PersistentPreRun:  setup(input),
-		PersistentPostRun: cleanup(input),
-		Version:           version,
-		SilenceUsage:      true,
-	}
-	rootCmd.Flags().BoolP("watch", "w", false, "watch the contents of the local repo and run when files change")
-	rootCmd.Flags().BoolP("list", "l", false, "list workflows")
-	rootCmd.Flags().BoolP("graph", "g", false, "draw workflows")
-	rootCmd.Flags().StringP("job", "j", "", "run a specific job ID")
-	rootCmd.Flags().BoolP("bug-report", "", false, "Display system information for bug report")
-
-	rootCmd.Flags().StringVar(&input.remoteName, "remote-name", "origin", "git remote name that will be used to retrieve url of git repo")
-	rootCmd.Flags().StringArrayVarP(&input.secrets, "secret", "s", []string{}, "secret to make available to actions with optional value (e.g. -s mysecret=foo or -s mysecret)")
-	rootCmd.Flags().StringArrayVar(&input.vars, "var", []string{}, "variable to make available to actions with optional value (e.g. --var myvar=foo or --var myvar)")
-	rootCmd.Flags().StringArrayVarP(&input.envs, "env", "", []string{}, "env to make available to actions with optional value (e.g. --env myenv=foo or --env myenv)")
-	rootCmd.Flags().StringArrayVarP(&input.inputs, "input", "", []string{}, "action input to make available to actions (e.g. --input myinput=foo)")
-	rootCmd.Flags().StringArrayVarP(&input.platforms, "platform", "P", []string{}, "custom image to use per platform (e.g. -P ubuntu-18.04=nektos/act-environments-ubuntu:18.04)")
-	rootCmd.Flags().BoolVarP(&input.reuseContainers, "reuse", "r", false, "don't remove container(s) on successfully completed workflow(s) to maintain state between runs")
-	rootCmd.Flags().BoolVarP(&input.bindWorkdir, "bind", "b", false, "bind working directory to container, rather than copy")
-	rootCmd.Flags().BoolVarP(&input.forcePull, "pull", "p", true, "pull docker image(s) even if already present")
-	rootCmd.Flags().BoolVarP(&input.forceRebuild, "rebuild", "", true, "rebuild local action docker image(s) even if already present")
-	rootCmd.Flags().BoolVarP(&input.autodetectEvent, "detect-event", "", false, "Use first event type from workflow as event that triggered the workflow")
-	rootCmd.Flags().StringVarP(&input.eventPath, "eventpath", "e", "", "path to event JSON file")
-	rootCmd.Flags().StringVar(&input.defaultBranch, "defaultbranch", "", "the name of the main branch")
-	rootCmd.Flags().BoolVar(&input.privileged, "privileged", false, "use privileged mode")
-	rootCmd.Flags().StringVar(&input.usernsMode, "userns", "", "user namespace to use")
-	rootCmd.Flags().BoolVar(&input.useGitIgnore, "use-gitignore", true, "Controls whether paths specified in .gitignore should be copied into container")
-	rootCmd.Flags().StringArrayVarP(&input.containerCapAdd, "container-cap-add", "", []string{}, "kernel capabilities to add to the workflow containers (e.g. --container-cap-add SYS_PTRACE)")
-	rootCmd.Flags().StringArrayVarP(&input.containerCapDrop, "container-cap-drop", "", []string{}, "kernel capabilities to remove from the workflow containers (e.g. --container-cap-drop SYS_PTRACE)")
-	rootCmd.Flags().BoolVar(&input.autoRemove, "rm", false, "automatically remove container(s)/volume(s) after a workflow(s) failure")
-	rootCmd.Flags().StringArrayVarP(&input.replaceGheActionWithGithubCom, "replace-ghe-action-with-github-com", "", []string{}, "If you are using GitHub Enterprise Server and allow specified actions from GitHub (github.com), you can set actions on this. (e.g. --replace-ghe-action-with-github-com =github/super-linter)")
-	rootCmd.Flags().StringVar(&input.replaceGheActionTokenWithGithubCom, "replace-ghe-action-token-with-github-com", "", "If you are using replace-ghe-action-with-github-com  and you want to use private actions on GitHub, you have to set personal access token")
-	rootCmd.Flags().StringArrayVarP(&input.matrix, "matrix", "", []string{}, "specify which matrix configuration to include (e.g. --matrix java:13")
-	rootCmd.PersistentFlags().StringVarP(&input.actor, "actor", "a", "nektos/act", "user that triggered the event")
-	rootCmd.PersistentFlags().StringVarP(&input.workflowsPath, "workflows", "W", "./.github/workflows/", "path to workflow file(s)")
-	rootCmd.PersistentFlags().BoolVarP(&input.noWorkflowRecurse, "no-recurse", "", false, "Flag to disable running workflows from subdirectories of specified path in '--workflows'/'-W' flag")
-	rootCmd.PersistentFlags().StringVarP(&input.workdir, "directory", "C", ".", "working directory")
-	rootCmd.PersistentFlags().BoolP("verbose", "v", false, "verbose output")
-	rootCmd.PersistentFlags().BoolVar(&input.jsonLogger, "json", false, "Output logs in json format")
-	rootCmd.PersistentFlags().BoolVar(&input.logPrefixJobID, "log-prefix-job-id", false, "Output the job id within non-json logs instead of the entire name")
-	rootCmd.PersistentFlags().BoolVarP(&input.noOutput, "quiet", "q", false, "disable logging of output from steps")
-	rootCmd.PersistentFlags().BoolVarP(&input.dryrun, "dryrun", "n", false, "dryrun mode")
-	rootCmd.PersistentFlags().StringVarP(&input.secretfile, "secret-file", "", ".secrets", "file with list of secrets to read from (e.g. --secret-file .secrets)")
-	rootCmd.PersistentFlags().StringVarP(&input.varfile, "var-file", "", ".vars", "file with list of vars to read from (e.g. --var-file .vars)")
-	rootCmd.PersistentFlags().BoolVarP(&input.insecureSecrets, "insecure-secrets", "", false, "NOT RECOMMENDED! Doesn't hide secrets while printing logs.")
-	rootCmd.PersistentFlags().StringVarP(&input.envfile, "env-file", "", ".env", "environment file to read and use as env in the containers")
-	rootCmd.PersistentFlags().StringVarP(&input.inputfile, "input-file", "", ".input", "input file to read and use as action input")
-	rootCmd.PersistentFlags().StringVarP(&input.containerArchitecture, "container-architecture", "", "", "Architecture which should be used to run containers, e.g.: linux/amd64. If not specified, will use host default architecture. Requires Docker server API Version 1.41+. Ignored on earlier Docker server platforms.")
-	rootCmd.PersistentFlags().StringVarP(&input.containerDaemonSocket, "container-daemon-socket", "", "", "URI to Docker Engine socket (e.g.: unix://~/.docker/run/docker.sock or - to disable bind mounting the socket)")
-	rootCmd.PersistentFlags().StringVarP(&input.containerOptions, "container-options", "", "", "Custom docker container options for the job container without an options property in the job definition")
-	rootCmd.PersistentFlags().StringVarP(&input.githubInstance, "github-instance", "", "github.com", "GitHub instance to use. Don't use this if you are not using GitHub Enterprise Server.")
-	rootCmd.PersistentFlags().StringVarP(&input.artifactServerPath, "artifact-server-path", "", "", "Defines the path where the artifact server stores uploads and retrieves downloads from. If not specified the artifact server will not start.")
-	rootCmd.PersistentFlags().StringVarP(&input.artifactServerAddr, "artifact-server-addr", "", common.GetOutboundIP().String(), "Defines the address to which the artifact server binds.")
-	rootCmd.PersistentFlags().StringVarP(&input.artifactServerPort, "artifact-server-port", "", "34567", "Defines the port where the artifact server listens.")
-	rootCmd.PersistentFlags().BoolVarP(&input.noSkipCheckout, "no-skip-checkout", "", false, "Do not skip actions/checkout")
-	rootCmd.PersistentFlags().BoolVarP(&input.noCacheServer, "no-cache-server", "", false, "Disable cache server")
-	rootCmd.PersistentFlags().StringVarP(&input.cacheServerPath, "cache-server-path", "", filepath.Join(CacheHomeDir, "actcache"), "Defines the path where the cache server stores caches.")
-	rootCmd.PersistentFlags().StringVarP(&input.cacheServerAddr, "cache-server-addr", "", common.GetOutboundIP().String(), "Defines the address to which the cache server binds.")
-	rootCmd.PersistentFlags().Uint16VarP(&input.cacheServerPort, "cache-server-port", "", 0, "Defines the port where the artifact server listens. 0 means a randomly available port.")
-	rootCmd.PersistentFlags().StringVarP(&input.actionCachePath, "action-cache-path", "", filepath.Join(CacheHomeDir, "act"), "Defines the path where the actions get cached and host workspaces created.")
-	rootCmd.PersistentFlags().BoolVarP(&input.actionOfflineMode, "action-offline-mode", "", false, "If action contents exists, it will not be fetch and pull again. If turn on this,will turn off force pull")
-	rootCmd.PersistentFlags().StringVarP(&input.networkName, "network", "", "host", "Sets a docker network name. Defaults to host.")
-	rootCmd.PersistentFlags().BoolVarP(&input.useNewActionCache, "use-new-action-cache", "", false, "Enable using the new Action Cache for storing Actions locally")
-	rootCmd.PersistentFlags().StringArrayVarP(&input.localRepository, "local-repository", "", []string{}, "Replaces the specified repository and ref with a local folder (e.g. https://github.com/test/test@v0=/home/act/test or test/test@v0=/home/act/test, the latter matches any hosts or protocols)")
-	rootCmd.PersistentFlags().IntVarP(&input.maxParallel, "max-parallel", "", 0, "Limits the number of jobs running in parallel across all workflows (0 = no limit, uses number of CPUs)")
-	rootCmd.SetArgs(args())
-
-	if err := rootCmd.Execute(); err != nil {
-		os.Exit(1)
-	}
-}
-
-// Return locations where Act's config can be found in order: XDG spec, .actrc in HOME directory, .actrc in invocation directory
-func configLocations() []string {
-	configFileName := ".actrc"
-
-	homePath := filepath.Join(UserHomeDir, configFileName)
-	invocationPath := filepath.Join(".", configFileName)
-
-	// Though named xdg, adrg's lib support macOS and Windows config paths as well
-	// It also takes cares of creating the parent folder so we don't need to bother later
-	specPath, err := xdg.ConfigFile("act/actrc")
-	if err != nil {
-		specPath = homePath
-	}
-
-	// This order should be enforced since the survey part relies on it
-	return []string{specPath, homePath, invocationPath}
-}
-
-func args() []string {
-	actrc := configLocations()
-
-	args := make([]string, 0)
-	for _, f := range actrc {
-		args = append(args, readArgsFile(f, true)...)
-	}
-
-	args = append(args, os.Args[1:]...)
-	return args
-}
-
-func bugReport(ctx context.Context, version string) error {
-	sprintf := func(key, val string) string {
-		return fmt.Sprintf("%-24s%s\n", key, val)
-	}
-
-	report := sprintf("act version:", version)
-	report += sprintf("GOOS:", runtime.GOOS)
-	report += sprintf("GOARCH:", runtime.GOARCH)
-	report += sprintf("NumCPU:", fmt.Sprint(runtime.NumCPU()))
-
-	var dockerHost string
-	var exists bool
-	if dockerHost, exists = os.LookupEnv("DOCKER_HOST"); !exists {
-		dockerHost = "DOCKER_HOST environment variable is not set"
-	} else if dockerHost == "" {
-		dockerHost = "DOCKER_HOST environment variable is empty."
-	}
-
-	report += sprintf("Docker host:", dockerHost)
-	report += fmt.Sprintln("Sockets found:")
-	for _, p := range container.CommonSocketLocations {
-		if _, err := os.Lstat(os.ExpandEnv(p)); err != nil {
-			continue
-		} else if _, err := os.Stat(os.ExpandEnv(p)); err != nil {
-			report += fmt.Sprintf("\t%s(broken)\n", p)
-		} else {
-			report += fmt.Sprintf("\t%s\n", p)
-		}
-	}
-
-	report += sprintf("Config files:", "")
-	for _, c := range configLocations() {
-		args := readArgsFile(c, false)
-		if len(args) > 0 {
-			report += fmt.Sprintf("\t%s:\n", c)
-			for _, l := range args {
-				report += fmt.Sprintf("\t\t%s\n", l)
-			}
-		}
-	}
-
-	vcs, ok := debug.ReadBuildInfo()
-	if ok && vcs != nil {
-		report += fmt.Sprintln("Build info:")
-		vcs := *vcs
-		report += sprintf("\tGo version:", vcs.GoVersion)
-		report += sprintf("\tModule path:", vcs.Path)
-		report += sprintf("\tMain version:", vcs.Main.Version)
-		report += sprintf("\tMain path:", vcs.Main.Path)
-		report += sprintf("\tMain checksum:", vcs.Main.Sum)
-
-		report += fmt.Sprintln("\tBuild settings:")
-		for _, set := range vcs.Settings {
-			report += sprintf(fmt.Sprintf("\t\t%s:", set.Key), set.Value)
-		}
-	}
-
-	info, err := container.GetHostInfo(ctx)
-	if err != nil {
-		fmt.Println(report)
-		return err
-	}
-
-	report += fmt.Sprintln("Docker Engine:")
-
-	report += sprintf("\tEngine version:", info.ServerVersion)
-	report += sprintf("\tEngine runtime:", info.DefaultRuntime)
-	report += sprintf("\tCgroup version:", info.CgroupVersion)
-	report += sprintf("\tCgroup driver:", info.CgroupDriver)
-	report += sprintf("\tStorage driver:", info.Driver)
-	report += sprintf("\tRegistry URI:", info.IndexServerAddress)
-
-	report += sprintf("\tOS:", info.OperatingSystem)
-	report += sprintf("\tOS type:", info.OSType)
-	report += sprintf("\tOS version:", info.OSVersion)
-	report += sprintf("\tOS arch:", info.Architecture)
-	report += sprintf("\tOS kernel:", info.KernelVersion)
-	report += sprintf("\tOS CPU:", fmt.Sprint(info.NCPU))
-	report += sprintf("\tOS memory:", fmt.Sprintf("%d MB", info.MemTotal/1024/1024))
-
-	report += fmt.Sprintln("\tSecurity options:")
-	for _, secopt := range info.SecurityOptions {
-		report += fmt.Sprintf("\t\t%s\n", secopt)
-	}
-
-	fmt.Println(report)
-	return nil
-}
-
-func readArgsFile(file string, split bool) []string {
-	args := make([]string, 0)
-	f, err := os.Open(file)
-	if err != nil {
-		return args
-	}
-	defer func() {
-		err := f.Close()
-		if err != nil {
-			log.Errorf("Failed to close args file: %v", err)
-		}
-	}()
-	scanner := bufio.NewScanner(f)
-	for scanner.Scan() {
-		arg := os.ExpandEnv(strings.TrimSpace(scanner.Text()))
-
-		if strings.HasPrefix(arg, "-") && split {
-			args = append(args, regexp.MustCompile(`\s`).Split(arg, 2)...)
-		} else if !split {
-			args = append(args, arg)
-		}
-	}
-	return args
-}
-
-func setup(_ *Input) func(*cobra.Command, []string) {
-	return func(cmd *cobra.Command, _ []string) {
-		verbose, _ := cmd.Flags().GetBool("verbose")
-		if verbose {
-			log.SetLevel(log.DebugLevel)
-		}
-		loadVersionNotices(cmd.Version)
-	}
-}
-
-func cleanup(inputs *Input) func(*cobra.Command, []string) {
-	return func(cmd *cobra.Command, _ []string) {
-		displayNotices(inputs)
-	}
-}
-
-func parseEnvs(env []string) map[string]string {
-	envs := make(map[string]string, len(env))
-	for _, envVar := range env {
-		e := strings.SplitN(envVar, `=`, 2)
-		if len(e) == 2 {
-			envs[e[0]] = e[1]
-		} else {
-			envs[e[0]] = ""
-		}
-	}
-	return envs
-}
-
-func readYamlFile(file string) (map[string]string, error) {
-	content, err := os.ReadFile(file)
-	if err != nil {
-		return nil, err
-	}
-	ret := map[string]string{}
-	if err = yaml.Unmarshal(content, &ret); err != nil {
-		return nil, err
-	}
-	return ret, nil
-}
-
-func readEnvs(path string, envs map[string]string) bool {
-	if _, err := os.Stat(path); err == nil {
-		var env map[string]string
-		if ext := filepath.Ext(path); ext == ".yml" || ext == ".yaml" {
-			env, err = readYamlFile(path)
-		} else {
-			env, err = godotenv.Read(path)
-		}
-		if err != nil {
-			log.Fatalf("Error loading from %s: %v", path, err)
-		}
-		for k, v := range env {
-			envs[k] = v
-		}
-		return true
-	}
-	return false
-}
-
-func parseMatrix(matrix []string) map[string]map[string]bool {
-	// each matrix entry should be of the form - string:string
-	r := regexp.MustCompile(":")
-	matrixes := make(map[string]map[string]bool)
-	for _, m := range matrix {
-		matrix := r.Split(m, 2)
-		if len(matrix) < 2 {
-			log.Fatalf("Invalid matrix format. Failed to parse %s", m)
-		}
-		if _, ok := matrixes[matrix[0]]; !ok {
-			matrixes[matrix[0]] = make(map[string]bool)
-		}
-		matrixes[matrix[0]][matrix[1]] = true
-	}
-	return matrixes
-}
-
-//nolint:gocyclo
-func newRunCommand(ctx context.Context, input *Input) func(*cobra.Command, []string) error {
-	return func(cmd *cobra.Command, args []string) error {
-		if input.jsonLogger {
-			log.SetFormatter(&log.JSONFormatter{})
-		}
-
-		if ok, _ := cmd.Flags().GetBool("bug-report"); ok {
-			return bugReport(ctx, cmd.Version)
-		}
-		if ret, err := container.GetSocketAndHost(input.containerDaemonSocket); err != nil {
-			log.Warnf("Couldn't get a valid docker connection: %+v", err)
-		} else {
-			os.Setenv("DOCKER_HOST", ret.Host)
-			input.containerDaemonSocket = ret.Socket
-			log.Infof("Using docker host '%s', and daemon socket '%s'", ret.Host, ret.Socket)
-		}
-
-		if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && input.containerArchitecture == "" {
-			l := log.New()
-			l.SetFormatter(&log.TextFormatter{
-				DisableQuote:     true,
-				DisableTimestamp: true,
-			})
-			l.Warnf(" \U000026A0 You are using Apple M-series chip and you have not specified container architecture, you might encounter issues while running act. If so, try running it with '--container-architecture linux/amd64'. \U000026A0 \n")
-		}
-
-		log.Debugf("Loading environment from %s", input.Envfile())
-		envs := parseEnvs(input.envs)
-		_ = readEnvs(input.Envfile(), envs)
-
-		log.Debugf("Loading action inputs from %s", input.Inputfile())
-		inputs := parseEnvs(input.inputs)
-		_ = readEnvs(input.Inputfile(), inputs)
-
-		log.Debugf("Loading secrets from %s", input.Secretfile())
-		secrets := newSecrets(input.secrets)
-		_ = readEnvs(input.Secretfile(), secrets)
-
-		log.Debugf("Loading vars from %s", input.Varfile())
-		vars := newSecrets(input.vars)
-		_ = readEnvs(input.Varfile(), vars)
-
-		matrixes := parseMatrix(input.matrix)
-		log.Debugf("Evaluated matrix inclusions: %v", matrixes)
-
-		planner, err := model.NewWorkflowPlanner(input.WorkflowsPath(), input.noWorkflowRecurse)
-		if err != nil {
-			return err
-		}
-
-		jobID, err := cmd.Flags().GetString("job")
-		if err != nil {
-			return err
-		}
-
-		// check if we should just list the workflows
-		list, err := cmd.Flags().GetBool("list")
-		if err != nil {
-			return err
-		}
-
-		// check if we should just draw the graph
-		graph, err := cmd.Flags().GetBool("graph")
-		if err != nil {
-			return err
-		}
-
-		// collect all events from loaded workflows
-		events := planner.GetEvents()
-
-		// plan with filtered jobs - to be used for filtering only
-		var filterPlan *model.Plan
-
-		// Determine the event name to be filtered
-		var filterEventName string
-
-		if len(args) > 0 {
-			log.Debugf("Using first passed in arguments event for filtering: %s", args[0])
-			filterEventName = args[0]
-		} else if input.autodetectEvent && len(events) > 0 && len(events[0]) > 0 {
-			// set default event type to first event from many available
-			// this way user dont have to specify the event.
-			log.Debugf("Using first detected workflow event for filtering: %s", events[0])
-			filterEventName = events[0]
-		}
-
-		var plannerErr error
-		if jobID != "" {
-			log.Debugf("Preparing plan with a job: %s", jobID)
-			filterPlan, plannerErr = planner.PlanJob(jobID)
-		} else if filterEventName != "" {
-			log.Debugf("Preparing plan for a event: %s", filterEventName)
-			filterPlan, plannerErr = planner.PlanEvent(filterEventName)
-		} else {
-			log.Debugf("Preparing plan with all jobs")
-			filterPlan, plannerErr = planner.PlanAll()
-		}
-		if filterPlan == nil && plannerErr != nil {
-			return plannerErr
-		}
-
-		if list {
-			err = printList(filterPlan)
-			if err != nil {
-				return err
-			}
-			return plannerErr
-		}
-
-		if graph {
-			err = drawGraph(filterPlan)
-			if err != nil {
-				return err
-			}
-			return plannerErr
-		}
-
-		// plan with triggered jobs
-		var plan *model.Plan
-
-		// Determine the event name to be triggered
-		var eventName string
-
-		if len(args) > 0 {
-			log.Debugf("Using first passed in arguments event: %s", args[0])
-			eventName = args[0]
-		} else if len(events) == 1 && len(events[0]) > 0 {
-			log.Debugf("Using the only detected workflow event: %s", events[0])
-			eventName = events[0]
-		} else if input.autodetectEvent && len(events) > 0 && len(events[0]) > 0 {
-			// set default event type to first event from many available
-			// this way user dont have to specify the event.
-			log.Debugf("Using first detected workflow event: %s", events[0])
-			eventName = events[0]
-		} else {
-			log.Debugf("Using default workflow event: push")
-			eventName = "push"
-		}
-
-		// build the plan for this run
-		if jobID != "" {
-			log.Debugf("Planning job: %s", jobID)
-			plan, plannerErr = planner.PlanJob(jobID)
-		} else {
-			log.Debugf("Planning jobs for event: %s", eventName)
-			plan, plannerErr = planner.PlanEvent(eventName)
-		}
-		if plan == nil && plannerErr != nil {
-			return plannerErr
-		}
-
-		// check to see if the main branch was defined
-		defaultbranch, err := cmd.Flags().GetString("defaultbranch")
-		if err != nil {
-			return err
-		}
-
-		// Check if platforms flag is set, if not, run default image survey
-		if len(input.platforms) == 0 {
-			cfgFound := false
-			cfgLocations := configLocations()
-			for _, v := range cfgLocations {
-				_, err := os.Stat(v)
-				if os.IsExist(err) {
-					cfgFound = true
-				}
-			}
-			if !cfgFound && len(cfgLocations) > 0 {
-				// The first config location refers to the global config folder one
-				if err := defaultImageSurvey(cfgLocations[0]); err != nil {
-					log.Fatal(err)
-				}
-				input.platforms = readArgsFile(cfgLocations[0], true)
-			}
-		}
-		deprecationWarning := "--%s is deprecated and will be removed soon, please switch to cli: `--container-options \"%[2]s\"` or `.actrc`: `--container-options %[2]s`."
-		if input.privileged {
-			log.Warnf(deprecationWarning, "privileged", "--privileged")
-		}
-		if len(input.usernsMode) > 0 {
-			log.Warnf(deprecationWarning, "userns", fmt.Sprintf("--userns=%s", input.usernsMode))
-		}
-		if len(input.containerCapAdd) > 0 {
-			log.Warnf(deprecationWarning, "container-cap-add", fmt.Sprintf("--cap-add=%s", input.containerCapAdd))
-		}
-		if len(input.containerCapDrop) > 0 {
-			log.Warnf(deprecationWarning, "container-cap-drop", fmt.Sprintf("--cap-drop=%s", input.containerCapDrop))
-		}
-
-		// run the plan
-		config := &runner.Config{
-			Actor:                              input.actor,
-			EventName:                          eventName,
-			EventPath:                          input.EventPath(),
-			DefaultBranch:                      defaultbranch,
-			ForcePull:                          !input.actionOfflineMode && input.forcePull,
-			ForceRebuild:                       input.forceRebuild,
-			ReuseContainers:                    input.reuseContainers,
-			Workdir:                            input.Workdir(),
-			ActionCacheDir:                     input.actionCachePath,
-			ActionOfflineMode:                  input.actionOfflineMode,
-			BindWorkdir:                        input.bindWorkdir,
-			LogOutput:                          !input.noOutput,
-			JSONLogger:                         input.jsonLogger,
-			LogPrefixJobID:                     input.logPrefixJobID,
-			Env:                                envs,
-			Secrets:                            secrets,
-			Vars:                               vars,
-			Inputs:                             inputs,
-			Token:                              secrets["GITHUB_TOKEN"],
-			InsecureSecrets:                    input.insecureSecrets,
-			Platforms:                          input.newPlatforms(),
-			Privileged:                         input.privileged,
-			UsernsMode:                         input.usernsMode,
-			ContainerArchitecture:              input.containerArchitecture,
-			ContainerDaemonSocket:              input.containerDaemonSocket,
-			ContainerOptions:                   input.containerOptions,
-			UseGitIgnore:                       input.useGitIgnore,
-			GitHubInstance:                     input.githubInstance,
-			ContainerCapAdd:                    input.containerCapAdd,
-			ContainerCapDrop:                   input.containerCapDrop,
-			AutoRemove:                         input.autoRemove,
-			ArtifactServerPath:                 input.artifactServerPath,
-			ArtifactServerAddr:                 input.artifactServerAddr,
-			ArtifactServerPort:                 input.artifactServerPort,
-			NoSkipCheckout:                     input.noSkipCheckout,
-			RemoteName:                         input.remoteName,
-			ReplaceGheActionWithGithubCom:      input.replaceGheActionWithGithubCom,
-			ReplaceGheActionTokenWithGithubCom: input.replaceGheActionTokenWithGithubCom,
-			Matrix:                             matrixes,
-			ContainerNetworkMode:               docker_container.NetworkMode(input.networkName),
-			MaxParallel:                        input.maxParallel,
-		}
-		if input.useNewActionCache || len(input.localRepository) > 0 {
-			if input.actionOfflineMode {
-				config.ActionCache = &runner.GoGitActionCacheOfflineMode{
-					Parent: runner.GoGitActionCache{
-						Path: config.ActionCacheDir,
-					},
-				}
-			} else {
-				config.ActionCache = &runner.GoGitActionCache{
-					Path: config.ActionCacheDir,
-				}
-			}
-			if len(input.localRepository) > 0 {
-				localRepositories := map[string]string{}
-				for _, l := range input.localRepository {
-					k, v, _ := strings.Cut(l, "=")
-					localRepositories[k] = v
-				}
-				config.ActionCache = &runner.LocalRepositoryCache{
-					Parent:            config.ActionCache,
-					LocalRepositories: localRepositories,
-					CacheDirCache:     map[string]string{},
-				}
-			}
-		}
-		r, err := runner.New(config)
-		if err != nil {
-			return err
-		}
-
-		cancel := artifacts.Serve(ctx, input.artifactServerPath, input.artifactServerAddr, input.artifactServerPort)
-
-		const cacheURLKey = "ACTIONS_CACHE_URL"
-		var cacheHandler *artifactcache.Handler
-		if !input.noCacheServer && envs[cacheURLKey] == "" {
-			var err error
-			cacheHandler, err = artifactcache.StartHandler(input.cacheServerPath, input.cacheServerAddr, input.cacheServerPort, common.Logger(ctx))
-			if err != nil {
-				return err
-			}
-			envs[cacheURLKey] = cacheHandler.ExternalURL() + "/"
-		}
-
-		ctx = common.WithDryrun(ctx, input.dryrun)
-		if watch, err := cmd.Flags().GetBool("watch"); err != nil {
-			return err
-		} else if watch {
-			err = watchAndRun(ctx, r.NewPlanExecutor(plan))
-			if err != nil {
-				return err
-			}
-			return plannerErr
-		}
-
-		executor := r.NewPlanExecutor(plan).Finally(func(ctx context.Context) error {
-			cancel()
-			_ = cacheHandler.Close()
-			return nil
-		})
-		err = executor(ctx)
-		if err != nil {
-			return err
-		}
-		return plannerErr
-	}
-}
-
-func defaultImageSurvey(actrc string) error {
-	var answer string
-	confirmation := &survey.Select{
-		Message: "Please choose the default image you want to use with act:\n  - Large size image: ca. 17GB download + 53.1GB storage, you will need 75GB of free disk space, snapshots of GitHub Hosted Runners without snap and pulled docker images\n  - Medium size image: ~500MB, includes only necessary tools to bootstrap actions and aims to be compatible with most actions\n  - Micro size image: <200MB, contains only NodeJS required to bootstrap actions, doesn't work with all actions\n\nDefault image and other options can be changed manually in ~/.actrc (please refer to https://github.com/nektos/act#configuration for additional information about file structure)",
-		Help:    "If you want to know why act asks you that, please go to https://github.com/nektos/act/issues/107",
-		Default: "Medium",
-		Options: []string{"Large", "Medium", "Micro"},
-	}
-
-	err := survey.AskOne(confirmation, &answer)
-	if err != nil {
-		return err
-	}
-
-	var option string
-	switch answer {
-	case "Large":
-		option = "-P ubuntu-latest=catthehacker/ubuntu:full-latest\n-P ubuntu-22.04=catthehacker/ubuntu:full-22.04\n-P ubuntu-20.04=catthehacker/ubuntu:full-20.04\n-P ubuntu-18.04=catthehacker/ubuntu:full-18.04\n"
-	case "Medium":
-		option = "-P ubuntu-latest=catthehacker/ubuntu:act-latest\n-P ubuntu-22.04=catthehacker/ubuntu:act-22.04\n-P ubuntu-20.04=catthehacker/ubuntu:act-20.04\n-P ubuntu-18.04=catthehacker/ubuntu:act-18.04\n"
-	case "Micro":
-		option = "-P ubuntu-latest=node:16-buster-slim\n-P ubuntu-22.04=node:16-bullseye-slim\n-P ubuntu-20.04=node:16-buster-slim\n-P ubuntu-18.04=node:16-buster-slim\n"
-	}
-
-	f, err := os.Create(actrc)
-	if err != nil {
-		return err
-	}
-
-	_, err = f.WriteString(option)
-	if err != nil {
-		_ = f.Close()
-		return err
-	}
-
-	err = f.Close()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func watchAndRun(ctx context.Context, fn common.Executor) error {
-	dir, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-
-	ignoreFile := filepath.Join(dir, ".gitignore")
-	ignore := &gitignore.GitIgnore{}
-	if info, err := os.Stat(ignoreFile); err == nil && !info.IsDir() {
-		ignore, err = gitignore.CompileIgnoreFile(ignoreFile)
-		if err != nil {
-			return fmt.Errorf("compile %q: %w", ignoreFile, err)
-		}
-	}
-
-	folderWatcher := fswatch.NewFolderWatcher(
-		dir,
-		true,
-		ignore.MatchesPath,
-		2, // 2 seconds
-	)
-
-	folderWatcher.Start()
-	defer folderWatcher.Stop()
-
-	// run once before watching
-	if err := fn(ctx); err != nil {
-		return err
-	}
-
-	for folderWatcher.IsRunning() {
-		log.Debugf("Watching %s for changes", dir)
-		select {
-		case <-ctx.Done():
-			return nil
-		case changes := <-folderWatcher.ChangeDetails():
-			log.Debugf("%s", changes.String())
-			if err := fn(ctx); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}

cmd/secrets.go

@@ -1,42 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	log "github.com/sirupsen/logrus"
-	"golang.org/x/term"
-)
-
-type secrets map[string]string
-
-func newSecrets(secretList []string) secrets {
-	s := make(map[string]string)
-	for _, secretPair := range secretList {
-		secretPairParts := strings.SplitN(secretPair, "=", 2)
-		secretPairParts[0] = strings.ToUpper(secretPairParts[0])
-		if strings.ToUpper(s[secretPairParts[0]]) == secretPairParts[0] {
-			log.Errorf("Secret %s is already defined (secrets are case insensitive)", secretPairParts[0])
-		}
-		if len(secretPairParts) == 2 {
-			s[secretPairParts[0]] = secretPairParts[1]
-		} else if env, ok := os.LookupEnv(secretPairParts[0]); ok && env != "" {
-			s[secretPairParts[0]] = env
-		} else {
-			fmt.Printf("Provide value for '%s': ", secretPairParts[0])
-			val, err := term.ReadPassword(int(os.Stdin.Fd()))
-			fmt.Println()
-			if err != nil {
-				log.Errorf("failed to read input: %v", err)
-				os.Exit(1)
-			}
-			s[secretPairParts[0]] = string(val)
-		}
-	}
-	return s
-}
-
-func (s secrets) AsMap() map[string]string {
-	return s
-}

codecov.yml

@@ -1,9 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        target: auto # auto compares coverage to the previous base commit
-        threshold: 1%
-    patch:
-      default:
-        target: 50%

config/config.go

@@ -0,0 +1,114 @@
+package config
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+	"runtime"
+	"strconv"
+
+	"gitea.com/gitea/act_runner/core"
+
+	"github.com/joho/godotenv"
+	"github.com/kelseyhightower/envconfig"
+)
+
+type (
+	// Config provides the system configuration.
+	Config struct {
+		Debug    bool `envconfig:"GITEA_DEBUG"`
+		Trace    bool `envconfig:"GITEA_TRACE"`
+		Client   Client
+		Runner   Runner
+		Platform Platform
+	}
+
+	Client struct {
+		Address  string `ignored:"true"`
+		Insecure bool
+	}
+
+	Runner struct {
+		UUID     string            `ignored:"true"`
+		Name     string            `envconfig:"GITEA_RUNNER_NAME"`
+		Token    string            `ignored:"true"`
+		Capacity int               `envconfig:"GITEA_RUNNER_CAPACITY" default:"1"`
+		File     string            `envconfig:"GITEA_RUNNER_FILE" default:".runner"`
+		Environ  map[string]string `envconfig:"GITEA_RUNNER_ENVIRON"`
+		EnvFile  string            `envconfig:"GITEA_RUNNER_ENV_FILE"`
+		Labels   []string          `envconfig:"GITEA_RUNNER_LABELS"`
+	}
+
+	Platform struct {
+		OS   string `envconfig:"GITEA_PLATFORM_OS"`
+		Arch string `envconfig:"GITEA_PLATFORM_ARCH"`
+	}
+)
+
+// FromEnviron returns the settings from the environment.
+func FromEnviron() (Config, error) {
+	cfg := Config{}
+	if err := envconfig.Process("", &cfg); err != nil {
+		return cfg, err
+	}
+
+	// check runner config exist
+	f, err := os.Stat(cfg.Runner.File)
+	if err == nil && !f.IsDir() {
+		jsonFile, _ := os.Open(cfg.Runner.File)
+		defer jsonFile.Close()
+		byteValue, _ := io.ReadAll(jsonFile)
+		var runner core.Runner
+		if err := json.Unmarshal(byteValue, &runner); err != nil {
+			return cfg, err
+		}
+		if runner.UUID != "" {
+			cfg.Runner.UUID = runner.UUID
+		}
+		if runner.Token != "" {
+			cfg.Runner.Token = runner.Token
+		}
+		if len(runner.Labels) != 0 {
+			cfg.Runner.Labels = runner.Labels
+		}
+		if runner.Address != "" {
+			cfg.Client.Address = runner.Address
+		}
+		if runner.Insecure != "" {
+			cfg.Client.Insecure, _ = strconv.ParseBool(runner.Insecure)
+		}
+	} else if err != nil {
+		return cfg, err
+	}
+
+	// runner config
+	if cfg.Runner.Environ == nil {
+		cfg.Runner.Environ = map[string]string{
+			"GITHUB_API_URL":    cfg.Client.Address + "/api/v1",
+			"GITHUB_SERVER_URL": cfg.Client.Address,
+		}
+	}
+	if cfg.Runner.Name == "" {
+		cfg.Runner.Name, _ = os.Hostname()
+	}
+
+	// platform config
+	if cfg.Platform.OS == "" {
+		cfg.Platform.OS = runtime.GOOS
+	}
+	if cfg.Platform.Arch == "" {
+		cfg.Platform.Arch = runtime.GOARCH
+	}
+
+	if file := cfg.Runner.EnvFile; file != "" {
+		envs, err := godotenv.Read(file)
+		if err != nil {
+			return cfg, err
+		}
+		for k, v := range envs {
+			cfg.Runner.Environ[k] = v
+		}
+	}
+
+	return cfg, nil
+}

core/runner.go

@@ -0,0 +1,17 @@
+package core
+
+const (
+	UUIDHeader  = "x-runner-uuid"
+	TokenHeader = "x-runner-token"
+)
+
+// Runner struct
+type Runner struct {
+	ID       int64    `json:"id"`
+	UUID     string   `json:"uuid"`
+	Name     string   `json:"name"`
+	Token    string   `json:"token"`
+	Address  string   `json:"address"`
+	Insecure string   `json:"insecure"`
+	Labels   []string `json:"labels"`
+}

engine/docker.go

@@ -0,0 +1,37 @@
+package engine
+
+import (
+	"context"
+
+	"github.com/docker/docker/client"
+)
+
+type Docker struct {
+	client   client.APIClient
+	hidePull bool
+}
+
+func New(opts ...Option) (*Docker, error) {
+	cli, err := client.NewClientWithOpts(client.FromEnv)
+	if err != nil {
+		return nil, err
+	}
+
+	srv := &Docker{
+		client: cli,
+	}
+
+	// Loop through each option
+	for _, opt := range opts {
+		// Call the option giving the instantiated
+		opt.Apply(srv)
+	}
+
+	return srv, nil
+}
+
+// Ping pings the Docker daemon.
+func (e *Docker) Ping(ctx context.Context) error {
+	_, err := e.client.Ping(ctx)
+	return err
+}

engine/engine.go

@@ -0,0 +1,43 @@
+package engine
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// Start start docker engine api loop
+func Start(ctx context.Context) error {
+	engine, err := New()
+	if err != nil {
+		return err
+	}
+
+	count := 0
+	for {
+		err := engine.Ping(ctx)
+		if err == context.Canceled {
+			break
+		}
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+		if err != nil {
+			log.WithError(err).
+				Errorln("cannot ping the docker daemon")
+			count++
+			if count == 5 {
+				return fmt.Errorf("retry connect to docker daemon failed: %d times", count)
+			}
+			time.Sleep(time.Second)
+		} else {
+			log.Infoln("successfully ping the docker daemon")
+			break
+		}
+	}
+	return nil
+}

engine/options.go

@@ -0,0 +1,30 @@
+package engine
+
+import "github.com/docker/docker/client"
+
+// An Option configures a mutex.
+type Option interface {
+	Apply(*Docker)
+}
+
+// OptionFunc is a function that configure a value.
+type OptionFunc func(*Docker)
+
+// Apply calls f(option)
+func (f OptionFunc) Apply(docker *Docker) {
+	f(docker)
+}
+
+// WithClient set custom client
+func WithClient(c client.APIClient) Option {
+	return OptionFunc(func(q *Docker) {
+		q.client = c
+	})
+}
+
+// WithHidePull hide pull event.
+func WithHidePull(v bool) Option {
+	return OptionFunc(func(q *Docker) {
+		q.hidePull = v
+	})
+}

go.mod

@@ -1,92 +1,80 @@
-module github.com/nektos/act
+module gitea.com/gitea/act_runner
 
-go 1.20
+go 1.18
 
 require (
-	github.com/AlecAivazis/survey/v2 v2.3.7
-	github.com/Masterminds/semver v1.5.0
-	github.com/adrg/xdg v0.4.0
-	github.com/andreaskoch/go-fswatch v1.0.0
-	github.com/creack/pty v1.1.21
-	github.com/docker/cli v24.0.7+incompatible
-	github.com/docker/distribution v2.8.3+incompatible
-	github.com/docker/docker v24.0.9+incompatible // 24.0 branch
-	github.com/docker/go-connections v0.4.0
-	github.com/go-git/go-billy/v5 v5.5.0
-	github.com/go-git/go-git/v5 v5.11.0
-	github.com/gobwas/glob v0.2.3
-	github.com/imdario/mergo v0.3.16
-	github.com/joho/godotenv v1.5.1
-	github.com/julienschmidt/httprouter v1.3.0
-	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51
-	github.com/mattn/go-isatty v0.0.20
-	github.com/moby/buildkit v0.12.5
-	github.com/moby/patternmatcher v0.6.0
-	github.com/opencontainers/image-spec v1.1.0
-	github.com/opencontainers/selinux v1.11.0
-	github.com/pkg/errors v0.9.1
-	github.com/rhysd/actionlint v1.6.27
-	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
-	github.com/sirupsen/logrus v1.9.3
-	github.com/spf13/cobra v1.8.0
-	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.9.0
-	github.com/timshannon/bolthold v0.0.0-20210913165410-232392fc8a6a
-	go.etcd.io/bbolt v1.3.9
-	go.yaml.in/yaml/v4 v4.0.0-rc.2
-	golang.org/x/term v0.18.0
-	gotest.tools/v3 v3.5.1
+	code.gitea.io/actions-proto-go v0.2.0
+	github.com/avast/retry-go/v4 v4.3.1
+	github.com/bufbuild/connect-go v1.3.1
+	github.com/docker/docker v20.10.21+incompatible
+	github.com/joho/godotenv v1.4.0
+	github.com/kelseyhightower/envconfig v1.4.0
+	github.com/mattn/go-isatty v0.0.16
+	github.com/nektos/act v0.0.0
+	github.com/sirupsen/logrus v1.9.0
+	github.com/spf13/cobra v1.6.1
+	golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde
+	google.golang.org/protobuf v1.28.1
 )
 
 require (
-	dario.cat/mergo v1.0.0 // indirect
-	github.com/Microsoft/go-winio v0.6.1 // indirect
-	github.com/ProtonMail/go-crypto v0.0.0-20230828082145-3c4c8a2d2371 // indirect
-	github.com/cloudflare/circl v1.3.7 // indirect
-	github.com/containerd/containerd v1.7.2 // indirect
-	github.com/cyphar/filepath-securejoin v0.2.4 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/distribution/reference v0.5.0 // indirect
-	github.com/docker/docker-credential-helpers v0.7.0 // indirect
-	github.com/docker/go-units v0.5.0 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/fatih/color v1.16.0 // indirect
-	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
+	github.com/Masterminds/semver v1.5.0 // indirect
+	github.com/Microsoft/go-winio v0.5.2 // indirect
+	github.com/Microsoft/hcsshim v0.9.3 // indirect
+	github.com/ProtonMail/go-crypto v0.0.0-20220404123522-616f957b79ad // indirect
+	github.com/acomagu/bufpipe v1.0.3 // indirect
+	github.com/containerd/cgroups v1.0.3 // indirect
+	github.com/containerd/containerd v1.6.6 // indirect
+	github.com/creack/pty v1.1.18 // indirect
+	github.com/docker/cli v20.10.21+incompatible // indirect
+	github.com/docker/distribution v2.8.1+incompatible // indirect
+	github.com/docker/docker-credential-helpers v0.6.4 // indirect
+	github.com/docker/go-connections v0.4.0 // indirect
+	github.com/docker/go-units v0.4.0 // indirect
+	github.com/emirpasic/gods v1.12.0 // indirect
+	github.com/fatih/color v1.13.0 // indirect
+	github.com/go-git/gcfg v1.5.0 // indirect
+	github.com/go-git/go-billy/v5 v5.3.1 // indirect
+	github.com/go-git/go-git/v5 v5.4.2 // indirect
+	github.com/go-ini/ini v1.67.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/imdario/mergo v0.3.13 // indirect
+	github.com/inconshreveable/mousetrap v1.0.1 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/julienschmidt/httprouter v1.3.0 // indirect
+	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/kevinburke/ssh_config v1.2.0 // indirect
-	github.com/klauspost/compress v1.17.2 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
-	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
+	github.com/mattn/go-runewidth v0.0.13 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.1.2 // indirect
-	github.com/moby/sys/sequential v0.5.0 // indirect
-	github.com/moby/term v0.0.0-20200312100748-672ec06f55cd // indirect
+	github.com/moby/buildkit v0.10.6 // indirect
+	github.com/moby/sys/mount v0.3.1 // indirect
+	github.com/moby/sys/mountinfo v0.6.0 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/runc v1.1.12 // indirect
-	github.com/pjbgf/sha1cd v0.3.0 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/opencontainers/image-spec v1.0.3-0.20211202183452-c5a74bcca799 // indirect
+	github.com/opencontainers/runc v1.1.2 // indirect
+	github.com/opencontainers/selinux v1.10.2 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rhysd/actionlint v1.6.22 // indirect
+	github.com/rivo/uniseg v0.3.4 // indirect
+	github.com/robfig/cron v1.2.0 // indirect
 	github.com/sergi/go-diff v1.2.0 // indirect
-	github.com/skeema/knownhosts v1.2.1 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
-	github.com/xanzy/ssh-agent v0.3.3 // indirect
-	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/xanzy/ssh-agent v0.3.1 // indirect
+	github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
-	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
-	golang.org/x/crypto v0.17.0 // indirect
-	golang.org/x/mod v0.12.0 // indirect
-	golang.org/x/net v0.19.0 // indirect
-	golang.org/x/sync v0.6.0 // indirect
-	golang.org/x/sys v0.18.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	golang.org/x/tools v0.13.0 // indirect
+	github.com/xeipuuv/gojsonschema v0.0.0-20180618132009-1d523034197f // indirect
+	go.opencensus.io v0.23.0 // indirect
+	golang.org/x/crypto v0.0.0-20220331220935-ae2d96664a29 // indirect
+	golang.org/x/net v0.0.0-20220906165146-f3363e06e74c // indirect
+	golang.org/x/sys v0.0.0-20220818161305-2296e01440c6 // indirect
+	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
+
+replace github.com/nektos/act => gitea.com/gitea/act v0.234.3-0.20230224062034-1252e551b867

install.sh

@@ -1,401 +0,0 @@
-#!/bin/sh
-set -e
-# Code generated by godownloader on 2021-12-22T16:10:52Z. DO NOT EDIT.
-#
-
-usage() {
-  this=$1
-  cat <<EOF
-$this: download go binaries for nektos/act
-
-Usage: $this [-b] bindir [-d] [tag]
-  -b sets bindir or installation directory, Defaults to ./bin
-  -d turns on debug logging
-   [tag] is a tag from
-   https://github.com/nektos/act/releases
-   If tag is missing, then the latest will be used.
-
- Generated by godownloader
-  https://github.com/goreleaser/godownloader
-
-EOF
-  exit 2
-}
-
-parse_args() {
-  #BINDIR is ./bin unless set be ENV
-  # over-ridden by flag below
-
-  BINDIR=${BINDIR:-./bin}
-  while getopts "b:dh?x" arg; do
-    case "$arg" in
-      b) BINDIR="$OPTARG" ;;
-      d) log_set_priority 10 ;;
-      h | \?) usage "$0" ;;
-      x) set -x ;;
-    esac
-  done
-  shift $((OPTIND - 1))
-  TAG=$1
-}
-# this function wraps all the destructive operations
-# if a curl|bash cuts off the end of the script due to
-# network, either nothing will happen or will syntax error
-# out preventing half-done work
-execute() {
-  tmpdir=$(mktemp -d)
-  log_debug "downloading files into ${tmpdir}"
-  http_download "${tmpdir}/${TARBALL}" "${TARBALL_URL}"
-  http_download "${tmpdir}/${CHECKSUM}" "${CHECKSUM_URL}"
-  hash_sha256_verify "${tmpdir}/${TARBALL}" "${tmpdir}/${CHECKSUM}"
-  srcdir="${tmpdir}"
-  (cd "${tmpdir}" && untar "${TARBALL}")
-  test ! -d "${BINDIR}" && install -d "${BINDIR}"
-  for binexe in $BINARIES; do
-    if [ "$OS" = "windows" ]; then
-      binexe="${binexe}.exe"
-    fi
-    install "${srcdir}/${binexe}" "${BINDIR}/"
-    log_info "installed ${BINDIR}/${binexe}"
-  done
-  rm -rf "${tmpdir}"
-}
-get_binaries() {
-  case "$PLATFORM" in
-    darwin/386) BINARIES="act" ;;
-    darwin/amd64) BINARIES="act" ;;
-    darwin/arm64) BINARIES="act" ;;
-    darwin/armv6) BINARIES="act" ;;
-    darwin/armv7) BINARIES="act" ;;
-    linux/386) BINARIES="act" ;;
-    linux/amd64) BINARIES="act" ;;
-    linux/arm64) BINARIES="act" ;;
-    linux/armv6) BINARIES="act" ;;
-    linux/armv7) BINARIES="act" ;;
-    windows/386) BINARIES="act" ;;
-    windows/amd64) BINARIES="act" ;;
-    windows/arm64) BINARIES="act" ;;
-    windows/armv6) BINARIES="act" ;;
-    windows/armv7) BINARIES="act" ;;
-    *)
-      log_crit "platform $PLATFORM is not supported.  Make sure this script is up-to-date and file request at https://github.com/${PREFIX}/issues/new"
-      exit 1
-      ;;
-  esac
-}
-tag_to_version() {
-  if [ -z "${TAG}" ]; then
-    log_info "checking GitHub for latest tag"
-  else
-    log_info "checking GitHub for tag '${TAG}'"
-  fi
-  REALTAG=$(github_release "$OWNER/$REPO" "${TAG}") && true
-  if test -z "$REALTAG"; then
-    log_crit "unable to find '${TAG}' - use 'latest' or see https://github.com/${PREFIX}/releases for details"
-    exit 1
-  fi
-  # if version starts with 'v', remove it
-  TAG="$REALTAG"
-  VERSION=${TAG#v}
-}
-adjust_format() {
-  # change format (tar.gz or zip) based on OS
-  case ${OS} in
-    windows) FORMAT=zip ;;
-  esac
-  true
-}
-adjust_os() {
-  # adjust archive name based on OS
-  case ${OS} in
-    386) OS=i386 ;;
-    amd64) OS=x86_64 ;;
-    darwin) OS=Darwin ;;
-    linux) OS=Linux ;;
-    windows) OS=Windows ;;
-  esac
-  true
-}
-adjust_arch() {
-  # adjust archive name based on ARCH
-  case ${ARCH} in
-    386) ARCH=i386 ;;
-    amd64) ARCH=x86_64 ;;
-    darwin) ARCH=Darwin ;;
-    linux) ARCH=Linux ;;
-    windows) ARCH=Windows ;;
-  esac
-  true
-}
-
-cat /dev/null <<EOF
-------------------------------------------------------------------------
-https://github.com/client9/shlib - portable posix shell functions
-Public domain - http://unlicense.org
-https://github.com/client9/shlib/blob/master/LICENSE.md
-but credit (and pull requests) appreciated.
-------------------------------------------------------------------------
-EOF
-is_command() {
-  command -v "$1" >/dev/null
-}
-echoerr() {
-  echo "$@" 1>&2
-}
-log_prefix() {
-  echo "$0"
-}
-_logp=6
-log_set_priority() {
-  _logp="$1"
-}
-log_priority() {
-  if test -z "$1"; then
-    echo "$_logp"
-    return
-  fi
-  [ "$1" -le "$_logp" ]
-}
-log_tag() {
-  case $1 in
-    0) echo "emerg" ;;
-    1) echo "alert" ;;
-    2) echo "crit" ;;
-    3) echo "err" ;;
-    4) echo "warning" ;;
-    5) echo "notice" ;;
-    6) echo "info" ;;
-    7) echo "debug" ;;
-    *) echo "$1" ;;
-  esac
-}
-log_debug() {
-  log_priority 7 || return 0
-  echoerr "$(log_prefix)" "$(log_tag 7)" "$@"
-}
-log_info() {
-  log_priority 6 || return 0
-  echoerr "$(log_prefix)" "$(log_tag 6)" "$@"
-}
-log_err() {
-  log_priority 3 || return 0
-  echoerr "$(log_prefix)" "$(log_tag 3)" "$@"
-}
-log_crit() {
-  log_priority 2 || return 0
-  echoerr "$(log_prefix)" "$(log_tag 2)" "$@"
-}
-uname_os() {
-  os=$(uname -s | tr '[:upper:]' '[:lower:]')
-  case "$os" in
-    cygwin_nt*) os="windows" ;;
-    mingw*) os="windows" ;;
-    msys_nt*) os="windows" ;;
-  esac
-  echo "$os"
-}
-uname_arch() {
-  arch=$(uname -m)
-  case $arch in
-    x86_64) arch="amd64" ;;
-    x86) arch="386" ;;
-    i686) arch="386" ;;
-    i386) arch="386" ;;
-    aarch64) arch="arm64" ;;
-    armv5*) arch="armv5" ;;
-    armv6*) arch="armv6" ;;
-    armv7*) arch="armv7" ;;
-  esac
-  echo ${arch}
-}
-uname_os_check() {
-  os=$(uname_os)
-  case "$os" in
-    darwin) return 0 ;;
-    dragonfly) return 0 ;;
-    freebsd) return 0 ;;
-    linux) return 0 ;;
-    android) return 0 ;;
-    nacl) return 0 ;;
-    netbsd) return 0 ;;
-    openbsd) return 0 ;;
-    plan9) return 0 ;;
-    solaris) return 0 ;;
-    windows) return 0 ;;
-  esac
-  log_crit "uname_os_check '$(uname -s)' got converted to '$os' which is not a GOOS value. Please file bug at https://github.com/client9/shlib"
-  return 1
-}
-uname_arch_check() {
-  arch=$(uname_arch)
-  case "$arch" in
-    386) return 0 ;;
-    amd64) return 0 ;;
-    arm64) return 0 ;;
-    armv5) return 0 ;;
-    armv6) return 0 ;;
-    armv7) return 0 ;;
-    ppc64) return 0 ;;
-    ppc64le) return 0 ;;
-    mips) return 0 ;;
-    mipsle) return 0 ;;
-    mips64) return 0 ;;
-    mips64le) return 0 ;;
-    s390x) return 0 ;;
-    amd64p32) return 0 ;;
-  esac
-  log_crit "uname_arch_check '$(uname -m)' got converted to '$arch' which is not a GOARCH value.  Please file bug report at https://github.com/client9/shlib"
-  return 1
-}
-untar() {
-  tarball=$1
-  case "${tarball}" in
-    *.tar.gz | *.tgz) tar --no-same-owner -xzf "${tarball}" ;;
-    *.tar) tar --no-same-owner -xf "${tarball}" ;;
-    *.zip) unzip "${tarball}" ;;
-    *)
-      log_err "untar unknown archive format for ${tarball}"
-      return 1
-      ;;
-  esac
-}
-http_download_curl() {
-  local_file=$1
-  source_url=$2
-  header=$3
-  if [ -z "$header" ]; then
-    code=$(curl -w '%{http_code}' -sL -o "$local_file" "$source_url")
-  else
-    code=$(curl -w '%{http_code}' -sL -H "$header" -o "$local_file" "$source_url")
-  fi
-  if [ "$code" != "200" ]; then
-    log_debug "http_download_curl received HTTP status $code"
-    return 1
-  fi
-  return 0
-}
-http_download_wget() {
-  local_file=$1
-  source_url=$2
-  header=$3
-  if [ -z "$header" ]; then
-    wget -q -O "$local_file" "$source_url"
-  else
-    wget -q --header "$header" -O "$local_file" "$source_url"
-  fi
-}
-http_download() {
-  log_debug "http_download $2"
-  if is_command curl; then
-    http_download_curl "$@"
-    return
-  elif is_command wget; then
-    http_download_wget "$@"
-    return
-  fi
-  log_crit "http_download unable to find wget or curl"
-  return 1
-}
-http_copy() {
-  tmp=$(mktemp)
-  http_download "${tmp}" "$1" "$2" || return 1
-  body=$(cat "$tmp")
-  rm -f "${tmp}"
-  echo "$body"
-}
-github_release() {
-  owner_repo=$1
-  version=$2
-  test -z "$version" && version="latest"
-  giturl="https://github.com/${owner_repo}/releases/${version}"
-  json=$(http_copy "$giturl" "Accept:application/json")
-  test -z "$json" && return 1
-  version=$(echo "$json" | tr -s '\n' ' ' | sed 's/.*"tag_name":"//' | sed 's/".*//')
-  test -z "$version" && return 1
-  echo "$version"
-}
-hash_sha256() {
-  TARGET=${1:-/dev/stdin}
-  if is_command gsha256sum; then
-    hash=$(gsha256sum "$TARGET") || return 1
-    echo "$hash" | cut -d ' ' -f 1
-  elif is_command sha256sum; then
-    hash=$(sha256sum "$TARGET") || return 1
-    echo "$hash" | cut -d ' ' -f 1
-  elif is_command shasum; then
-    hash=$(shasum -a 256 "$TARGET" 2>/dev/null) || return 1
-    echo "$hash" | cut -d ' ' -f 1
-  elif is_command openssl; then
-    hash=$(openssl -dst openssl dgst -sha256 "$TARGET") || return 1
-    echo "$hash" | cut -d ' ' -f a
-  else
-    log_crit "hash_sha256 unable to find command to compute sha-256 hash"
-    return 1
-  fi
-}
-hash_sha256_verify() {
-  TARGET=$1
-  checksums=$2
-  if [ -z "$checksums" ]; then
-    log_err "hash_sha256_verify checksum file not specified in arg2"
-    return 1
-  fi
-  BASENAME=${TARGET##*/}
-  want=$(grep "${BASENAME}" "${checksums}" 2>/dev/null | tr '\t' ' ' | cut -d ' ' -f 1)
-  if [ -z "$want" ]; then
-    log_err "hash_sha256_verify unable to find checksum for '${TARGET}' in '${checksums}'"
-    return 1
-  fi
-  got=$(hash_sha256 "$TARGET")
-  if [ "$want" != "$got" ]; then
-    log_err "hash_sha256_verify checksum for '$TARGET' did not verify ${want} vs $got"
-    return 1
-  fi
-}
-cat /dev/null <<EOF
-------------------------------------------------------------------------
-End of functions from https://github.com/client9/shlib
-------------------------------------------------------------------------
-EOF
-
-PROJECT_NAME="act"
-OWNER=nektos
-REPO="act"
-BINARY=act
-FORMAT=tar.gz
-OS=$(uname_os)
-ARCH=$(uname_arch)
-PREFIX="$OWNER/$REPO"
-
-# use in logging routines
-log_prefix() {
-	echo "$PREFIX"
-}
-PLATFORM="${OS}/${ARCH}"
-GITHUB_DOWNLOAD=https://github.com/${OWNER}/${REPO}/releases/download
-
-uname_os_check "$OS"
-uname_arch_check "$ARCH"
-
-parse_args "$@"
-
-get_binaries
-
-tag_to_version
-
-adjust_format
-
-adjust_os
-
-adjust_arch
-
-log_info "found version: ${VERSION} for ${TAG}/${OS}/${ARCH}"
-
-NAME=${PROJECT_NAME}_${OS}_${ARCH}
-TARBALL=${NAME}.${FORMAT}
-TARBALL_URL=${GITHUB_DOWNLOAD}/${TAG}/${TARBALL}
-CHECKSUM=checksums.txt
-CHECKSUM_URL=${GITHUB_DOWNLOAD}/${TAG}/${CHECKSUM}
-
-
-execute

main.go

@@ -2,36 +2,33 @@ package main
 
 import (
 	"context"
-	_ "embed"
 	"os"
 	"os/signal"
 	"syscall"
 
-	"github.com/nektos/act/cmd"
+	"gitea.com/gitea/act_runner/cmd"
 )
 
-//go:embed VERSION
-var version string
-
-func main() {
-	ctx := context.Background()
+func withContextFunc(ctx context.Context, f func()) context.Context {
 	ctx, cancel := context.WithCancel(ctx)
-
-	// trap Ctrl+C and call cancel on the context
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
-	defer func() {
-		signal.Stop(c)
-		cancel()
-	}()
 	go func() {
+		c := make(chan os.Signal, 1)
+		signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
+		defer signal.Stop(c)
+
 		select {
+		case <-ctx.Done():
 		case <-c:
 			cancel()
-		case <-ctx.Done():
+			f()
 		}
 	}()
 
+	return ctx
+}
+
+func main() {
+	ctx := withContextFunc(context.Background(), func() {})
 	// run the command
-	cmd.Execute(ctx, version)
+	cmd.Execute(ctx)
 }

pkg/artifactcache/doc.go

@@ -1,8 +0,0 @@
-// Package artifactcache provides a cache handler for the runner.
-//
-// Inspired by https://github.com/sp-ricard-valverde/github-act-cache-server
-//
-// TODO: Authorization
-// TODO: Restrictions for accessing a cache, see https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#restrictions-for-accessing-a-cache
-// TODO: Force deleting cache entries, see https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#force-deleting-cache-entries
-package artifactcache

pkg/artifactcache/handler.go

@@ -1,556 +0,0 @@
-package artifactcache
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"sync/atomic"
-	"time"
-
-	"github.com/julienschmidt/httprouter"
-	"github.com/sirupsen/logrus"
-	"github.com/timshannon/bolthold"
-	"go.etcd.io/bbolt"
-
-	"github.com/nektos/act/pkg/common"
-)
-
-const (
-	urlBase = "/_apis/artifactcache"
-)
-
-type Handler struct {
-	dir      string
-	storage  *Storage
-	router   *httprouter.Router
-	listener net.Listener
-	server   *http.Server
-	logger   logrus.FieldLogger
-
-	gcing atomic.Bool
-	gcAt  time.Time
-
-	outboundIP string
-}
-
-func StartHandler(dir, outboundIP string, port uint16, logger logrus.FieldLogger) (*Handler, error) {
-	h := &Handler{}
-
-	if logger == nil {
-		discard := logrus.New()
-		discard.Out = io.Discard
-		logger = discard
-	}
-	logger = logger.WithField("module", "artifactcache")
-	h.logger = logger
-
-	if dir == "" {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return nil, err
-		}
-		dir = filepath.Join(home, ".cache", "actcache")
-	}
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return nil, err
-	}
-
-	h.dir = dir
-
-	storage, err := NewStorage(filepath.Join(dir, "cache"))
-	if err != nil {
-		return nil, err
-	}
-	h.storage = storage
-
-	if outboundIP != "" {
-		h.outboundIP = outboundIP
-	} else if ip := common.GetOutboundIP(); ip == nil {
-		return nil, fmt.Errorf("unable to determine outbound IP address")
-	} else {
-		h.outboundIP = ip.String()
-	}
-
-	router := httprouter.New()
-	router.GET(urlBase+"/cache", h.middleware(h.find))
-	router.POST(urlBase+"/caches", h.middleware(h.reserve))
-	router.PATCH(urlBase+"/caches/:id", h.middleware(h.upload))
-	router.POST(urlBase+"/caches/:id", h.middleware(h.commit))
-	router.GET(urlBase+"/artifacts/:id", h.middleware(h.get))
-	router.POST(urlBase+"/clean", h.middleware(h.clean))
-
-	h.router = router
-
-	h.gcCache()
-
-	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port)) // listen on all interfaces
-	if err != nil {
-		return nil, err
-	}
-	server := &http.Server{
-		ReadHeaderTimeout: 2 * time.Second,
-		Handler:           router,
-	}
-	go func() {
-		if err := server.Serve(listener); err != nil && errors.Is(err, net.ErrClosed) {
-			logger.Errorf("http serve: %v", err)
-		}
-	}()
-	h.listener = listener
-	h.server = server
-
-	return h, nil
-}
-
-func (h *Handler) ExternalURL() string {
-	// TODO: make the external url configurable if necessary
-	return fmt.Sprintf("http://%s:%d",
-		h.outboundIP,
-		h.listener.Addr().(*net.TCPAddr).Port)
-}
-
-func (h *Handler) Close() error {
-	if h == nil {
-		return nil
-	}
-	var retErr error
-	if h.server != nil {
-		err := h.server.Close()
-		if err != nil {
-			retErr = err
-		}
-		h.server = nil
-	}
-	if h.listener != nil {
-		err := h.listener.Close()
-		if errors.Is(err, net.ErrClosed) {
-			err = nil
-		}
-		if err != nil {
-			retErr = err
-		}
-		h.listener = nil
-	}
-	return retErr
-}
-
-func (h *Handler) openDB() (*bolthold.Store, error) {
-	return bolthold.Open(filepath.Join(h.dir, "bolt.db"), 0o644, &bolthold.Options{
-		Encoder: json.Marshal,
-		Decoder: json.Unmarshal,
-		Options: &bbolt.Options{
-			Timeout:      5 * time.Second,
-			NoGrowSync:   bbolt.DefaultOptions.NoGrowSync,
-			FreelistType: bbolt.DefaultOptions.FreelistType,
-		},
-	})
-}
-
-// GET /_apis/artifactcache/cache
-func (h *Handler) find(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-	keys := strings.Split(r.URL.Query().Get("keys"), ",")
-	// cache keys are case insensitive
-	for i, key := range keys {
-		keys[i] = strings.ToLower(key)
-	}
-	version := r.URL.Query().Get("version")
-
-	db, err := h.openDB()
-	if err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	defer db.Close()
-
-	cache, err := findCache(db, keys, version)
-	if err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	if cache == nil {
-		h.responseJSON(w, r, 204)
-		return
-	}
-
-	if ok, err := h.storage.Exist(cache.ID); err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	} else if !ok {
-		_ = db.Delete(cache.ID, cache)
-		h.responseJSON(w, r, 204)
-		return
-	}
-	h.responseJSON(w, r, 200, map[string]any{
-		"result":          "hit",
-		"archiveLocation": fmt.Sprintf("%s%s/artifacts/%d", h.ExternalURL(), urlBase, cache.ID),
-		"cacheKey":        cache.Key,
-	})
-}
-
-// POST /_apis/artifactcache/caches
-func (h *Handler) reserve(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-	api := &Request{}
-	if err := json.NewDecoder(r.Body).Decode(api); err != nil {
-		h.responseJSON(w, r, 400, err)
-		return
-	}
-	// cache keys are case insensitive
-	api.Key = strings.ToLower(api.Key)
-
-	cache := api.ToCache()
-	db, err := h.openDB()
-	if err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	defer db.Close()
-
-	now := time.Now().Unix()
-	cache.CreatedAt = now
-	cache.UsedAt = now
-	if err := insertCache(db, cache); err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	h.responseJSON(w, r, 200, map[string]any{
-		"cacheId": cache.ID,
-	})
-}
-
-// PATCH /_apis/artifactcache/caches/:id
-func (h *Handler) upload(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
-	id, err := strconv.ParseInt(params.ByName("id"), 10, 64)
-	if err != nil {
-		h.responseJSON(w, r, 400, err)
-		return
-	}
-
-	cache := &Cache{}
-	db, err := h.openDB()
-	if err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	defer db.Close()
-	if err := db.Get(id, cache); err != nil {
-		if errors.Is(err, bolthold.ErrNotFound) {
-			h.responseJSON(w, r, 400, fmt.Errorf("cache %d: not reserved", id))
-			return
-		}
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-
-	if cache.Complete {
-		h.responseJSON(w, r, 400, fmt.Errorf("cache %v %q: already complete", cache.ID, cache.Key))
-		return
-	}
-	db.Close()
-	start, _, err := parseContentRange(r.Header.Get("Content-Range"))
-	if err != nil {
-		h.responseJSON(w, r, 400, err)
-		return
-	}
-	if err := h.storage.Write(cache.ID, start, r.Body); err != nil {
-		h.responseJSON(w, r, 500, err)
-	}
-	h.useCache(id)
-	h.responseJSON(w, r, 200)
-}
-
-// POST /_apis/artifactcache/caches/:id
-func (h *Handler) commit(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
-	id, err := strconv.ParseInt(params.ByName("id"), 10, 64)
-	if err != nil {
-		h.responseJSON(w, r, 400, err)
-		return
-	}
-
-	cache := &Cache{}
-	db, err := h.openDB()
-	if err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	defer db.Close()
-	if err := db.Get(id, cache); err != nil {
-		if errors.Is(err, bolthold.ErrNotFound) {
-			h.responseJSON(w, r, 400, fmt.Errorf("cache %d: not reserved", id))
-			return
-		}
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-
-	if cache.Complete {
-		h.responseJSON(w, r, 400, fmt.Errorf("cache %v %q: already complete", cache.ID, cache.Key))
-		return
-	}
-
-	db.Close()
-
-	size, err := h.storage.Commit(cache.ID, cache.Size)
-	if err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	// write real size back to cache, it may be different from the current value when the request doesn't specify it.
-	cache.Size = size
-
-	db, err = h.openDB()
-	if err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-	defer db.Close()
-
-	cache.Complete = true
-	if err := db.Update(cache.ID, cache); err != nil {
-		h.responseJSON(w, r, 500, err)
-		return
-	}
-
-	h.responseJSON(w, r, 200)
-}
-
-// GET /_apis/artifactcache/artifacts/:id
-func (h *Handler) get(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
-	id, err := strconv.ParseInt(params.ByName("id"), 10, 64)
-	if err != nil {
-		h.responseJSON(w, r, 400, err)
-		return
-	}
-	h.useCache(id)
-	h.storage.Serve(w, r, uint64(id))
-}
-
-// POST /_apis/artifactcache/clean
-func (h *Handler) clean(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
-	// TODO: don't support force deleting cache entries
-	// see: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#force-deleting-cache-entries
-
-	h.responseJSON(w, r, 200)
-}
-
-func (h *Handler) middleware(handler httprouter.Handle) httprouter.Handle {
-	return func(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
-		h.logger.Debugf("%s %s", r.Method, r.RequestURI)
-		handler(w, r, params)
-		go h.gcCache()
-	}
-}
-
-// if not found, return (nil, nil) instead of an error.
-func findCache(db *bolthold.Store, keys []string, version string) (*Cache, error) {
-	cache := &Cache{}
-	for _, prefix := range keys {
-		// if a key in the list matches exactly, don't return partial matches
-		if err := db.FindOne(cache,
-			bolthold.Where("Key").Eq(prefix).
-				And("Version").Eq(version).
-				And("Complete").Eq(true).
-				SortBy("CreatedAt").Reverse()); err == nil || !errors.Is(err, bolthold.ErrNotFound) {
-			if err != nil {
-				return nil, fmt.Errorf("find cache: %w", err)
-			}
-			return cache, nil
-		}
-		prefixPattern := fmt.Sprintf("^%s", regexp.QuoteMeta(prefix))
-		re, err := regexp.Compile(prefixPattern)
-		if err != nil {
-			continue
-		}
-		if err := db.FindOne(cache,
-			bolthold.Where("Key").RegExp(re).
-				And("Version").Eq(version).
-				And("Complete").Eq(true).
-				SortBy("CreatedAt").Reverse()); err != nil {
-			if errors.Is(err, bolthold.ErrNotFound) {
-				continue
-			}
-			return nil, fmt.Errorf("find cache: %w", err)
-		}
-		return cache, nil
-	}
-	return nil, nil
-}
-
-func insertCache(db *bolthold.Store, cache *Cache) error {
-	if err := db.Insert(bolthold.NextSequence(), cache); err != nil {
-		return fmt.Errorf("insert cache: %w", err)
-	}
-	// write back id to db
-	if err := db.Update(cache.ID, cache); err != nil {
-		return fmt.Errorf("write back id to db: %w", err)
-	}
-	return nil
-}
-
-func (h *Handler) useCache(id int64) {
-	db, err := h.openDB()
-	if err != nil {
-		return
-	}
-	defer db.Close()
-	cache := &Cache{}
-	if err := db.Get(id, cache); err != nil {
-		return
-	}
-	cache.UsedAt = time.Now().Unix()
-	_ = db.Update(cache.ID, cache)
-}
-
-const (
-	keepUsed   = 30 * 24 * time.Hour
-	keepUnused = 7 * 24 * time.Hour
-	keepTemp   = 5 * time.Minute
-	keepOld    = 5 * time.Minute
-)
-
-func (h *Handler) gcCache() {
-	if h.gcing.Load() {
-		return
-	}
-	if !h.gcing.CompareAndSwap(false, true) {
-		return
-	}
-	defer h.gcing.Store(false)
-
-	if time.Since(h.gcAt) < time.Hour {
-		h.logger.Debugf("skip gc: %v", h.gcAt.String())
-		return
-	}
-	h.gcAt = time.Now()
-	h.logger.Debugf("gc: %v", h.gcAt.String())
-
-	db, err := h.openDB()
-	if err != nil {
-		return
-	}
-	defer db.Close()
-
-	// Remove the caches which are not completed for a while, they are most likely to be broken.
-	var caches []*Cache
-	if err := db.Find(&caches, bolthold.
-		Where("UsedAt").Lt(time.Now().Add(-keepTemp).Unix()).
-		And("Complete").Eq(false),
-	); err != nil {
-		h.logger.Warnf("find caches: %v", err)
-	} else {
-		for _, cache := range caches {
-			h.storage.Remove(cache.ID)
-			if err := db.Delete(cache.ID, cache); err != nil {
-				h.logger.Warnf("delete cache: %v", err)
-				continue
-			}
-			h.logger.Infof("deleted cache: %+v", cache)
-		}
-	}
-
-	// Remove the old caches which have not been used recently.
-	caches = caches[:0]
-	if err := db.Find(&caches, bolthold.
-		Where("UsedAt").Lt(time.Now().Add(-keepUnused).Unix()),
-	); err != nil {
-		h.logger.Warnf("find caches: %v", err)
-	} else {
-		for _, cache := range caches {
-			h.storage.Remove(cache.ID)
-			if err := db.Delete(cache.ID, cache); err != nil {
-				h.logger.Warnf("delete cache: %v", err)
-				continue
-			}
-			h.logger.Infof("deleted cache: %+v", cache)
-		}
-	}
-
-	// Remove the old caches which are too old.
-	caches = caches[:0]
-	if err := db.Find(&caches, bolthold.
-		Where("CreatedAt").Lt(time.Now().Add(-keepUsed).Unix()),
-	); err != nil {
-		h.logger.Warnf("find caches: %v", err)
-	} else {
-		for _, cache := range caches {
-			h.storage.Remove(cache.ID)
-			if err := db.Delete(cache.ID, cache); err != nil {
-				h.logger.Warnf("delete cache: %v", err)
-				continue
-			}
-			h.logger.Infof("deleted cache: %+v", cache)
-		}
-	}
-
-	// Remove the old caches with the same key and version, keep the latest one.
-	// Also keep the olds which have been used recently for a while in case of the cache is still in use.
-	if results, err := db.FindAggregate(
-		&Cache{},
-		bolthold.Where("Complete").Eq(true),
-		"Key", "Version",
-	); err != nil {
-		h.logger.Warnf("find aggregate caches: %v", err)
-	} else {
-		for _, result := range results {
-			if result.Count() <= 1 {
-				continue
-			}
-			result.Sort("CreatedAt")
-			caches = caches[:0]
-			result.Reduction(&caches)
-			for _, cache := range caches[:len(caches)-1] {
-				if time.Since(time.Unix(cache.UsedAt, 0)) < keepOld {
-					// Keep it since it has been used recently, even if it's old.
-					// Or it could break downloading in process.
-					continue
-				}
-				h.storage.Remove(cache.ID)
-				if err := db.Delete(cache.ID, cache); err != nil {
-					h.logger.Warnf("delete cache: %v", err)
-					continue
-				}
-				h.logger.Infof("deleted cache: %+v", cache)
-			}
-		}
-	}
-}
-
-func (h *Handler) responseJSON(w http.ResponseWriter, r *http.Request, code int, v ...any) {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	var data []byte
-	if len(v) == 0 || v[0] == nil {
-		data, _ = json.Marshal(struct{}{})
-	} else if err, ok := v[0].(error); ok {
-		h.logger.Errorf("%v %v: %v", r.Method, r.RequestURI, err)
-		data, _ = json.Marshal(map[string]any{
-			"error": err.Error(),
-		})
-	} else {
-		data, _ = json.Marshal(v[0])
-	}
-	w.WriteHeader(code)
-	_, _ = w.Write(data)
-}
-
-func parseContentRange(s string) (int64, int64, error) {
-	// support the format like "bytes 11-22/*" only
-	s, _, _ = strings.Cut(strings.TrimPrefix(s, "bytes "), "/")
-	s1, s2, _ := strings.Cut(s, "-")
-
-	start, err := strconv.ParseInt(s1, 10, 64)
-	if err != nil {
-		return 0, 0, fmt.Errorf("parse %q: %w", s, err)
-	}
-	stop, err := strconv.ParseInt(s2, 10, 64)
-	if err != nil {
-		return 0, 0, fmt.Errorf("parse %q: %w", s, err)
-	}
-	return start, stop, nil
-}

pkg/artifactcache/handler_test.go

@@ -1,697 +0,0 @@
-package artifactcache
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/timshannon/bolthold"
-	"go.etcd.io/bbolt"
-)
-
-func TestHandler(t *testing.T) {
-	dir := filepath.Join(t.TempDir(), "artifactcache")
-	handler, err := StartHandler(dir, "", 0, nil)
-	require.NoError(t, err)
-
-	base := fmt.Sprintf("%s%s", handler.ExternalURL(), urlBase)
-
-	defer func() {
-		t.Run("inpect db", func(t *testing.T) {
-			db, err := handler.openDB()
-			require.NoError(t, err)
-			defer db.Close()
-			require.NoError(t, db.Bolt().View(func(tx *bbolt.Tx) error {
-				return tx.Bucket([]byte("Cache")).ForEach(func(k, v []byte) error {
-					t.Logf("%s: %s", k, v)
-					return nil
-				})
-			}))
-		})
-		t.Run("close", func(t *testing.T) {
-			require.NoError(t, handler.Close())
-			assert.Nil(t, handler.server)
-			assert.Nil(t, handler.listener)
-			_, err := http.Post(fmt.Sprintf("%s/caches/%d", base, 1), "", nil)
-			assert.Error(t, err)
-		})
-	}()
-
-	t.Run("get not exist", func(t *testing.T) {
-		key := strings.ToLower(t.Name())
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		resp, err := http.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
-		require.NoError(t, err)
-		require.Equal(t, 204, resp.StatusCode)
-	})
-
-	t.Run("reserve and upload", func(t *testing.T) {
-		key := strings.ToLower(t.Name())
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		content := make([]byte, 100)
-		_, err := rand.Read(content)
-		require.NoError(t, err)
-		uploadCacheNormally(t, base, key, version, content)
-	})
-
-	t.Run("clean", func(t *testing.T) {
-		resp, err := http.Post(fmt.Sprintf("%s/clean", base), "", nil)
-		require.NoError(t, err)
-		assert.Equal(t, 200, resp.StatusCode)
-	})
-
-	t.Run("reserve with bad request", func(t *testing.T) {
-		body := []byte(`invalid json`)
-		require.NoError(t, err)
-		resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-		require.NoError(t, err)
-		assert.Equal(t, 400, resp.StatusCode)
-	})
-
-	t.Run("duplicate reserve", func(t *testing.T) {
-		key := strings.ToLower(t.Name())
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		var first, second struct {
-			CacheID uint64 `json:"cacheId"`
-		}
-		{
-			body, err := json.Marshal(&Request{
-				Key:     key,
-				Version: version,
-				Size:    100,
-			})
-			require.NoError(t, err)
-			resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-
-			require.NoError(t, json.NewDecoder(resp.Body).Decode(&first))
-			assert.NotZero(t, first.CacheID)
-		}
-		{
-			body, err := json.Marshal(&Request{
-				Key:     key,
-				Version: version,
-				Size:    100,
-			})
-			require.NoError(t, err)
-			resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-
-			require.NoError(t, json.NewDecoder(resp.Body).Decode(&second))
-			assert.NotZero(t, second.CacheID)
-		}
-
-		assert.NotEqual(t, first.CacheID, second.CacheID)
-	})
-
-	t.Run("upload with bad id", func(t *testing.T) {
-		req, err := http.NewRequest(http.MethodPatch,
-			fmt.Sprintf("%s/caches/invalid_id", base), bytes.NewReader(nil))
-		require.NoError(t, err)
-		req.Header.Set("Content-Type", "application/octet-stream")
-		req.Header.Set("Content-Range", "bytes 0-99/*")
-		resp, err := http.DefaultClient.Do(req)
-		require.NoError(t, err)
-		assert.Equal(t, 400, resp.StatusCode)
-	})
-
-	t.Run("upload without reserve", func(t *testing.T) {
-		req, err := http.NewRequest(http.MethodPatch,
-			fmt.Sprintf("%s/caches/%d", base, 1000), bytes.NewReader(nil))
-		require.NoError(t, err)
-		req.Header.Set("Content-Type", "application/octet-stream")
-		req.Header.Set("Content-Range", "bytes 0-99/*")
-		resp, err := http.DefaultClient.Do(req)
-		require.NoError(t, err)
-		assert.Equal(t, 400, resp.StatusCode)
-	})
-
-	t.Run("upload with complete", func(t *testing.T) {
-		key := strings.ToLower(t.Name())
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		var id uint64
-		content := make([]byte, 100)
-		_, err := rand.Read(content)
-		require.NoError(t, err)
-		{
-			body, err := json.Marshal(&Request{
-				Key:     key,
-				Version: version,
-				Size:    100,
-			})
-			require.NoError(t, err)
-			resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-
-			got := struct {
-				CacheID uint64 `json:"cacheId"`
-			}{}
-			require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-			id = got.CacheID
-		}
-		{
-			req, err := http.NewRequest(http.MethodPatch,
-				fmt.Sprintf("%s/caches/%d", base, id), bytes.NewReader(content))
-			require.NoError(t, err)
-			req.Header.Set("Content-Type", "application/octet-stream")
-			req.Header.Set("Content-Range", "bytes 0-99/*")
-			resp, err := http.DefaultClient.Do(req)
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-		}
-		{
-			resp, err := http.Post(fmt.Sprintf("%s/caches/%d", base, id), "", nil)
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-		}
-		{
-			req, err := http.NewRequest(http.MethodPatch,
-				fmt.Sprintf("%s/caches/%d", base, id), bytes.NewReader(content))
-			require.NoError(t, err)
-			req.Header.Set("Content-Type", "application/octet-stream")
-			req.Header.Set("Content-Range", "bytes 0-99/*")
-			resp, err := http.DefaultClient.Do(req)
-			require.NoError(t, err)
-			assert.Equal(t, 400, resp.StatusCode)
-		}
-	})
-
-	t.Run("upload with invalid range", func(t *testing.T) {
-		key := strings.ToLower(t.Name())
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		var id uint64
-		content := make([]byte, 100)
-		_, err := rand.Read(content)
-		require.NoError(t, err)
-		{
-			body, err := json.Marshal(&Request{
-				Key:     key,
-				Version: version,
-				Size:    100,
-			})
-			require.NoError(t, err)
-			resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-
-			got := struct {
-				CacheID uint64 `json:"cacheId"`
-			}{}
-			require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-			id = got.CacheID
-		}
-		{
-			req, err := http.NewRequest(http.MethodPatch,
-				fmt.Sprintf("%s/caches/%d", base, id), bytes.NewReader(content))
-			require.NoError(t, err)
-			req.Header.Set("Content-Type", "application/octet-stream")
-			req.Header.Set("Content-Range", "bytes xx-99/*")
-			resp, err := http.DefaultClient.Do(req)
-			require.NoError(t, err)
-			assert.Equal(t, 400, resp.StatusCode)
-		}
-	})
-
-	t.Run("commit with bad id", func(t *testing.T) {
-		{
-			resp, err := http.Post(fmt.Sprintf("%s/caches/invalid_id", base), "", nil)
-			require.NoError(t, err)
-			assert.Equal(t, 400, resp.StatusCode)
-		}
-	})
-
-	t.Run("commit with not exist id", func(t *testing.T) {
-		{
-			resp, err := http.Post(fmt.Sprintf("%s/caches/%d", base, 100), "", nil)
-			require.NoError(t, err)
-			assert.Equal(t, 400, resp.StatusCode)
-		}
-	})
-
-	t.Run("duplicate commit", func(t *testing.T) {
-		key := strings.ToLower(t.Name())
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		var id uint64
-		content := make([]byte, 100)
-		_, err := rand.Read(content)
-		require.NoError(t, err)
-		{
-			body, err := json.Marshal(&Request{
-				Key:     key,
-				Version: version,
-				Size:    100,
-			})
-			require.NoError(t, err)
-			resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-
-			got := struct {
-				CacheID uint64 `json:"cacheId"`
-			}{}
-			require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-			id = got.CacheID
-		}
-		{
-			req, err := http.NewRequest(http.MethodPatch,
-				fmt.Sprintf("%s/caches/%d", base, id), bytes.NewReader(content))
-			require.NoError(t, err)
-			req.Header.Set("Content-Type", "application/octet-stream")
-			req.Header.Set("Content-Range", "bytes 0-99/*")
-			resp, err := http.DefaultClient.Do(req)
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-		}
-		{
-			resp, err := http.Post(fmt.Sprintf("%s/caches/%d", base, id), "", nil)
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-		}
-		{
-			resp, err := http.Post(fmt.Sprintf("%s/caches/%d", base, id), "", nil)
-			require.NoError(t, err)
-			assert.Equal(t, 400, resp.StatusCode)
-		}
-	})
-
-	t.Run("commit early", func(t *testing.T) {
-		key := strings.ToLower(t.Name())
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		var id uint64
-		content := make([]byte, 100)
-		_, err := rand.Read(content)
-		require.NoError(t, err)
-		{
-			body, err := json.Marshal(&Request{
-				Key:     key,
-				Version: version,
-				Size:    100,
-			})
-			require.NoError(t, err)
-			resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-
-			got := struct {
-				CacheID uint64 `json:"cacheId"`
-			}{}
-			require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-			id = got.CacheID
-		}
-		{
-			req, err := http.NewRequest(http.MethodPatch,
-				fmt.Sprintf("%s/caches/%d", base, id), bytes.NewReader(content[:50]))
-			require.NoError(t, err)
-			req.Header.Set("Content-Type", "application/octet-stream")
-			req.Header.Set("Content-Range", "bytes 0-59/*")
-			resp, err := http.DefaultClient.Do(req)
-			require.NoError(t, err)
-			assert.Equal(t, 200, resp.StatusCode)
-		}
-		{
-			resp, err := http.Post(fmt.Sprintf("%s/caches/%d", base, id), "", nil)
-			require.NoError(t, err)
-			assert.Equal(t, 500, resp.StatusCode)
-		}
-	})
-
-	t.Run("get with bad id", func(t *testing.T) {
-		resp, err := http.Get(fmt.Sprintf("%s/artifacts/invalid_id", base))
-		require.NoError(t, err)
-		require.Equal(t, 400, resp.StatusCode)
-	})
-
-	t.Run("get with not exist id", func(t *testing.T) {
-		resp, err := http.Get(fmt.Sprintf("%s/artifacts/%d", base, 100))
-		require.NoError(t, err)
-		require.Equal(t, 404, resp.StatusCode)
-	})
-
-	t.Run("get with not exist id", func(t *testing.T) {
-		resp, err := http.Get(fmt.Sprintf("%s/artifacts/%d", base, 100))
-		require.NoError(t, err)
-		require.Equal(t, 404, resp.StatusCode)
-	})
-
-	t.Run("get with multiple keys", func(t *testing.T) {
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		key := strings.ToLower(t.Name())
-		keys := [3]string{
-			key + "_a_b_c",
-			key + "_a_b",
-			key + "_a",
-		}
-		contents := [3][]byte{
-			make([]byte, 100),
-			make([]byte, 200),
-			make([]byte, 300),
-		}
-		for i := range contents {
-			_, err := rand.Read(contents[i])
-			require.NoError(t, err)
-			uploadCacheNormally(t, base, keys[i], version, contents[i])
-			time.Sleep(time.Second) // ensure CreatedAt of caches are different
-		}
-
-		reqKeys := strings.Join([]string{
-			key + "_a_b_x",
-			key + "_a_b",
-			key + "_a",
-		}, ",")
-
-		resp, err := http.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, reqKeys, version))
-		require.NoError(t, err)
-		require.Equal(t, 200, resp.StatusCode)
-
-		/*
-			Expect `key_a_b` because:
-			- `key_a_b_x" doesn't match any caches.
-			- `key_a_b" matches `key_a_b` and `key_a_b_c`, but `key_a_b` is newer.
-		*/
-		except := 1
-
-		got := struct {
-			Result          string `json:"result"`
-			ArchiveLocation string `json:"archiveLocation"`
-			CacheKey        string `json:"cacheKey"`
-		}{}
-		require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-		assert.Equal(t, "hit", got.Result)
-		assert.Equal(t, keys[except], got.CacheKey)
-
-		contentResp, err := http.Get(got.ArchiveLocation)
-		require.NoError(t, err)
-		require.Equal(t, 200, contentResp.StatusCode)
-		content, err := io.ReadAll(contentResp.Body)
-		require.NoError(t, err)
-		assert.Equal(t, contents[except], content)
-	})
-
-	t.Run("case insensitive", func(t *testing.T) {
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		key := strings.ToLower(t.Name())
-		content := make([]byte, 100)
-		_, err := rand.Read(content)
-		require.NoError(t, err)
-		uploadCacheNormally(t, base, key+"_ABC", version, content)
-
-		{
-			reqKey := key + "_aBc"
-			resp, err := http.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, reqKey, version))
-			require.NoError(t, err)
-			require.Equal(t, 200, resp.StatusCode)
-			got := struct {
-				Result          string `json:"result"`
-				ArchiveLocation string `json:"archiveLocation"`
-				CacheKey        string `json:"cacheKey"`
-			}{}
-			require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-			assert.Equal(t, "hit", got.Result)
-			assert.Equal(t, key+"_abc", got.CacheKey)
-		}
-	})
-
-	t.Run("exact keys are preferred (key 0)", func(t *testing.T) {
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		key := strings.ToLower(t.Name())
-		keys := [3]string{
-			key + "_a",
-			key + "_a_b_c",
-			key + "_a_b",
-		}
-		contents := [3][]byte{
-			make([]byte, 100),
-			make([]byte, 200),
-			make([]byte, 300),
-		}
-		for i := range contents {
-			_, err := rand.Read(contents[i])
-			require.NoError(t, err)
-			uploadCacheNormally(t, base, keys[i], version, contents[i])
-			time.Sleep(time.Second) // ensure CreatedAt of caches are different
-		}
-
-		reqKeys := strings.Join([]string{
-			key + "_a",
-			key + "_a_b",
-		}, ",")
-
-		resp, err := http.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, reqKeys, version))
-		require.NoError(t, err)
-		require.Equal(t, 200, resp.StatusCode)
-
-		/*
-			Expect `key_a` because:
-			- `key_a` matches `key_a`, `key_a_b` and `key_a_b_c`, but `key_a` is an exact match.
-			- `key_a_b` matches `key_a_b` and `key_a_b_c`, but previous key had a match
-		*/
-		expect := 0
-
-		got := struct {
-			ArchiveLocation string `json:"archiveLocation"`
-			CacheKey        string `json:"cacheKey"`
-		}{}
-		require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-		assert.Equal(t, keys[expect], got.CacheKey)
-
-		contentResp, err := http.Get(got.ArchiveLocation)
-		require.NoError(t, err)
-		require.Equal(t, 200, contentResp.StatusCode)
-		content, err := io.ReadAll(contentResp.Body)
-		require.NoError(t, err)
-		assert.Equal(t, contents[expect], content)
-	})
-
-	t.Run("exact keys are preferred (key 1)", func(t *testing.T) {
-		version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
-		key := strings.ToLower(t.Name())
-		keys := [3]string{
-			key + "_a",
-			key + "_a_b_c",
-			key + "_a_b",
-		}
-		contents := [3][]byte{
-			make([]byte, 100),
-			make([]byte, 200),
-			make([]byte, 300),
-		}
-		for i := range contents {
-			_, err := rand.Read(contents[i])
-			require.NoError(t, err)
-			uploadCacheNormally(t, base, keys[i], version, contents[i])
-			time.Sleep(time.Second) // ensure CreatedAt of caches are different
-		}
-
-		reqKeys := strings.Join([]string{
-			"------------------------------------------------------",
-			key + "_a",
-			key + "_a_b",
-		}, ",")
-
-		resp, err := http.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, reqKeys, version))
-		require.NoError(t, err)
-		require.Equal(t, 200, resp.StatusCode)
-
-		/*
-			Expect `key_a` because:
-			- `------------------------------------------------------` doesn't match any caches.
-			- `key_a` matches `key_a`, `key_a_b` and `key_a_b_c`, but `key_a` is an exact match.
-			- `key_a_b` matches `key_a_b` and `key_a_b_c`, but previous key had a match
-		*/
-		expect := 0
-
-		got := struct {
-			ArchiveLocation string `json:"archiveLocation"`
-			CacheKey        string `json:"cacheKey"`
-		}{}
-		require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-		assert.Equal(t, keys[expect], got.CacheKey)
-
-		contentResp, err := http.Get(got.ArchiveLocation)
-		require.NoError(t, err)
-		require.Equal(t, 200, contentResp.StatusCode)
-		content, err := io.ReadAll(contentResp.Body)
-		require.NoError(t, err)
-		assert.Equal(t, contents[expect], content)
-	})
-}
-
-func uploadCacheNormally(t *testing.T, base, key, version string, content []byte) {
-	var id uint64
-	{
-		body, err := json.Marshal(&Request{
-			Key:     key,
-			Version: version,
-			Size:    int64(len(content)),
-		})
-		require.NoError(t, err)
-		resp, err := http.Post(fmt.Sprintf("%s/caches", base), "application/json", bytes.NewReader(body))
-		require.NoError(t, err)
-		assert.Equal(t, 200, resp.StatusCode)
-
-		got := struct {
-			CacheID uint64 `json:"cacheId"`
-		}{}
-		require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-		id = got.CacheID
-	}
-	{
-		req, err := http.NewRequest(http.MethodPatch,
-			fmt.Sprintf("%s/caches/%d", base, id), bytes.NewReader(content))
-		require.NoError(t, err)
-		req.Header.Set("Content-Type", "application/octet-stream")
-		req.Header.Set("Content-Range", "bytes 0-99/*")
-		resp, err := http.DefaultClient.Do(req)
-		require.NoError(t, err)
-		assert.Equal(t, 200, resp.StatusCode)
-	}
-	{
-		resp, err := http.Post(fmt.Sprintf("%s/caches/%d", base, id), "", nil)
-		require.NoError(t, err)
-		assert.Equal(t, 200, resp.StatusCode)
-	}
-	var archiveLocation string
-	{
-		resp, err := http.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
-		require.NoError(t, err)
-		require.Equal(t, 200, resp.StatusCode)
-		got := struct {
-			Result          string `json:"result"`
-			ArchiveLocation string `json:"archiveLocation"`
-			CacheKey        string `json:"cacheKey"`
-		}{}
-		require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
-		assert.Equal(t, "hit", got.Result)
-		assert.Equal(t, strings.ToLower(key), got.CacheKey)
-		archiveLocation = got.ArchiveLocation
-	}
-	{
-		resp, err := http.Get(archiveLocation) //nolint:gosec
-		require.NoError(t, err)
-		require.Equal(t, 200, resp.StatusCode)
-		got, err := io.ReadAll(resp.Body)
-		require.NoError(t, err)
-		assert.Equal(t, content, got)
-	}
-}
-
-func TestHandler_gcCache(t *testing.T) {
-	dir := filepath.Join(t.TempDir(), "artifactcache")
-	handler, err := StartHandler(dir, "", 0, nil)
-	require.NoError(t, err)
-
-	defer func() {
-		require.NoError(t, handler.Close())
-	}()
-
-	now := time.Now()
-
-	cases := []struct {
-		Cache *Cache
-		Kept  bool
-	}{
-		{
-			// should be kept, since it's used recently and not too old.
-			Cache: &Cache{
-				Key:       "test_key_1",
-				Version:   "test_version",
-				Complete:  true,
-				UsedAt:    now.Unix(),
-				CreatedAt: now.Add(-time.Hour).Unix(),
-			},
-			Kept: true,
-		},
-		{
-			// should be removed, since it's not complete and not used for a while.
-			Cache: &Cache{
-				Key:       "test_key_2",
-				Version:   "test_version",
-				Complete:  false,
-				UsedAt:    now.Add(-(keepTemp + time.Second)).Unix(),
-				CreatedAt: now.Add(-(keepTemp + time.Hour)).Unix(),
-			},
-			Kept: false,
-		},
-		{
-			// should be removed, since it's not used for a while.
-			Cache: &Cache{
-				Key:       "test_key_3",
-				Version:   "test_version",
-				Complete:  true,
-				UsedAt:    now.Add(-(keepUnused + time.Second)).Unix(),
-				CreatedAt: now.Add(-(keepUnused + time.Hour)).Unix(),
-			},
-			Kept: false,
-		},
-		{
-			// should be removed, since it's used but too old.
-			Cache: &Cache{
-				Key:       "test_key_3",
-				Version:   "test_version",
-				Complete:  true,
-				UsedAt:    now.Unix(),
-				CreatedAt: now.Add(-(keepUsed + time.Second)).Unix(),
-			},
-			Kept: false,
-		},
-		{
-			// should be kept, since it has a newer edition but be used recently.
-			Cache: &Cache{
-				Key:       "test_key_1",
-				Version:   "test_version",
-				Complete:  true,
-				UsedAt:    now.Add(-(keepOld - time.Minute)).Unix(),
-				CreatedAt: now.Add(-(time.Hour + time.Second)).Unix(),
-			},
-			Kept: true,
-		},
-		{
-			// should be removed, since it has a newer edition and not be used recently.
-			Cache: &Cache{
-				Key:       "test_key_1",
-				Version:   "test_version",
-				Complete:  true,
-				UsedAt:    now.Add(-(keepOld + time.Second)).Unix(),
-				CreatedAt: now.Add(-(time.Hour + time.Second)).Unix(),
-			},
-			Kept: false,
-		},
-	}
-
-	db, err := handler.openDB()
-	require.NoError(t, err)
-	for _, c := range cases {
-		require.NoError(t, insertCache(db, c.Cache))
-	}
-	require.NoError(t, db.Close())
-
-	handler.gcAt = time.Time{} // ensure gcCache will not skip
-	handler.gcCache()
-
-	db, err = handler.openDB()
-	require.NoError(t, err)
-	for i, v := range cases {
-		t.Run(fmt.Sprintf("%d_%s", i, v.Cache.Key), func(t *testing.T) {
-			cache := &Cache{}
-			err = db.Get(v.Cache.ID, cache)
-			if v.Kept {
-				assert.NoError(t, err)
-			} else {
-				assert.ErrorIs(t, err, bolthold.ErrNotFound)
-			}
-		})
-	}
-	require.NoError(t, db.Close())
-}

pkg/artifactcache/model.go

@@ -1,34 +0,0 @@
-package artifactcache
-
-type Request struct {
-	Key     string `json:"key" `
-	Version string `json:"version"`
-	Size    int64  `json:"cacheSize"`
-}
-
-func (c *Request) ToCache() *Cache {
-	if c == nil {
-		return nil
-	}
-	ret := &Cache{
-		Key:     c.Key,
-		Version: c.Version,
-		Size:    c.Size,
-	}
-	if c.Size == 0 {
-		// So the request comes from old versions of actions, like `actions/cache@v2`.
-		// It doesn't send cache size. Set it to -1 to indicate that.
-		ret.Size = -1
-	}
-	return ret
-}
-
-type Cache struct {
-	ID        uint64 `json:"id" boltholdKey:"ID"`
-	Key       string `json:"key" boltholdIndex:"Key"`
-	Version   string `json:"version" boltholdIndex:"Version"`
-	Size      int64  `json:"cacheSize"`
-	Complete  bool   `json:"complete" boltholdIndex:"Complete"`
-	UsedAt    int64  `json:"usedAt" boltholdIndex:"UsedAt"`
-	CreatedAt int64  `json:"createdAt" boltholdIndex:"CreatedAt"`
-}

pkg/artifactcache/storage.go

@@ -1,130 +0,0 @@
-package artifactcache
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-)
-
-type Storage struct {
-	rootDir string
-}
-
-func NewStorage(rootDir string) (*Storage, error) {
-	if err := os.MkdirAll(rootDir, 0o755); err != nil {
-		return nil, err
-	}
-	return &Storage{
-		rootDir: rootDir,
-	}, nil
-}
-
-func (s *Storage) Exist(id uint64) (bool, error) {
-	name := s.filename(id)
-	if _, err := os.Stat(name); os.IsNotExist(err) {
-		return false, nil
-	} else if err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
-func (s *Storage) Write(id uint64, offset int64, reader io.Reader) error {
-	name := s.tempName(id, offset)
-	if err := os.MkdirAll(filepath.Dir(name), 0o755); err != nil {
-		return err
-	}
-	file, err := os.Create(name)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	_, err = io.Copy(file, reader)
-	return err
-}
-
-func (s *Storage) Commit(id uint64, size int64) (int64, error) {
-	defer func() {
-		_ = os.RemoveAll(s.tempDir(id))
-	}()
-
-	name := s.filename(id)
-	tempNames, err := s.tempNames(id)
-	if err != nil {
-		return 0, err
-	}
-
-	if err := os.MkdirAll(filepath.Dir(name), 0o755); err != nil {
-		return 0, err
-	}
-	file, err := os.Create(name)
-	if err != nil {
-		return 0, err
-	}
-	defer file.Close()
-
-	var written int64
-	for _, v := range tempNames {
-		f, err := os.Open(v)
-		if err != nil {
-			return 0, err
-		}
-		n, err := io.Copy(file, f)
-		_ = f.Close()
-		if err != nil {
-			return 0, err
-		}
-		written += n
-	}
-
-	// If size is less than 0, it means the size is unknown.
-	// We can't check the size of the file, just skip the check.
-	// It happens when the request comes from old versions of actions, like `actions/cache@v2`.
-	if size >= 0 && written != size {
-		_ = file.Close()
-		_ = os.Remove(name)
-		return 0, fmt.Errorf("broken file: %v != %v", written, size)
-	}
-
-	return written, nil
-}
-
-func (s *Storage) Serve(w http.ResponseWriter, r *http.Request, id uint64) {
-	name := s.filename(id)
-	http.ServeFile(w, r, name)
-}
-
-func (s *Storage) Remove(id uint64) {
-	_ = os.Remove(s.filename(id))
-	_ = os.RemoveAll(s.tempDir(id))
-}
-
-func (s *Storage) filename(id uint64) string {
-	return filepath.Join(s.rootDir, fmt.Sprintf("%02x", id%0xff), fmt.Sprint(id))
-}
-
-func (s *Storage) tempDir(id uint64) string {
-	return filepath.Join(s.rootDir, "tmp", fmt.Sprint(id))
-}
-
-func (s *Storage) tempName(id uint64, offset int64) string {
-	return filepath.Join(s.tempDir(id), fmt.Sprintf("%016x", offset))
-}
-
-func (s *Storage) tempNames(id uint64) ([]string, error) {
-	dir := s.tempDir(id)
-	files, err := os.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	var names []string
-	for _, v := range files {
-		if !v.IsDir() {
-			names = append(names, filepath.Join(dir, v.Name()))
-		}
-	}
-	return names, nil
-}

pkg/artifactcache/testdata/example/example.yaml

@@ -1,30 +0,0 @@
-# Copied from https://github.com/actions/cache#example-cache-workflow
-name: Caching Primes
-
-on: push
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - run: env
-
-      - uses: actions/checkout@v3
-
-      - name: Cache Primes
-        id: cache-primes
-        uses: actions/cache@v3
-        with:
-          path: prime-numbers
-          key: ${{ runner.os }}-primes-${{ github.run_id }}
-          restore-keys: |
-            ${{ runner.os }}-primes
-            ${{ runner.os }}
-
-      - name: Generate Prime Numbers
-        if: steps.cache-primes.outputs.cache-hit != 'true'
-        run: cat /proc/sys/kernel/random/uuid > prime-numbers
-
-      - name: Use Prime Numbers
-        run: cat prime-numbers

pkg/artifacts/server.go

@@ -1,318 +0,0 @@
-package artifacts
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/julienschmidt/httprouter"
-
-	"github.com/nektos/act/pkg/common"
-)
-
-type FileContainerResourceURL struct {
-	FileContainerResourceURL string `json:"fileContainerResourceUrl"`
-}
-
-type NamedFileContainerResourceURL struct {
-	Name                     string `json:"name"`
-	FileContainerResourceURL string `json:"fileContainerResourceUrl"`
-}
-
-type NamedFileContainerResourceURLResponse struct {
-	Count int                             `json:"count"`
-	Value []NamedFileContainerResourceURL `json:"value"`
-}
-
-type ContainerItem struct {
-	Path            string `json:"path"`
-	ItemType        string `json:"itemType"`
-	ContentLocation string `json:"contentLocation"`
-}
-
-type ContainerItemResponse struct {
-	Value []ContainerItem `json:"value"`
-}
-
-type ResponseMessage struct {
-	Message string `json:"message"`
-}
-
-type WritableFile interface {
-	io.WriteCloser
-}
-
-type WriteFS interface {
-	OpenWritable(name string) (WritableFile, error)
-	OpenAppendable(name string) (WritableFile, error)
-}
-
-type readWriteFSImpl struct {
-}
-
-func (fwfs readWriteFSImpl) Open(name string) (fs.File, error) {
-	return os.Open(name)
-}
-
-func (fwfs readWriteFSImpl) OpenWritable(name string) (WritableFile, error) {
-	if err := os.MkdirAll(filepath.Dir(name), os.ModePerm); err != nil {
-		return nil, err
-	}
-	return os.OpenFile(name, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0o644)
-}
-
-func (fwfs readWriteFSImpl) OpenAppendable(name string) (WritableFile, error) {
-	if err := os.MkdirAll(filepath.Dir(name), os.ModePerm); err != nil {
-		return nil, err
-	}
-	file, err := os.OpenFile(name, os.O_CREATE|os.O_RDWR, 0o644)
-
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = file.Seek(0, io.SeekEnd)
-	if err != nil {
-		return nil, err
-	}
-	return file, nil
-}
-
-var gzipExtension = ".gz__"
-
-func safeResolve(baseDir string, relPath string) string {
-	return filepath.Join(baseDir, filepath.Clean(filepath.Join(string(os.PathSeparator), relPath)))
-}
-
-func uploads(router *httprouter.Router, baseDir string, fsys WriteFS) {
-	router.POST("/_apis/pipelines/workflows/:runId/artifacts", func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
-		runID := params.ByName("runId")
-
-		json, err := json.Marshal(FileContainerResourceURL{
-			FileContainerResourceURL: fmt.Sprintf("http://%s/upload/%s", req.Host, runID),
-		})
-		if err != nil {
-			panic(err)
-		}
-
-		_, err = w.Write(json)
-		if err != nil {
-			panic(err)
-		}
-	})
-
-	router.PUT("/upload/:runId", func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
-		itemPath := req.URL.Query().Get("itemPath")
-		runID := params.ByName("runId")
-
-		if req.Header.Get("Content-Encoding") == "gzip" {
-			itemPath += gzipExtension
-		}
-
-		safeRunPath := safeResolve(baseDir, runID)
-		safePath := safeResolve(safeRunPath, itemPath)
-
-		file, err := func() (WritableFile, error) {
-			contentRange := req.Header.Get("Content-Range")
-			if contentRange != "" && !strings.HasPrefix(contentRange, "bytes 0-") {
-				return fsys.OpenAppendable(safePath)
-			}
-			return fsys.OpenWritable(safePath)
-		}()
-
-		if err != nil {
-			panic(err)
-		}
-		defer file.Close()
-
-		writer, ok := file.(io.Writer)
-		if !ok {
-			panic(errors.New("File is not writable"))
-		}
-
-		if req.Body == nil {
-			panic(errors.New("No body given"))
-		}
-
-		_, err = io.Copy(writer, req.Body)
-		if err != nil {
-			panic(err)
-		}
-
-		json, err := json.Marshal(ResponseMessage{
-			Message: "success",
-		})
-		if err != nil {
-			panic(err)
-		}
-
-		_, err = w.Write(json)
-		if err != nil {
-			panic(err)
-		}
-	})
-
-	router.PATCH("/_apis/pipelines/workflows/:runId/artifacts", func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
-		json, err := json.Marshal(ResponseMessage{
-			Message: "success",
-		})
-		if err != nil {
-			panic(err)
-		}
-
-		_, err = w.Write(json)
-		if err != nil {
-			panic(err)
-		}
-	})
-}
-
-func downloads(router *httprouter.Router, baseDir string, fsys fs.FS) {
-	router.GET("/_apis/pipelines/workflows/:runId/artifacts", func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
-		runID := params.ByName("runId")
-
-		safePath := safeResolve(baseDir, runID)
-
-		entries, err := fs.ReadDir(fsys, safePath)
-		if err != nil {
-			panic(err)
-		}
-
-		var list []NamedFileContainerResourceURL
-		for _, entry := range entries {
-			list = append(list, NamedFileContainerResourceURL{
-				Name:                     entry.Name(),
-				FileContainerResourceURL: fmt.Sprintf("http://%s/download/%s", req.Host, runID),
-			})
-		}
-
-		json, err := json.Marshal(NamedFileContainerResourceURLResponse{
-			Count: len(list),
-			Value: list,
-		})
-		if err != nil {
-			panic(err)
-		}
-
-		_, err = w.Write(json)
-		if err != nil {
-			panic(err)
-		}
-	})
-
-	router.GET("/download/:container", func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
-		container := params.ByName("container")
-		itemPath := req.URL.Query().Get("itemPath")
-		safePath := safeResolve(baseDir, filepath.Join(container, itemPath))
-
-		var files []ContainerItem
-		err := fs.WalkDir(fsys, safePath, func(path string, entry fs.DirEntry, err error) error {
-			if !entry.IsDir() {
-				rel, err := filepath.Rel(safePath, path)
-				if err != nil {
-					panic(err)
-				}
-
-				// if it was upload as gzip
-				rel = strings.TrimSuffix(rel, gzipExtension)
-				path := filepath.Join(itemPath, rel)
-
-				rel = filepath.ToSlash(rel)
-				path = filepath.ToSlash(path)
-
-				files = append(files, ContainerItem{
-					Path:            path,
-					ItemType:        "file",
-					ContentLocation: fmt.Sprintf("http://%s/artifact/%s/%s/%s", req.Host, container, itemPath, rel),
-				})
-			}
-			return nil
-		})
-		if err != nil {
-			panic(err)
-		}
-
-		json, err := json.Marshal(ContainerItemResponse{
-			Value: files,
-		})
-		if err != nil {
-			panic(err)
-		}
-
-		_, err = w.Write(json)
-		if err != nil {
-			panic(err)
-		}
-	})
-
-	router.GET("/artifact/*path", func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
-		path := params.ByName("path")[1:]
-
-		safePath := safeResolve(baseDir, path)
-
-		file, err := fsys.Open(safePath)
-		if err != nil {
-			// try gzip file
-			file, err = fsys.Open(safePath + gzipExtension)
-			if err != nil {
-				panic(err)
-			}
-			w.Header().Add("Content-Encoding", "gzip")
-		}
-
-		_, err = io.Copy(w, file)
-		if err != nil {
-			panic(err)
-		}
-	})
-}
-
-func Serve(ctx context.Context, artifactPath string, addr string, port string) context.CancelFunc {
-	serverContext, cancel := context.WithCancel(ctx)
-	logger := common.Logger(serverContext)
-
-	if artifactPath == "" {
-		return cancel
-	}
-
-	router := httprouter.New()
-
-	logger.Debugf("Artifacts base path '%s'", artifactPath)
-	fsys := readWriteFSImpl{}
-	uploads(router, artifactPath, fsys)
-	downloads(router, artifactPath, fsys)
-
-	server := &http.Server{
-		Addr:              fmt.Sprintf("%s:%s", addr, port),
-		ReadHeaderTimeout: 2 * time.Second,
-		Handler:           router,
-	}
-
-	// run server
-	go func() {
-		logger.Infof("Start server on http://%s:%s", addr, port)
-		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.Fatal(err)
-		}
-	}()
-
-	// wait for cancel to gracefully shutdown server
-	go func() {
-		<-serverContext.Done()
-
-		if err := server.Shutdown(ctx); err != nil {
-			logger.Errorf("Failed shutdown gracefully - force shutdown: %v", err)
-			server.Close()
-		}
-	}()
-
-	return cancel
-}

pkg/artifacts/server_test.go

@@ -1,395 +0,0 @@
-package artifacts
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-	"testing"
-	"testing/fstest"
-
-	"github.com/julienschmidt/httprouter"
-	log "github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
-
-	"github.com/nektos/act/pkg/model"
-	"github.com/nektos/act/pkg/runner"
-)
-
-type writableMapFile struct {
-	fstest.MapFile
-}
-
-func (f *writableMapFile) Write(data []byte) (int, error) {
-	f.Data = data
-	return len(data), nil
-}
-
-func (f *writableMapFile) Close() error {
-	return nil
-}
-
-type writeMapFS struct {
-	fstest.MapFS
-}
-
-func (fsys writeMapFS) OpenWritable(name string) (WritableFile, error) {
-	var file = &writableMapFile{
-		MapFile: fstest.MapFile{
-			Data: []byte("content2"),
-		},
-	}
-	fsys.MapFS[name] = &file.MapFile
-
-	return file, nil
-}
-
-func (fsys writeMapFS) OpenAppendable(name string) (WritableFile, error) {
-	var file = &writableMapFile{
-		MapFile: fstest.MapFile{
-			Data: []byte("content2"),
-		},
-	}
-	fsys.MapFS[name] = &file.MapFile
-
-	return file, nil
-}
-
-func TestNewArtifactUploadPrepare(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{})
-
-	router := httprouter.New()
-	uploads(router, "artifact/server/path", writeMapFS{memfs})
-
-	req, _ := http.NewRequest("POST", "http://localhost/_apis/pipelines/workflows/1/artifacts", nil)
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.Fail("Wrong status")
-	}
-
-	response := FileContainerResourceURL{}
-	err := json.Unmarshal(rr.Body.Bytes(), &response)
-	if err != nil {
-		panic(err)
-	}
-
-	assert.Equal("http://localhost/upload/1", response.FileContainerResourceURL)
-}
-
-func TestArtifactUploadBlob(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{})
-
-	router := httprouter.New()
-	uploads(router, "artifact/server/path", writeMapFS{memfs})
-
-	req, _ := http.NewRequest("PUT", "http://localhost/upload/1?itemPath=some/file", strings.NewReader("content"))
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.Fail("Wrong status")
-	}
-
-	response := ResponseMessage{}
-	err := json.Unmarshal(rr.Body.Bytes(), &response)
-	if err != nil {
-		panic(err)
-	}
-
-	assert.Equal("success", response.Message)
-	assert.Equal("content", string(memfs["artifact/server/path/1/some/file"].Data))
-}
-
-func TestFinalizeArtifactUpload(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{})
-
-	router := httprouter.New()
-	uploads(router, "artifact/server/path", writeMapFS{memfs})
-
-	req, _ := http.NewRequest("PATCH", "http://localhost/_apis/pipelines/workflows/1/artifacts", nil)
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.Fail("Wrong status")
-	}
-
-	response := ResponseMessage{}
-	err := json.Unmarshal(rr.Body.Bytes(), &response)
-	if err != nil {
-		panic(err)
-	}
-
-	assert.Equal("success", response.Message)
-}
-
-func TestListArtifacts(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{
-		"artifact/server/path/1/file.txt": {
-			Data: []byte(""),
-		},
-	})
-
-	router := httprouter.New()
-	downloads(router, "artifact/server/path", memfs)
-
-	req, _ := http.NewRequest("GET", "http://localhost/_apis/pipelines/workflows/1/artifacts", nil)
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.FailNow(fmt.Sprintf("Wrong status: %d", status))
-	}
-
-	response := NamedFileContainerResourceURLResponse{}
-	err := json.Unmarshal(rr.Body.Bytes(), &response)
-	if err != nil {
-		panic(err)
-	}
-
-	assert.Equal(1, response.Count)
-	assert.Equal("file.txt", response.Value[0].Name)
-	assert.Equal("http://localhost/download/1", response.Value[0].FileContainerResourceURL)
-}
-
-func TestListArtifactContainer(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{
-		"artifact/server/path/1/some/file": {
-			Data: []byte(""),
-		},
-	})
-
-	router := httprouter.New()
-	downloads(router, "artifact/server/path", memfs)
-
-	req, _ := http.NewRequest("GET", "http://localhost/download/1?itemPath=some/file", nil)
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.FailNow(fmt.Sprintf("Wrong status: %d", status))
-	}
-
-	response := ContainerItemResponse{}
-	err := json.Unmarshal(rr.Body.Bytes(), &response)
-	if err != nil {
-		panic(err)
-	}
-
-	assert.Equal(1, len(response.Value))
-	assert.Equal("some/file", response.Value[0].Path)
-	assert.Equal("file", response.Value[0].ItemType)
-	assert.Equal("http://localhost/artifact/1/some/file/.", response.Value[0].ContentLocation)
-}
-
-func TestDownloadArtifactFile(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{
-		"artifact/server/path/1/some/file": {
-			Data: []byte("content"),
-		},
-	})
-
-	router := httprouter.New()
-	downloads(router, "artifact/server/path", memfs)
-
-	req, _ := http.NewRequest("GET", "http://localhost/artifact/1/some/file", nil)
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.FailNow(fmt.Sprintf("Wrong status: %d", status))
-	}
-
-	data := rr.Body.Bytes()
-
-	assert.Equal("content", string(data))
-}
-
-type TestJobFileInfo struct {
-	workdir               string
-	workflowPath          string
-	eventName             string
-	errorMessage          string
-	platforms             map[string]string
-	containerArchitecture string
-}
-
-var (
-	artifactsPath = path.Join(os.TempDir(), "test-artifacts")
-	artifactsAddr = "127.0.0.1"
-	artifactsPort = "12345"
-)
-
-func TestArtifactFlow(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping integration test")
-	}
-
-	ctx := context.Background()
-
-	cancel := Serve(ctx, artifactsPath, artifactsAddr, artifactsPort)
-	defer cancel()
-
-	platforms := map[string]string{
-		"ubuntu-latest": "node:16-buster", // Don't use node:16-buster-slim because it doesn't have curl command, which is used in the tests
-	}
-
-	tables := []TestJobFileInfo{
-		{"testdata", "upload-and-download", "push", "", platforms, ""},
-		{"testdata", "GHSL-2023-004", "push", "", platforms, ""},
-	}
-	log.SetLevel(log.DebugLevel)
-
-	for _, table := range tables {
-		runTestJobFile(ctx, t, table)
-	}
-}
-
-func runTestJobFile(ctx context.Context, t *testing.T, tjfi TestJobFileInfo) {
-	t.Run(tjfi.workflowPath, func(t *testing.T) {
-		fmt.Printf("::group::%s\n", tjfi.workflowPath)
-
-		if err := os.RemoveAll(artifactsPath); err != nil {
-			panic(err)
-		}
-
-		workdir, err := filepath.Abs(tjfi.workdir)
-		assert.Nil(t, err, workdir)
-		fullWorkflowPath := filepath.Join(workdir, tjfi.workflowPath)
-		runnerConfig := &runner.Config{
-			Workdir:               workdir,
-			BindWorkdir:           false,
-			EventName:             tjfi.eventName,
-			Platforms:             tjfi.platforms,
-			ReuseContainers:       false,
-			ContainerArchitecture: tjfi.containerArchitecture,
-			GitHubInstance:        "github.com",
-			ArtifactServerPath:    artifactsPath,
-			ArtifactServerAddr:    artifactsAddr,
-			ArtifactServerPort:    artifactsPort,
-		}
-
-		runner, err := runner.New(runnerConfig)
-		assert.Nil(t, err, tjfi.workflowPath)
-
-		planner, err := model.NewWorkflowPlanner(fullWorkflowPath, true)
-		assert.Nil(t, err, fullWorkflowPath)
-
-		plan, err := planner.PlanEvent(tjfi.eventName)
-		if err == nil {
-			err = runner.NewPlanExecutor(plan)(ctx)
-			if tjfi.errorMessage == "" {
-				assert.Nil(t, err, fullWorkflowPath)
-			} else {
-				assert.Error(t, err, tjfi.errorMessage)
-			}
-		} else {
-			assert.Nil(t, plan)
-		}
-
-		fmt.Println("::endgroup::")
-	})
-}
-
-func TestMkdirFsImplSafeResolve(t *testing.T) {
-	assert := assert.New(t)
-
-	baseDir := "/foo/bar"
-
-	tests := map[string]struct {
-		input string
-		want  string
-	}{
-		"simple":         {input: "baz", want: "/foo/bar/baz"},
-		"nested":         {input: "baz/blue", want: "/foo/bar/baz/blue"},
-		"dots in middle": {input: "baz/../../blue", want: "/foo/bar/blue"},
-		"leading dots":   {input: "../../parent", want: "/foo/bar/parent"},
-		"root path":      {input: "/root", want: "/foo/bar/root"},
-		"root":           {input: "/", want: "/foo/bar"},
-		"empty":          {input: "", want: "/foo/bar"},
-	}
-
-	for name, tc := range tests {
-		t.Run(name, func(t *testing.T) {
-			assert.Equal(tc.want, safeResolve(baseDir, tc.input))
-		})
-	}
-}
-
-func TestDownloadArtifactFileUnsafePath(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{
-		"artifact/server/path/some/file": {
-			Data: []byte("content"),
-		},
-	})
-
-	router := httprouter.New()
-	downloads(router, "artifact/server/path", memfs)
-
-	req, _ := http.NewRequest("GET", "http://localhost/artifact/2/../../some/file", nil)
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.FailNow(fmt.Sprintf("Wrong status: %d", status))
-	}
-
-	data := rr.Body.Bytes()
-
-	assert.Equal("content", string(data))
-}
-
-func TestArtifactUploadBlobUnsafePath(t *testing.T) {
-	assert := assert.New(t)
-
-	var memfs = fstest.MapFS(map[string]*fstest.MapFile{})
-
-	router := httprouter.New()
-	uploads(router, "artifact/server/path", writeMapFS{memfs})
-
-	req, _ := http.NewRequest("PUT", "http://localhost/upload/1?itemPath=../../some/file", strings.NewReader("content"))
-	rr := httptest.NewRecorder()
-
-	router.ServeHTTP(rr, req)
-
-	if status := rr.Code; status != http.StatusOK {
-		assert.Fail("Wrong status")
-	}
-
-	response := ResponseMessage{}
-	err := json.Unmarshal(rr.Body.Bytes(), &response)
-	if err != nil {
-		panic(err)
-	}
-
-	assert.Equal("success", response.Message)
-	assert.Equal("content", string(memfs["artifact/server/path/1/some/file"].Data))
-}

pkg/artifacts/testdata/GHSL-2023-004/artifacts.yml

@@ -1,39 +0,0 @@
-
-name: "GHSL-2023-0004"
-on: push
-
-jobs:
-  test-artifacts:
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo "hello world" > test.txt
-      - name: curl upload
-        run: curl --silent --show-error --fail ${ACTIONS_RUNTIME_URL}upload/1?itemPath=../../my-artifact/secret.txt --upload-file test.txt
-      - uses: actions/download-artifact@v2
-        with:
-          name: my-artifact
-          path: test-artifacts
-      - name: 'Verify Artifact #1'
-        run: |
-          file="test-artifacts/secret.txt"
-          if [ ! -f $file ] ; then
-            echo "Expected file does not exist"
-            exit 1
-          fi
-          if [ "$(cat $file)" != "hello world" ] ; then
-            echo "File contents of downloaded artifact are incorrect"
-            exit 1
-          fi
-      - name: Verify download should work by clean extra dots
-        run: curl --silent --show-error --fail --path-as-is -o out.txt ${ACTIONS_RUNTIME_URL}artifact/1/../../../1/my-artifact/secret.txt
-      - name: 'Verify download content'
-        run: |
-          file="out.txt"
-          if [ ! -f $file ] ; then
-            echo "Expected file does not exist"
-            exit 1
-          fi
-          if [ "$(cat $file)" != "hello world" ] ; then
-            echo "File contents of downloaded artifact are incorrect"
-            exit 1
-          fi

pkg/artifacts/testdata/upload-and-download/artifacts.yml

@@ -1,230 +0,0 @@
-
-name: "Test that artifact uploads and downloads succeed"
-on: push
-
-jobs:
-  test-artifacts:
-    runs-on: ubuntu-latest
-    steps:
-      - run: mkdir -p path/to/artifact
-      - run: echo hello > path/to/artifact/world.txt
-      - uses: actions/upload-artifact@v2
-        with:
-          name: my-artifact
-          path: path/to/artifact/world.txt
-
-      - run: rm -rf path
-
-      - uses: actions/download-artifact@v2
-        with:
-          name: my-artifact
-      - name: Display structure of downloaded files
-        run: ls -la
-
-      # Test end-to-end by uploading two artifacts and then downloading them
-      - name: Create artifact files
-        run: |
-          mkdir -p path/to/dir-1
-          mkdir -p path/to/dir-2
-          mkdir -p path/to/dir-3
-          mkdir -p path/to/dir-5
-          mkdir -p path/to/dir-6
-          mkdir -p path/to/dir-7
-          echo "Lorem ipsum dolor sit amet" > path/to/dir-1/file1.txt
-          echo "Hello world from file #2" > path/to/dir-2/file2.txt
-          echo "This is a going to be a test for a large enough file that should get compressed with GZip. The @actions/artifact package uses GZip to upload files. This text should have a compression ratio greater than 100% so it should get uploaded using GZip" > path/to/dir-3/gzip.txt
-          dd if=/dev/random of=path/to/dir-5/file5.rnd bs=1024 count=1024
-          dd if=/dev/random of=path/to/dir-6/file6.rnd bs=1024 count=$((10*1024))
-          dd if=/dev/random of=path/to/dir-7/file7.rnd bs=1024 count=$((10*1024))
-
-      # Upload a single file artifact
-      - name: 'Upload artifact #1'
-        uses: actions/upload-artifact@v2
-        with:
-          name: 'Artifact-A'
-          path: path/to/dir-1/file1.txt
-      
-      # Upload using a wildcard pattern, name should default to 'artifact' if not provided
-      - name: 'Upload artifact #2'
-        uses: actions/upload-artifact@v2
-        with:
-          path: path/**/dir*/
-      
-      # Upload a directory that contains a file that will be uploaded with GZip
-      - name: 'Upload artifact #3'
-        uses: actions/upload-artifact@v2
-        with:
-          name: 'GZip-Artifact'
-          path: path/to/dir-3/
-      
-      # Upload a directory that contains a file that will be uploaded with GZip
-      - name: 'Upload artifact #4'
-        uses: actions/upload-artifact@v2
-        with:
-          name: 'Multi-Path-Artifact'
-          path: |
-            path/to/dir-1/*
-            path/to/dir-[23]/*
-            !path/to/dir-3/*.txt
-      
-      # Upload a mid-size file artifact
-      - name: 'Upload artifact #5'
-        uses: actions/upload-artifact@v2
-        with:
-          name: 'Mid-Size-Artifact'
-          path: path/to/dir-5/file5.rnd
-      
-      # Upload a big file artifact
-      - name: 'Upload artifact #6'
-        uses: actions/upload-artifact@v2
-        with:
-          name: 'Big-Artifact'
-          path: path/to/dir-6/file6.rnd
-
-      # Upload a big file artifact twice
-      - name: 'Upload artifact #7 (First)'
-        uses: actions/upload-artifact@v2
-        with:
-          name: 'Big-Uploaded-Twice'
-          path: path/to/dir-7/file7.rnd
-
-      # Upload a big file artifact twice
-      - name: 'Upload artifact #7 (Second)'
-        uses: actions/upload-artifact@v2
-        with:
-          name: 'Big-Uploaded-Twice'
-          path: path/to/dir-7/file7.rnd
-
-      # Verify artifacts. Switch to download-artifact@v2 once it's out of preview
-      
-      # Download Artifact #1 and verify the correctness of the content
-      - name: 'Download artifact #1'
-        uses: actions/download-artifact@v2
-        with:
-          name: 'Artifact-A'
-          path: some/new/path
-      
-      - name: 'Verify Artifact #1'
-        run: |
-          file="some/new/path/file1.txt"
-          if [ ! -f $file ] ; then
-            echo "Expected file does not exist"
-            exit 1
-          fi
-          if [ "$(cat $file)" != "Lorem ipsum dolor sit amet" ] ; then
-            echo "File contents of downloaded artifact are incorrect"
-            exit 1
-          fi
-      
-      # Download Artifact #2 and verify the correctness of the content
-      - name: 'Download artifact #2'
-        uses: actions/download-artifact@v2
-        with:
-          name: 'artifact'
-          path: some/other/path
-      
-      - name: 'Verify Artifact #2'
-        run: |
-          file1="some/other/path/to/dir-1/file1.txt"
-          file2="some/other/path/to/dir-2/file2.txt"
-          if [ ! -f $file1 -o ! -f $file2 ] ; then
-            echo "Expected files do not exist"
-            exit 1
-          fi
-          if [ "$(cat $file1)" != "Lorem ipsum dolor sit amet" -o "$(cat $file2)" != "Hello world from file #2" ] ; then
-            echo "File contents of downloaded artifacts are incorrect"
-            exit 1
-          fi
-      
-      # Download Artifact #3 and verify the correctness of the content
-      - name: 'Download artifact #3'
-        uses: actions/download-artifact@v2
-        with:
-          name: 'GZip-Artifact'
-          path: gzip/artifact/path
-      
-      # Because a directory was used as input during the upload the parent directories, path/to/dir-3/, should not be included in the uploaded artifact
-      - name: 'Verify Artifact #3'
-        run: |
-          gzipFile="gzip/artifact/path/gzip.txt"
-          if [ ! -f $gzipFile ] ; then
-            echo "Expected file do not exist"
-            exit 1
-          fi
-          if [ "$(cat $gzipFile)" != "This is a going to be a test for a large enough file that should get compressed with GZip. The @actions/artifact package uses GZip to upload files. This text should have a compression ratio greater than 100% so it should get uploaded using GZip" ] ; then
-            echo "File contents of downloaded artifact is incorrect"
-            exit 1
-          fi
-      
-      - name: 'Download artifact #4'
-        uses: actions/download-artifact@v2
-        with:
-          name: 'Multi-Path-Artifact'
-          path: multi/artifact
-      
-      - name: 'Verify Artifact #4'
-        run: |
-          file1="multi/artifact/dir-1/file1.txt"
-          file2="multi/artifact/dir-2/file2.txt"
-          if [ ! -f $file1 -o ! -f $file2 ] ; then
-            echo "Expected files do not exist"
-            exit 1
-          fi
-          if [ "$(cat $file1)" != "Lorem ipsum dolor sit amet" -o "$(cat $file2)" != "Hello world from file #2" ] ; then
-            echo "File contents of downloaded artifacts are incorrect"
-            exit 1
-          fi
-      
-      - name: 'Download artifact #5'
-        uses: actions/download-artifact@v2
-        with:
-          name: 'Mid-Size-Artifact'
-          path: mid-size/artifact/path
-      
-      - name: 'Verify Artifact #5'
-        run: |
-          file="mid-size/artifact/path/file5.rnd"
-          if [ ! -f $file ] ; then
-            echo "Expected file does not exist"
-            exit 1
-          fi
-          if ! diff $file path/to/dir-5/file5.rnd ; then
-            echo "File contents of downloaded artifact are incorrect"
-            exit 1
-          fi
-      
-      - name: 'Download artifact #6'
-        uses: actions/download-artifact@v2
-        with:
-          name: 'Big-Artifact'
-          path: big/artifact/path
-      
-      - name: 'Verify Artifact #6'
-        run: |
-          file="big/artifact/path/file6.rnd"
-          if [ ! -f $file ] ; then
-            echo "Expected file does not exist"
-            exit 1
-          fi
-          if ! diff $file path/to/dir-6/file6.rnd ; then
-            echo "File contents of downloaded artifact are incorrect"
-            exit 1
-          fi
-
-      - name: 'Download artifact #7'
-        uses: actions/download-artifact@v2
-        with:
-          name: 'Big-Uploaded-Twice'
-          path: big-uploaded-twice/artifact/path
-
-      - name: 'Verify Artifact #7'
-        run: |
-          file="big-uploaded-twice/artifact/path/file7.rnd"
-          if [ ! -f $file ] ; then
-            echo "Expected file does not exist"
-            exit 1
-          fi
-          if ! diff $file path/to/dir-7/file7.rnd ; then
-            echo "File contents of downloaded artifact are incorrect"
-            exit 1
-          fi

pkg/common/cartesian.go

@@ -1,54 +0,0 @@
-package common
-
-// CartesianProduct takes map of lists and returns list of unique tuples
-func CartesianProduct(mapOfLists map[string][]interface{}) []map[string]interface{} {
-	listNames := make([]string, 0)
-	lists := make([][]interface{}, 0)
-	for k, v := range mapOfLists {
-		listNames = append(listNames, k)
-		lists = append(lists, v)
-	}
-
-	listCart := cartN(lists...)
-
-	rtn := make([]map[string]interface{}, 0)
-	for _, list := range listCart {
-		vMap := make(map[string]interface{})
-		for i, v := range list {
-			vMap[listNames[i]] = v
-		}
-		rtn = append(rtn, vMap)
-	}
-	return rtn
-}
-
-func cartN(a ...[]interface{}) [][]interface{} {
-	c := 1
-	for _, a := range a {
-		c *= len(a)
-	}
-	if c == 0 || len(a) == 0 {
-		return nil
-	}
-	p := make([][]interface{}, c)
-	b := make([]interface{}, c*len(a))
-	n := make([]int, len(a))
-	s := 0
-	for i := range p {
-		e := s + len(a)
-		pi := b[s:e]
-		p[i] = pi
-		s = e
-		for j, n := range n {
-			pi[j] = a[j][n]
-		}
-		for j := len(n) - 1; j >= 0; j-- {
-			n[j]++
-			if n[j] < len(a[j]) {
-				break
-			}
-			n[j] = 0
-		}
-	}
-	return p
-}

pkg/common/cartesian_test.go

@@ -1,39 +0,0 @@
-package common
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCartesianProduct(t *testing.T) {
-	assert := assert.New(t)
-	input := map[string][]interface{}{
-		"foo": {1, 2, 3, 4},
-		"bar": {"a", "b", "c"},
-		"baz": {false, true},
-	}
-
-	output := CartesianProduct(input)
-	assert.Len(output, 24)
-
-	for _, v := range output {
-		assert.Len(v, 3)
-
-		assert.Contains(v, "foo")
-		assert.Contains(v, "bar")
-		assert.Contains(v, "baz")
-	}
-
-	input = map[string][]interface{}{
-		"foo": {1, 2, 3, 4},
-		"bar": {},
-		"baz": {false, true},
-	}
-	output = CartesianProduct(input)
-	assert.Len(output, 0)
-
-	input = map[string][]interface{}{}
-	output = CartesianProduct(input)
-	assert.Len(output, 0)
-}

pkg/common/draw.go

@@ -1,143 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strings"
-)
-
-// Style is a specific style
-type Style int
-
-// Styles
-const (
-	StyleDoubleLine = iota
-	StyleSingleLine
-	StyleDashedLine
-	StyleNoLine
-)
-
-// NewPen creates a new pen
-func NewPen(style Style, color int) *Pen {
-	bgcolor := 49
-	if os.Getenv("CLICOLOR") == "0" {
-		color = 0
-		bgcolor = 0
-	}
-	return &Pen{
-		style:   style,
-		color:   color,
-		bgcolor: bgcolor,
-	}
-}
-
-type styleDef struct {
-	cornerTL string
-	cornerTR string
-	cornerBL string
-	cornerBR string
-	lineH    string
-	lineV    string
-}
-
-var styleDefs = []styleDef{
-	{"\u2554", "\u2557", "\u255a", "\u255d", "\u2550", "\u2551"},
-	{"\u256d", "\u256e", "\u2570", "\u256f", "\u2500", "\u2502"},
-	{"\u250c", "\u2510", "\u2514", "\u2518", "\u254c", "\u254e"},
-	{" ", " ", " ", " ", " ", " "},
-}
-
-// Pen struct
-type Pen struct {
-	style   Style
-	color   int
-	bgcolor int
-}
-
-// Drawing struct
-type Drawing struct {
-	buf   *strings.Builder
-	width int
-}
-
-func (p *Pen) drawTopBars(buf io.Writer, labels ...string) {
-	style := styleDefs[p.style]
-	for _, label := range labels {
-		bar := strings.Repeat(style.lineH, len(label)+2)
-		fmt.Fprintf(buf, " ")
-		fmt.Fprintf(buf, "\x1b[%d;%dm", p.color, p.bgcolor)
-		fmt.Fprintf(buf, "%s%s%s", style.cornerTL, bar, style.cornerTR)
-		fmt.Fprintf(buf, "\x1b[%dm", 0)
-	}
-	fmt.Fprintf(buf, "\n")
-}
-func (p *Pen) drawBottomBars(buf io.Writer, labels ...string) {
-	style := styleDefs[p.style]
-	for _, label := range labels {
-		bar := strings.Repeat(style.lineH, len(label)+2)
-		fmt.Fprintf(buf, " ")
-		fmt.Fprintf(buf, "\x1b[%d;%dm", p.color, p.bgcolor)
-		fmt.Fprintf(buf, "%s%s%s", style.cornerBL, bar, style.cornerBR)
-		fmt.Fprintf(buf, "\x1b[%dm", 0)
-	}
-	fmt.Fprintf(buf, "\n")
-}
-func (p *Pen) drawLabels(buf io.Writer, labels ...string) {
-	style := styleDefs[p.style]
-	for _, label := range labels {
-		fmt.Fprintf(buf, " ")
-		fmt.Fprintf(buf, "\x1b[%d;%dm", p.color, p.bgcolor)
-		fmt.Fprintf(buf, "%s %s %s", style.lineV, label, style.lineV)
-		fmt.Fprintf(buf, "\x1b[%dm", 0)
-	}
-	fmt.Fprintf(buf, "\n")
-}
-
-// DrawArrow between boxes
-func (p *Pen) DrawArrow() *Drawing {
-	drawing := &Drawing{
-		buf:   new(strings.Builder),
-		width: 1,
-	}
-	fmt.Fprintf(drawing.buf, "\x1b[%dm", p.color)
-	fmt.Fprintf(drawing.buf, "\u2b07")
-	fmt.Fprintf(drawing.buf, "\x1b[%dm", 0)
-	return drawing
-}
-
-// DrawBoxes to draw boxes
-func (p *Pen) DrawBoxes(labels ...string) *Drawing {
-	width := 0
-	for _, l := range labels {
-		width += len(l) + 2 + 2 + 1
-	}
-	drawing := &Drawing{
-		buf:   new(strings.Builder),
-		width: width,
-	}
-	p.drawTopBars(drawing.buf, labels...)
-	p.drawLabels(drawing.buf, labels...)
-	p.drawBottomBars(drawing.buf, labels...)
-
-	return drawing
-}
-
-// Draw to writer
-func (d *Drawing) Draw(writer io.Writer, centerOnWidth int) {
-	padSize := (centerOnWidth - d.GetWidth()) / 2
-	if padSize < 0 {
-		padSize = 0
-	}
-	for _, l := range strings.Split(d.buf.String(), "\n") {
-		if len(l) > 0 {
-			padding := strings.Repeat(" ", padSize)
-			fmt.Fprintf(writer, "%s%s\n", padding, l)
-		}
-	}
-}
-
-// GetWidth of drawing
-func (d *Drawing) GetWidth() int {
-	return d.width
-}

pkg/common/dryrun.go

@@ -1,25 +0,0 @@
-package common
-
-import (
-	"context"
-)
-
-type dryrunContextKey string
-
-const dryrunContextKeyVal = dryrunContextKey("dryrun")
-
-// Dryrun returns true if the current context is dryrun
-func Dryrun(ctx context.Context) bool {
-	val := ctx.Value(dryrunContextKeyVal)
-	if val != nil {
-		if dryrun, ok := val.(bool); ok {
-			return dryrun
-		}
-	}
-	return false
-}
-
-// WithDryrun adds a value to the context for dryrun
-func WithDryrun(ctx context.Context, dryrun bool) context.Context {
-	return context.WithValue(ctx, dryrunContextKeyVal, dryrun)
-}

pkg/common/executor.go

@@ -1,215 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"runtime/debug"
-
-	log "github.com/sirupsen/logrus"
-)
-
-// Warning that implements `error` but safe to ignore
-type Warning struct {
-	Message string
-}
-
-// Error the contract for error
-func (w Warning) Error() string {
-	return w.Message
-}
-
-// Warningf create a warning
-func Warningf(format string, args ...interface{}) Warning {
-	w := Warning{
-		Message: fmt.Sprintf(format, args...),
-	}
-	return w
-}
-
-// Executor define contract for the steps of a workflow
-type Executor func(ctx context.Context) error
-
-// Conditional define contract for the conditional predicate
-type Conditional func(ctx context.Context) bool
-
-// NewInfoExecutor is an executor that logs messages
-func NewInfoExecutor(format string, args ...interface{}) Executor {
-	return func(ctx context.Context) error {
-		logger := Logger(ctx)
-		logger.Infof(format, args...)
-		return nil
-	}
-}
-
-// NewDebugExecutor is an executor that logs messages
-func NewDebugExecutor(format string, args ...interface{}) Executor {
-	return func(ctx context.Context) error {
-		logger := Logger(ctx)
-		logger.Debugf(format, args...)
-		return nil
-	}
-}
-
-// NewPipelineExecutor creates a new executor from a series of other executors
-func NewPipelineExecutor(executors ...Executor) Executor {
-	if len(executors) == 0 {
-		return func(ctx context.Context) error {
-			return nil
-		}
-	}
-	var rtn Executor
-	for _, executor := range executors {
-		if rtn == nil {
-			rtn = executor
-		} else {
-			rtn = rtn.Then(executor)
-		}
-	}
-	return rtn
-}
-
-// NewConditionalExecutor creates a new executor based on conditions
-func NewConditionalExecutor(conditional Conditional, trueExecutor Executor, falseExecutor Executor) Executor {
-	return func(ctx context.Context) error {
-		if conditional(ctx) {
-			if trueExecutor != nil {
-				return trueExecutor(ctx)
-			}
-		} else {
-			if falseExecutor != nil {
-				return falseExecutor(ctx)
-			}
-		}
-		return nil
-	}
-}
-
-// NewErrorExecutor creates a new executor that always errors out
-func NewErrorExecutor(err error) Executor {
-	return func(ctx context.Context) error {
-		return err
-	}
-}
-
-// NewParallelExecutor creates a new executor from a parallel of other executors
-func NewParallelExecutor(parallel int, executors ...Executor) Executor {
-	return func(ctx context.Context) error {
-		work := make(chan Executor, len(executors))
-		errs := make(chan error, len(executors))
-
-		if 1 > parallel {
-			log.Debugf("Parallel tasks (%d) below minimum, setting to 1", parallel)
-			parallel = 1
-		}
-
-		log.Infof("NewParallelExecutor: Creating %d workers for %d executors", parallel, len(executors))
-
-		for i := 0; i < parallel; i++ {
-			go func(workerID int, work <-chan Executor, errs chan<- error) {
-				log.Debugf("Worker %d started", workerID)
-				taskCount := 0
-				for executor := range work {
-					taskCount++
-					log.Debugf("Worker %d executing task %d", workerID, taskCount)
-					// Recover from panics in executors to avoid crashing the worker
-					// goroutine which would leave the runner process hung.
-					// https://gitea.com/gitea/act_runner/issues/371
-					errs <- func() (err error) {
-						defer func() {
-							if r := recover(); r != nil {
-								log.Errorf("panic in executor: %v\n%s", r, debug.Stack())
-								err = fmt.Errorf("panic: %v", r)
-							}
-						}()
-						return executor(ctx)
-					}()
-				}
-				log.Debugf("Worker %d finished (%d tasks executed)", workerID, taskCount)
-			}(i, work, errs)
-		}
-
-		for i := 0; i < len(executors); i++ {
-			work <- executors[i]
-		}
-		close(work)
-
-		// Executor waits all executors to cleanup these resources.
-		var firstErr error
-		for i := 0; i < len(executors); i++ {
-			err := <-errs
-			if firstErr == nil {
-				firstErr = err
-			}
-		}
-
-		if err := ctx.Err(); err != nil {
-			return err
-		}
-		return firstErr
-	}
-}
-
-// Then runs another executor if this executor succeeds
-func (e Executor) Then(then Executor) Executor {
-	return func(ctx context.Context) error {
-		err := e(ctx)
-		if err != nil {
-			switch err.(type) {
-			case Warning:
-				Logger(ctx).Warning(err.Error())
-			default:
-				return err
-			}
-		}
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		return then(ctx)
-	}
-}
-
-// If only runs this executor if conditional is true
-func (e Executor) If(conditional Conditional) Executor {
-	return func(ctx context.Context) error {
-		if conditional(ctx) {
-			return e(ctx)
-		}
-		return nil
-	}
-}
-
-// IfNot only runs this executor if conditional is true
-func (e Executor) IfNot(conditional Conditional) Executor {
-	return func(ctx context.Context) error {
-		if !conditional(ctx) {
-			return e(ctx)
-		}
-		return nil
-	}
-}
-
-// IfBool only runs this executor if conditional is true
-func (e Executor) IfBool(conditional bool) Executor {
-	return e.If(func(ctx context.Context) bool {
-		return conditional
-	})
-}
-
-// Finally adds an executor to run after other executor
-func (e Executor) Finally(finally Executor) Executor {
-	return func(ctx context.Context) error {
-		err := e(ctx)
-		err2 := finally(ctx)
-		if err2 != nil {
-			return fmt.Errorf("Error occurred running finally: %v (original error: %v)", err2, err)
-		}
-		return err
-	}
-}
-
-// Not return an inverted conditional
-func (c Conditional) Not() Conditional {
-	return func(ctx context.Context) bool {
-		return !c(ctx)
-	}
-}

pkg/common/executor_max_parallel_test.go

@@ -1,86 +0,0 @@
-package common
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// Simple fast test that verifies max-parallel: 2 limits concurrency
-func TestMaxParallel2Quick(t *testing.T) {
-	ctx := context.Background()
-
-	var currentRunning int32
-	var maxSimultaneous int32
-
-	executors := make([]Executor, 4)
-	for i := 0; i < 4; i++ {
-		executors[i] = func(ctx context.Context) error {
-			current := atomic.AddInt32(&currentRunning, 1)
-
-			// Update max if needed
-			for {
-				maxValue := atomic.LoadInt32(&maxSimultaneous)
-				if current <= maxValue || atomic.CompareAndSwapInt32(&maxSimultaneous, maxValue, current) {
-					break
-				}
-			}
-
-			time.Sleep(10 * time.Millisecond)
-			atomic.AddInt32(&currentRunning, -1)
-			return nil
-		}
-	}
-
-	err := NewParallelExecutor(2, executors...)(ctx)
-
-	assert.NoError(t, err)
-	assert.LessOrEqual(t, atomic.LoadInt32(&maxSimultaneous), int32(2),
-		"Should not exceed max-parallel: 2")
-}
-
-// Test that verifies max-parallel: 1 enforces sequential execution
-func TestMaxParallel1Sequential(t *testing.T) {
-	ctx := context.Background()
-
-	var currentRunning int32
-	var maxSimultaneous int32
-	var executionOrder []int
-	var orderMutex sync.Mutex
-
-	executors := make([]Executor, 5)
-	for i := 0; i < 5; i++ {
-		taskID := i
-		executors[i] = func(ctx context.Context) error {
-			current := atomic.AddInt32(&currentRunning, 1)
-
-			// Track execution order
-			orderMutex.Lock()
-			executionOrder = append(executionOrder, taskID)
-			orderMutex.Unlock()
-
-			// Update max if needed
-			for {
-				maxValue := atomic.LoadInt32(&maxSimultaneous)
-				if current <= maxValue || atomic.CompareAndSwapInt32(&maxSimultaneous, maxValue, current) {
-					break
-				}
-			}
-
-			time.Sleep(20 * time.Millisecond)
-			atomic.AddInt32(&currentRunning, -1)
-			return nil
-		}
-	}
-
-	err := NewParallelExecutor(1, executors...)(ctx)
-
-	assert.NoError(t, err)
-	assert.Equal(t, int32(1), atomic.LoadInt32(&maxSimultaneous),
-		"max-parallel: 1 should only run 1 task at a time")
-	assert.Len(t, executionOrder, 5, "All 5 tasks should have executed")
-}

pkg/common/executor_parallel_advanced_test.go

@@ -1,280 +0,0 @@
-package common
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// TestMaxParallelJobExecution tests actual job execution with max-parallel
-func TestMaxParallelJobExecution(t *testing.T) {
-	t.Run("MaxParallel=1 Sequential", func(t *testing.T) {
-		var currentRunning int32
-		var maxConcurrent int32
-		var executionOrder []int
-		var mu sync.Mutex
-
-		executors := make([]Executor, 5)
-		for i := 0; i < 5; i++ {
-			taskID := i
-			executors[i] = func(ctx context.Context) error {
-				current := atomic.AddInt32(&currentRunning, 1)
-
-				// Track max concurrent
-				for {
-					max := atomic.LoadInt32(&maxConcurrent)
-					if current <= max || atomic.CompareAndSwapInt32(&maxConcurrent, max, current) {
-						break
-					}
-				}
-
-				mu.Lock()
-				executionOrder = append(executionOrder, taskID)
-				mu.Unlock()
-
-				time.Sleep(10 * time.Millisecond)
-				atomic.AddInt32(&currentRunning, -1)
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-		err := NewParallelExecutor(1, executors...)(ctx)
-		assert.NoError(t, err)
-
-		assert.Equal(t, int32(1), maxConcurrent, "Should never exceed 1 concurrent execution")
-		assert.Len(t, executionOrder, 5, "All tasks should execute")
-	})
-
-	t.Run("MaxParallel=3 Limited", func(t *testing.T) {
-		var currentRunning int32
-		var maxConcurrent int32
-
-		executors := make([]Executor, 10)
-		for i := 0; i < 10; i++ {
-			executors[i] = func(ctx context.Context) error {
-				current := atomic.AddInt32(&currentRunning, 1)
-
-				for {
-					max := atomic.LoadInt32(&maxConcurrent)
-					if current <= max || atomic.CompareAndSwapInt32(&maxConcurrent, max, current) {
-						break
-					}
-				}
-
-				time.Sleep(20 * time.Millisecond)
-				atomic.AddInt32(&currentRunning, -1)
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-		err := NewParallelExecutor(3, executors...)(ctx)
-		assert.NoError(t, err)
-
-		assert.LessOrEqual(t, int(maxConcurrent), 3, "Should never exceed 3 concurrent executions")
-		assert.GreaterOrEqual(t, int(maxConcurrent), 1, "Should have at least 1 concurrent execution")
-	})
-
-	t.Run("MaxParallel=0 Uses1Worker", func(t *testing.T) {
-		var maxConcurrent int32
-		var currentRunning int32
-
-		executors := make([]Executor, 5)
-		for i := 0; i < 5; i++ {
-			executors[i] = func(ctx context.Context) error {
-				current := atomic.AddInt32(&currentRunning, 1)
-
-				for {
-					max := atomic.LoadInt32(&maxConcurrent)
-					if current <= max || atomic.CompareAndSwapInt32(&maxConcurrent, max, current) {
-						break
-					}
-				}
-
-				time.Sleep(10 * time.Millisecond)
-				atomic.AddInt32(&currentRunning, -1)
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-		// When maxParallel is 0 or negative, it defaults to 1
-		err := NewParallelExecutor(0, executors...)(ctx)
-		assert.NoError(t, err)
-
-		assert.Equal(t, int32(1), maxConcurrent, "Should use 1 worker when max-parallel is 0")
-	})
-}
-
-// TestMaxParallelWithErrors tests error handling with max-parallel
-func TestMaxParallelWithErrors(t *testing.T) {
-	t.Run("OneTaskFailsOthersContinue", func(t *testing.T) {
-		var successCount int32
-
-		executors := make([]Executor, 5)
-		for i := 0; i < 5; i++ {
-			taskID := i
-			executors[i] = func(ctx context.Context) error {
-				if taskID == 2 {
-					return assert.AnError
-				}
-				atomic.AddInt32(&successCount, 1)
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-		err := NewParallelExecutor(2, executors...)(ctx)
-
-		// Should return the error from task 2
-		assert.Error(t, err)
-
-		// Other tasks should still execute
-		assert.Equal(t, int32(4), successCount, "4 tasks should succeed")
-	})
-
-	t.Run("ContextCancellation", func(t *testing.T) {
-		ctx, cancel := context.WithCancel(context.Background())
-
-		var startedCount int32
-		executors := make([]Executor, 10)
-		for i := 0; i < 10; i++ {
-			executors[i] = func(ctx context.Context) error {
-				atomic.AddInt32(&startedCount, 1)
-				time.Sleep(100 * time.Millisecond)
-				return nil
-			}
-		}
-
-		// Cancel after a short delay
-		go func() {
-			time.Sleep(30 * time.Millisecond)
-			cancel()
-		}()
-
-		err := NewParallelExecutor(3, executors...)(ctx)
-		assert.Error(t, err)
-		assert.ErrorIs(t, err, context.Canceled)
-
-		// Not all tasks should start due to cancellation (but timing may vary)
-		// Just verify cancellation occurred
-		t.Logf("Started %d tasks before cancellation", startedCount)
-	})
-}
-
-// TestMaxParallelPerformance tests performance characteristics
-func TestMaxParallelPerformance(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping performance test in short mode")
-	}
-
-	t.Run("ParallelFasterThanSequential", func(t *testing.T) {
-		executors := make([]Executor, 10)
-		for i := 0; i < 10; i++ {
-			executors[i] = func(ctx context.Context) error {
-				time.Sleep(50 * time.Millisecond)
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-
-		// Sequential (max-parallel=1)
-		start := time.Now()
-		err := NewParallelExecutor(1, executors...)(ctx)
-		sequentialDuration := time.Since(start)
-		assert.NoError(t, err)
-
-		// Parallel (max-parallel=5)
-		start = time.Now()
-		err = NewParallelExecutor(5, executors...)(ctx)
-		parallelDuration := time.Since(start)
-		assert.NoError(t, err)
-
-		// Parallel should be significantly faster
-		assert.Less(t, parallelDuration, sequentialDuration/2,
-			"Parallel execution should be at least 2x faster")
-	})
-
-	t.Run("OptimalWorkerCount", func(t *testing.T) {
-		executors := make([]Executor, 20)
-		for i := 0; i < 20; i++ {
-			executors[i] = func(ctx context.Context) error {
-				time.Sleep(10 * time.Millisecond)
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-
-		// Test with different worker counts
-		workerCounts := []int{1, 2, 5, 10, 20}
-		durations := make(map[int]time.Duration)
-
-		for _, count := range workerCounts {
-			start := time.Now()
-			err := NewParallelExecutor(count, executors...)(ctx)
-			durations[count] = time.Since(start)
-			assert.NoError(t, err)
-		}
-
-		// More workers should generally be faster (up to a point)
-		assert.Less(t, durations[5], durations[1], "5 workers should be faster than 1")
-		assert.Less(t, durations[10], durations[2], "10 workers should be faster than 2")
-	})
-}
-
-// TestMaxParallelResourceSharing tests resource sharing scenarios
-func TestMaxParallelResourceSharing(t *testing.T) {
-	t.Run("SharedResourceWithMutex", func(t *testing.T) {
-		var sharedCounter int
-		var mu sync.Mutex
-
-		executors := make([]Executor, 100)
-		for i := 0; i < 100; i++ {
-			executors[i] = func(ctx context.Context) error {
-				mu.Lock()
-				sharedCounter++
-				mu.Unlock()
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-		err := NewParallelExecutor(10, executors...)(ctx)
-		assert.NoError(t, err)
-
-		assert.Equal(t, 100, sharedCounter, "All tasks should increment counter")
-	})
-
-	t.Run("ChannelCommunication", func(t *testing.T) {
-		resultChan := make(chan int, 50)
-
-		executors := make([]Executor, 50)
-		for i := 0; i < 50; i++ {
-			taskID := i
-			executors[i] = func(ctx context.Context) error {
-				resultChan <- taskID
-				return nil
-			}
-		}
-
-		ctx := context.Background()
-		err := NewParallelExecutor(5, executors...)(ctx)
-		assert.NoError(t, err)
-
-		close(resultChan)
-
-		results := make(map[int]bool)
-		for result := range resultChan {
-			results[result] = true
-		}
-
-		assert.Len(t, results, 50, "All task IDs should be received")
-	})
-}

pkg/common/executor_test.go

@@ -1,152 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewWorkflow(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx := context.Background()
-
-	// empty
-	emptyWorkflow := NewPipelineExecutor()
-	assert.Nil(emptyWorkflow(ctx))
-
-	// error case
-	errorWorkflow := NewErrorExecutor(fmt.Errorf("test error"))
-	assert.NotNil(errorWorkflow(ctx))
-
-	// multiple success case
-	runcount := 0
-	successWorkflow := NewPipelineExecutor(
-		func(ctx context.Context) error {
-			runcount++
-			return nil
-		},
-		func(ctx context.Context) error {
-			runcount++
-			return nil
-		})
-	assert.Nil(successWorkflow(ctx))
-	assert.Equal(2, runcount)
-}
-
-func TestNewConditionalExecutor(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx := context.Background()
-
-	trueCount := 0
-	falseCount := 0
-
-	err := NewConditionalExecutor(func(ctx context.Context) bool {
-		return false
-	}, func(ctx context.Context) error {
-		trueCount++
-		return nil
-	}, func(ctx context.Context) error {
-		falseCount++
-		return nil
-	})(ctx)
-
-	assert.Nil(err)
-	assert.Equal(0, trueCount)
-	assert.Equal(1, falseCount)
-
-	err = NewConditionalExecutor(func(ctx context.Context) bool {
-		return true
-	}, func(ctx context.Context) error {
-		trueCount++
-		return nil
-	}, func(ctx context.Context) error {
-		falseCount++
-		return nil
-	})(ctx)
-
-	assert.Nil(err)
-	assert.Equal(1, trueCount)
-	assert.Equal(1, falseCount)
-}
-
-func TestNewParallelExecutor(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx := context.Background()
-
-	count := 0
-	activeCount := 0
-	maxCount := 0
-	emptyWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
-		count++
-
-		activeCount++
-		if activeCount > maxCount {
-			maxCount = activeCount
-		}
-		time.Sleep(2 * time.Second)
-		activeCount--
-
-		return nil
-	})
-
-	err := NewParallelExecutor(2, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
-
-	assert.Equal(3, count, "should run all 3 executors")
-	assert.Equal(2, maxCount, "should run at most 2 executors in parallel")
-	assert.Nil(err)
-
-	// Reset to test running the executor with 0 parallelism
-	count = 0
-	activeCount = 0
-	maxCount = 0
-
-	errSingle := NewParallelExecutor(0, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
-
-	assert.Equal(3, count, "should run all 3 executors")
-	assert.Equal(1, maxCount, "should run at most 1 executors in parallel")
-	assert.Nil(errSingle)
-}
-
-func TestNewParallelExecutorFailed(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	count := 0
-	errorWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
-		count++
-		return fmt.Errorf("fake error")
-	})
-	err := NewParallelExecutor(1, errorWorkflow)(ctx)
-	assert.Equal(1, count)
-	assert.ErrorIs(context.Canceled, err)
-}
-
-func TestNewParallelExecutorCanceled(t *testing.T) {
-	assert := assert.New(t)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-
-	errExpected := fmt.Errorf("fake error")
-
-	count := 0
-	successWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
-		count++
-		return nil
-	})
-	errorWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
-		count++
-		return errExpected
-	})
-	err := NewParallelExecutor(3, errorWorkflow, successWorkflow, successWorkflow)(ctx)
-	assert.Equal(3, count)
-	assert.Error(errExpected, err)
-}

pkg/common/file.go

@@ -1,73 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"io"
-	"os"
-)
-
-// CopyFile copy file
-func CopyFile(source string, dest string) (err error) {
-	sourcefile, err := os.Open(source)
-	if err != nil {
-		return err
-	}
-
-	defer sourcefile.Close()
-
-	destfile, err := os.Create(dest)
-	if err != nil {
-		return err
-	}
-
-	defer destfile.Close()
-
-	_, err = io.Copy(destfile, sourcefile)
-	if err == nil {
-		sourceinfo, err := os.Stat(source)
-		if err != nil {
-			_ = os.Chmod(dest, sourceinfo.Mode())
-		}
-	}
-
-	return
-}
-
-// CopyDir recursive copy of directory
-func CopyDir(source string, dest string) (err error) {
-	// get properties of source dir
-	sourceinfo, err := os.Stat(source)
-	if err != nil {
-		return err
-	}
-
-	// create dest dir
-
-	err = os.MkdirAll(dest, sourceinfo.Mode())
-	if err != nil {
-		return err
-	}
-
-	objects, err := os.ReadDir(source)
-
-	for _, obj := range objects {
-		sourcefilepointer := source + "/" + obj.Name()
-
-		destinationfilepointer := dest + "/" + obj.Name()
-
-		if obj.IsDir() {
-			// create sub-directories - recursively
-			err = CopyDir(sourcefilepointer, destinationfilepointer)
-			if err != nil {
-				fmt.Println(err)
-			}
-		} else {
-			// perform copy
-			err = CopyFile(sourcefilepointer, destinationfilepointer)
-			if err != nil {
-				fmt.Println(err)
-			}
-		}
-	}
-	return err
-}

pkg/common/git/git.go

@@ -1,418 +0,0 @@
-package git
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"regexp"
-	"strings"
-	"sync"
-
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/config"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/storer"
-	"github.com/go-git/go-git/v5/plumbing/transport/http"
-	"github.com/mattn/go-isatty"
-	log "github.com/sirupsen/logrus"
-
-	"github.com/nektos/act/pkg/common"
-)
-
-var (
-	codeCommitHTTPRegex = regexp.MustCompile(`^https?://git-codecommit\.(.+)\.amazonaws.com/v1/repos/(.+)$`)
-	codeCommitSSHRegex  = regexp.MustCompile(`ssh://git-codecommit\.(.+)\.amazonaws.com/v1/repos/(.+)$`)
-	githubHTTPRegex     = regexp.MustCompile(`^https?://.*github.com.*/(.+)/(.+?)(?:.git)?$`)
-	githubSSHRegex      = regexp.MustCompile(`github.com[:/](.+)/(.+?)(?:.git)?$`)
-
-	cloneLock sync.Mutex
-
-	ErrShortRef = errors.New("short SHA references are not supported")
-	ErrNoRepo   = errors.New("unable to find git repo")
-)
-
-type Error struct {
-	err    error
-	commit string
-}
-
-func (e *Error) Error() string {
-	return e.err.Error()
-}
-
-func (e *Error) Unwrap() error {
-	return e.err
-}
-
-func (e *Error) Commit() string {
-	return e.commit
-}
-
-// FindGitRevision get the current git revision
-func FindGitRevision(ctx context.Context, file string) (shortSha string, sha string, err error) {
-	logger := common.Logger(ctx)
-
-	gitDir, err := git.PlainOpenWithOptions(
-		file,
-		&git.PlainOpenOptions{
-			DetectDotGit:          true,
-			EnableDotGitCommonDir: true,
-		},
-	)
-
-	if err != nil {
-		logger.WithError(err).Error("path", file, "not located inside a git repository")
-		return "", "", err
-	}
-
-	head, err := gitDir.Reference(plumbing.HEAD, true)
-	if err != nil {
-		return "", "", err
-	}
-
-	if head.Hash().IsZero() {
-		return "", "", fmt.Errorf("HEAD sha1 could not be resolved")
-	}
-
-	hash := head.Hash().String()
-
-	logger.Debugf("Found revision: %s", hash)
-	return hash[:7], strings.TrimSpace(hash), nil
-}
-
-// FindGitRef get the current git ref
-func FindGitRef(ctx context.Context, file string) (string, error) {
-	logger := common.Logger(ctx)
-
-	logger.Debugf("Loading revision from git directory")
-	_, ref, err := FindGitRevision(ctx, file)
-	if err != nil {
-		return "", err
-	}
-
-	logger.Debugf("HEAD points to '%s'", ref)
-
-	// Prefer the git library to iterate over the references and find a matching tag or branch.
-	var refTag = ""
-	var refBranch = ""
-	repo, err := git.PlainOpenWithOptions(
-		file,
-		&git.PlainOpenOptions{
-			DetectDotGit:          true,
-			EnableDotGitCommonDir: true,
-		},
-	)
-
-	if err != nil {
-		return "", err
-	}
-
-	iter, err := repo.References()
-	if err != nil {
-		return "", err
-	}
-
-	// find the reference that matches the revision's has
-	err = iter.ForEach(func(r *plumbing.Reference) error {
-		/* tags and branches will have the same hash
-		 * when a user checks out a tag, it is not mentioned explicitly
-		 * in the go-git package, we must identify the revision
-		 * then check if any tag matches that revision,
-		 * if so then we checked out a tag
-		 * else we look for branches and if matches,
-		 * it means we checked out a branch
-		 *
-		 * If a branches matches first we must continue and check all tags (all references)
-		 * in case we match with a tag later in the interation
-		 */
-		if r.Hash().String() == ref {
-			if r.Name().IsTag() {
-				refTag = r.Name().String()
-			}
-			if r.Name().IsBranch() {
-				refBranch = r.Name().String()
-			}
-		}
-
-		// we found what we where looking for
-		if refTag != "" && refBranch != "" {
-			return storer.ErrStop
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		return "", err
-	}
-
-	// order matters here see above comment.
-	if refTag != "" {
-		return refTag, nil
-	}
-	if refBranch != "" {
-		return refBranch, nil
-	}
-
-	return "", fmt.Errorf("failed to identify reference (tag/branch) for the checked-out revision '%s'", ref)
-}
-
-// FindGithubRepo get the repo
-func FindGithubRepo(ctx context.Context, file, githubInstance, remoteName string) (string, error) {
-	if remoteName == "" {
-		remoteName = "origin"
-	}
-
-	url, err := findGitRemoteURL(ctx, file, remoteName)
-	if err != nil {
-		return "", err
-	}
-	_, slug, err := findGitSlug(url, githubInstance)
-	return slug, err
-}
-
-func findGitRemoteURL(_ context.Context, file, remoteName string) (string, error) {
-	repo, err := git.PlainOpenWithOptions(
-		file,
-		&git.PlainOpenOptions{
-			DetectDotGit:          true,
-			EnableDotGitCommonDir: true,
-		},
-	)
-	if err != nil {
-		return "", err
-	}
-
-	remote, err := repo.Remote(remoteName)
-	if err != nil {
-		return "", err
-	}
-
-	if len(remote.Config().URLs) < 1 {
-		return "", fmt.Errorf("remote '%s' exists but has no URL", remoteName)
-	}
-
-	return remote.Config().URLs[0], nil
-}
-
-func findGitSlug(url string, githubInstance string) (string, string, error) {
-	if matches := codeCommitHTTPRegex.FindStringSubmatch(url); matches != nil {
-		return "CodeCommit", matches[2], nil
-	} else if matches := codeCommitSSHRegex.FindStringSubmatch(url); matches != nil {
-		return "CodeCommit", matches[2], nil
-	} else if matches := githubHTTPRegex.FindStringSubmatch(url); matches != nil {
-		return "GitHub", fmt.Sprintf("%s/%s", matches[1], matches[2]), nil
-	} else if matches := githubSSHRegex.FindStringSubmatch(url); matches != nil {
-		return "GitHub", fmt.Sprintf("%s/%s", matches[1], matches[2]), nil
-	} else if githubInstance != "github.com" {
-		gheHTTPRegex := regexp.MustCompile(fmt.Sprintf(`^https?://%s/(.+)/(.+?)(?:.git)?$`, githubInstance))
-		gheSSHRegex := regexp.MustCompile(fmt.Sprintf(`%s[:/](.+)/(.+?)(?:.git)?$`, githubInstance))
-		if matches := gheHTTPRegex.FindStringSubmatch(url); matches != nil {
-			return "GitHubEnterprise", fmt.Sprintf("%s/%s", matches[1], matches[2]), nil
-		} else if matches := gheSSHRegex.FindStringSubmatch(url); matches != nil {
-			return "GitHubEnterprise", fmt.Sprintf("%s/%s", matches[1], matches[2]), nil
-		}
-	}
-	return "", url, nil
-}
-
-// NewGitCloneExecutorInput the input for the NewGitCloneExecutor
-type NewGitCloneExecutorInput struct {
-	URL         string
-	Ref         string
-	Dir         string
-	Token       string
-	OfflineMode bool
-
-	// For Gitea
-	InsecureSkipTLS bool
-}
-
-// CloneIfRequired ...
-func CloneIfRequired(ctx context.Context, refName plumbing.ReferenceName, input NewGitCloneExecutorInput, logger log.FieldLogger) (*git.Repository, error) {
-	r, err := git.PlainOpen(input.Dir)
-	if err != nil {
-		var progressWriter io.Writer
-		if isatty.IsTerminal(os.Stdout.Fd()) || isatty.IsCygwinTerminal(os.Stdout.Fd()) {
-			if entry, ok := logger.(*log.Entry); ok {
-				progressWriter = entry.WriterLevel(log.DebugLevel)
-			} else if lgr, ok := logger.(*log.Logger); ok {
-				progressWriter = lgr.WriterLevel(log.DebugLevel)
-			} else {
-				log.Errorf("Unable to get writer from logger (type=%T)", logger)
-				progressWriter = os.Stdout
-			}
-		}
-
-		cloneOptions := git.CloneOptions{
-			URL:      input.URL,
-			Progress: progressWriter,
-
-			InsecureSkipTLS: input.InsecureSkipTLS, // For Gitea
-		}
-		if input.Token != "" {
-			cloneOptions.Auth = &http.BasicAuth{
-				Username: "token",
-				Password: input.Token,
-			}
-		}
-
-		r, err = git.PlainCloneContext(ctx, input.Dir, false, &cloneOptions)
-		if err != nil {
-			logger.Errorf("Unable to clone %v %s: %v", input.URL, refName, err)
-			return nil, err
-		}
-
-		if err = os.Chmod(input.Dir, 0o755); err != nil {
-			return nil, err
-		}
-	}
-
-	return r, nil
-}
-
-func gitOptions(token string) (fetchOptions git.FetchOptions, pullOptions git.PullOptions) {
-	fetchOptions.RefSpecs = []config.RefSpec{"refs/*:refs/*", "HEAD:refs/heads/HEAD"}
-	pullOptions.Force = true
-
-	if token != "" {
-		auth := &http.BasicAuth{
-			Username: "token",
-			Password: token,
-		}
-		fetchOptions.Auth = auth
-		pullOptions.Auth = auth
-	}
-
-	return fetchOptions, pullOptions
-}
-
-// NewGitCloneExecutor creates an executor to clone git repos
-//
-//nolint:gocyclo
-func NewGitCloneExecutor(input NewGitCloneExecutorInput) common.Executor {
-	return func(ctx context.Context) error {
-		logger := common.Logger(ctx)
-		logger.Infof("  \u2601  git clone '%s' # ref=%s", input.URL, input.Ref)
-		logger.Debugf("  cloning %s to %s", input.URL, input.Dir)
-
-		cloneLock.Lock()
-		defer cloneLock.Unlock()
-
-		refName := plumbing.ReferenceName(fmt.Sprintf("refs/heads/%s", input.Ref))
-		r, err := CloneIfRequired(ctx, refName, input, logger)
-		if err != nil {
-			return err
-		}
-
-		isOfflineMode := input.OfflineMode
-
-		// fetch latest changes
-		fetchOptions, pullOptions := gitOptions(input.Token)
-
-		if input.InsecureSkipTLS { // For Gitea
-			fetchOptions.InsecureSkipTLS = true
-			pullOptions.InsecureSkipTLS = true
-		}
-
-		if !isOfflineMode {
-			err = r.Fetch(&fetchOptions)
-			if err != nil && !errors.Is(err, git.NoErrAlreadyUpToDate) {
-				return err
-			}
-		}
-
-		var hash *plumbing.Hash
-		rev := plumbing.Revision(input.Ref)
-		if hash, err = r.ResolveRevision(rev); err != nil {
-			logger.Errorf("Unable to resolve %s: %v", input.Ref, err)
-		}
-
-		if hash.String() != input.Ref && strings.HasPrefix(hash.String(), input.Ref) {
-			return &Error{
-				err:    ErrShortRef,
-				commit: hash.String(),
-			}
-		}
-
-		// At this point we need to know if it's a tag or a branch
-		// And the easiest way to do it is duck typing
-		//
-		// If err is nil, it's a tag so let's proceed with that hash like we would if
-		// it was a sha
-		refType := "tag"
-		rev = plumbing.Revision(path.Join("refs", "tags", input.Ref))
-		if _, err := r.Tag(input.Ref); errors.Is(err, git.ErrTagNotFound) {
-			rName := plumbing.ReferenceName(path.Join("refs", "remotes", "origin", input.Ref))
-			if _, err := r.Reference(rName, false); errors.Is(err, plumbing.ErrReferenceNotFound) {
-				refType = "sha"
-				rev = plumbing.Revision(input.Ref)
-			} else {
-				refType = "branch"
-				rev = plumbing.Revision(rName)
-			}
-		}
-
-		if hash, err = r.ResolveRevision(rev); err != nil {
-			logger.Errorf("Unable to resolve %s: %v", input.Ref, err)
-			return err
-		}
-
-		var w *git.Worktree
-		if w, err = r.Worktree(); err != nil {
-			return err
-		}
-
-		// If the hash resolved doesn't match the ref provided in a workflow then we're
-		// using a branch or tag ref, not a sha
-		//
-		// Repos on disk point to commit hashes, and need to checkout input.Ref before
-		// we try and pull down any changes
-		if hash.String() != input.Ref && refType == "branch" {
-			logger.Debugf("Provided ref is not a sha. Checking out branch before pulling changes")
-			sourceRef := plumbing.ReferenceName(path.Join("refs", "remotes", "origin", input.Ref))
-			if err = w.Checkout(&git.CheckoutOptions{
-				Branch: sourceRef,
-				Force:  true,
-			}); err != nil {
-				logger.Errorf("Unable to checkout %s: %v", sourceRef, err)
-				return err
-			}
-		}
-		if !isOfflineMode {
-			if err = w.Pull(&pullOptions); err != nil && err != git.NoErrAlreadyUpToDate {
-				logger.Debugf("Unable to pull %s: %v", refName, err)
-			}
-		}
-		logger.Debugf("Cloned %s to %s", input.URL, input.Dir)
-
-		if hash.String() != input.Ref && refType == "branch" {
-			logger.Debugf("Provided ref is not a sha. Updating branch ref after pull")
-			if hash, err = r.ResolveRevision(rev); err != nil {
-				logger.Errorf("Unable to resolve %s: %v", input.Ref, err)
-				return err
-			}
-		}
-		if err = w.Checkout(&git.CheckoutOptions{
-			Hash:  *hash,
-			Force: true,
-		}); err != nil {
-			logger.Errorf("Unable to checkout %s: %v", *hash, err)
-			return err
-		}
-
-		if err = w.Reset(&git.ResetOptions{
-			Mode:   git.HardReset,
-			Commit: *hash,
-		}); err != nil {
-			logger.Errorf("Unable to reset to %s: %v", hash.String(), err)
-			return err
-		}
-
-		logger.Debugf("Checked out %s", input.Ref)
-		return nil
-	}
-}

pkg/common/git/git_test.go

@@ -1,249 +0,0 @@
-package git
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"syscall"
-	"testing"
-
-	log "github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestFindGitSlug(t *testing.T) {
-	assert := assert.New(t)
-
-	var slugTests = []struct {
-		url      string // input
-		provider string // expected result
-		slug     string // expected result
-	}{
-		{"https://git-codecommit.us-east-1.amazonaws.com/v1/repos/my-repo-name", "CodeCommit", "my-repo-name"},
-		{"ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/my-repo", "CodeCommit", "my-repo"},
-		{"[email protected]:nektos/act.git", "GitHub", "nektos/act"},
-		{"[email protected]:nektos/act", "GitHub", "nektos/act"},
-		{"https://github.com/nektos/act.git", "GitHub", "nektos/act"},
-		{"http://github.com/nektos/act.git", "GitHub", "nektos/act"},
-		{"https://github.com/nektos/act", "GitHub", "nektos/act"},
-		{"http://github.com/nektos/act", "GitHub", "nektos/act"},
-		{"git+ssh://[email protected]/owner/repo.git", "GitHub", "owner/repo"},
-		{"http://myotherrepo.com/act.git", "", "http://myotherrepo.com/act.git"},
-	}
-
-	for _, tt := range slugTests {
-		provider, slug, err := findGitSlug(tt.url, "github.com")
-
-		assert.NoError(err)
-		assert.Equal(tt.provider, provider)
-		assert.Equal(tt.slug, slug)
-	}
-}
-
-func testDir(t *testing.T) string {
-	basedir, err := os.MkdirTemp("", "act-test")
-	require.NoError(t, err)
-	t.Cleanup(func() { _ = os.RemoveAll(basedir) })
-	return basedir
-}
-
-func cleanGitHooks(dir string) error {
-	hooksDir := filepath.Join(dir, ".git", "hooks")
-	files, err := os.ReadDir(hooksDir)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		return err
-	}
-	for _, f := range files {
-		if f.IsDir() {
-			continue
-		}
-		relName := filepath.Join(hooksDir, f.Name())
-		if err := os.Remove(relName); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func TestFindGitRemoteURL(t *testing.T) {
-	assert := assert.New(t)
-
-	basedir := testDir(t)
-	gitConfig()
-	err := gitCmd("init", basedir)
-	assert.NoError(err)
-	err = cleanGitHooks(basedir)
-	assert.NoError(err)
-
-	remoteURL := "https://git-codecommit.us-east-1.amazonaws.com/v1/repos/my-repo-name"
-	err = gitCmd("-C", basedir, "remote", "add", "origin", remoteURL)
-	assert.NoError(err)
-
-	u, err := findGitRemoteURL(context.Background(), basedir, "origin")
-	assert.NoError(err)
-	assert.Equal(remoteURL, u)
-
-	remoteURL = "[email protected]/AwesomeOwner/MyAwesomeRepo.git"
-	err = gitCmd("-C", basedir, "remote", "add", "upstream", remoteURL)
-	assert.NoError(err)
-	u, err = findGitRemoteURL(context.Background(), basedir, "upstream")
-	assert.NoError(err)
-	assert.Equal(remoteURL, u)
-}
-
-func TestGitFindRef(t *testing.T) {
-	basedir := testDir(t)
-	gitConfig()
-
-	for name, tt := range map[string]struct {
-		Prepare func(t *testing.T, dir string)
-		Assert  func(t *testing.T, ref string, err error)
-	}{
-		"new_repo": {
-			Prepare: func(t *testing.T, dir string) {},
-			Assert: func(t *testing.T, ref string, err error) {
-				require.Error(t, err)
-			},
-		},
-		"new_repo_with_commit": {
-			Prepare: func(t *testing.T, dir string) {
-				require.NoError(t, gitCmd("-C", dir, "commit", "--allow-empty", "-m", "msg"))
-			},
-			Assert: func(t *testing.T, ref string, err error) {
-				require.NoError(t, err)
-				require.Equal(t, "refs/heads/master", ref)
-			},
-		},
-		"current_head_is_tag": {
-			Prepare: func(t *testing.T, dir string) {
-				require.NoError(t, gitCmd("-C", dir, "commit", "--allow-empty", "-m", "commit msg"))
-				require.NoError(t, gitCmd("-C", dir, "tag", "v1.2.3"))
-				require.NoError(t, gitCmd("-C", dir, "checkout", "v1.2.3"))
-			},
-			Assert: func(t *testing.T, ref string, err error) {
-				require.NoError(t, err)
-				require.Equal(t, "refs/tags/v1.2.3", ref)
-			},
-		},
-		"current_head_is_same_as_tag": {
-			Prepare: func(t *testing.T, dir string) {
-				require.NoError(t, gitCmd("-C", dir, "commit", "--allow-empty", "-m", "1.4.2 release"))
-				require.NoError(t, gitCmd("-C", dir, "tag", "v1.4.2"))
-			},
-			Assert: func(t *testing.T, ref string, err error) {
-				require.NoError(t, err)
-				require.Equal(t, "refs/tags/v1.4.2", ref)
-			},
-		},
-		"current_head_is_not_tag": {
-			Prepare: func(t *testing.T, dir string) {
-				require.NoError(t, gitCmd("-C", dir, "commit", "--allow-empty", "-m", "msg"))
-				require.NoError(t, gitCmd("-C", dir, "tag", "v1.4.2"))
-				require.NoError(t, gitCmd("-C", dir, "commit", "--allow-empty", "-m", "msg2"))
-			},
-			Assert: func(t *testing.T, ref string, err error) {
-				require.NoError(t, err)
-				require.Equal(t, "refs/heads/master", ref)
-			},
-		},
-		"current_head_is_another_branch": {
-			Prepare: func(t *testing.T, dir string) {
-				require.NoError(t, gitCmd("-C", dir, "checkout", "-b", "mybranch"))
-				require.NoError(t, gitCmd("-C", dir, "commit", "--allow-empty", "-m", "msg"))
-			},
-			Assert: func(t *testing.T, ref string, err error) {
-				require.NoError(t, err)
-				require.Equal(t, "refs/heads/mybranch", ref)
-			},
-		},
-	} {
-		tt := tt
-		name := name
-		t.Run(name, func(t *testing.T) {
-			dir := filepath.Join(basedir, name)
-			require.NoError(t, os.MkdirAll(dir, 0o755))
-			require.NoError(t, gitCmd("-C", dir, "init", "--initial-branch=master"))
-			require.NoError(t, cleanGitHooks(dir))
-			tt.Prepare(t, dir)
-			ref, err := FindGitRef(context.Background(), dir)
-			tt.Assert(t, ref, err)
-		})
-	}
-}
-
-func TestGitCloneExecutor(t *testing.T) {
-	for name, tt := range map[string]struct {
-		Err      error
-		URL, Ref string
-	}{
-		"tag": {
-			Err: nil,
-			URL: "https://github.com/actions/checkout",
-			Ref: "v2",
-		},
-		"branch": {
-			Err: nil,
-			URL: "https://github.com/anchore/scan-action",
-			Ref: "act-fails",
-		},
-		"sha": {
-			Err: nil,
-			URL: "https://github.com/actions/checkout",
-			Ref: "5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f", // v2
-		},
-		"short-sha": {
-			Err: &Error{ErrShortRef, "5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f"},
-			URL: "https://github.com/actions/checkout",
-			Ref: "5a4ac90", // v2
-		},
-	} {
-		t.Run(name, func(t *testing.T) {
-			clone := NewGitCloneExecutor(NewGitCloneExecutorInput{
-				URL: tt.URL,
-				Ref: tt.Ref,
-				Dir: testDir(t),
-			})
-
-			err := clone(context.Background())
-			if tt.Err != nil {
-				assert.Error(t, err)
-				assert.Equal(t, tt.Err, err)
-			} else {
-				assert.Empty(t, err)
-			}
-		})
-	}
-}
-
-func gitConfig() {
-	if os.Getenv("GITHUB_ACTIONS") == "true" {
-		var err error
-		if err = gitCmd("config", "--global", "user.email", "[email protected]"); err != nil {
-			log.Error(err)
-		}
-		if err = gitCmd("config", "--global", "user.name", "Unit Test"); err != nil {
-			log.Error(err)
-		}
-	}
-}
-
-func gitCmd(args ...string) error {
-	cmd := exec.Command("git", args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	err := cmd.Run()
-	if exitError, ok := err.(*exec.ExitError); ok {
-		if waitStatus, ok := exitError.Sys().(syscall.WaitStatus); ok {
-			return fmt.Errorf("Exit error %d", waitStatus.ExitStatus())
-		}
-		return exitError
-	}
-	return nil
-}

pkg/common/job_error.go

@@ -1,30 +0,0 @@
-package common
-
-import (
-	"context"
-)
-
-type jobErrorContextKey string
-
-const jobErrorContextKeyVal = jobErrorContextKey("job.error")
-
-// JobError returns the job error for current context if any
-func JobError(ctx context.Context) error {
-	val := ctx.Value(jobErrorContextKeyVal)
-	if val != nil {
-		if container, ok := val.(map[string]error); ok {
-			return container["error"]
-		}
-	}
-	return nil
-}
-
-func SetJobError(ctx context.Context, err error) {
-	ctx.Value(jobErrorContextKeyVal).(map[string]error)["error"] = err
-}
-
-// WithJobErrorContainer adds a value to the context as a container for an error
-func WithJobErrorContainer(ctx context.Context) context.Context {
-	container := map[string]error{}
-	return context.WithValue(ctx, jobErrorContextKeyVal, container)
-}

pkg/common/line_writer.go

@@ -1,50 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"io"
-)
-
-// LineHandler is a callback function for handling a line
-type LineHandler func(line string) bool
-
-type lineWriter struct {
-	buffer   bytes.Buffer
-	handlers []LineHandler
-}
-
-// NewLineWriter creates a new instance of a line writer
-func NewLineWriter(handlers ...LineHandler) io.Writer {
-	w := new(lineWriter)
-	w.handlers = handlers
-	return w
-}
-
-func (lw *lineWriter) Write(p []byte) (n int, err error) {
-	pBuf := bytes.NewBuffer(p)
-	written := 0
-	for {
-		line, err := pBuf.ReadString('\n')
-		w, _ := lw.buffer.WriteString(line)
-		written += w
-		if err == nil {
-			lw.handleLine(lw.buffer.String())
-			lw.buffer.Reset()
-		} else if err == io.EOF {
-			break
-		} else {
-			return written, err
-		}
-	}
-
-	return written, nil
-}
-
-func (lw *lineWriter) handleLine(line string) {
-	for _, h := range lw.handlers {
-		ok := h(line)
-		if !ok {
-			break
-		}
-	}
-}

pkg/common/line_writer_test.go

@@ -1,37 +0,0 @@
-package common
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestLineWriter(t *testing.T) {
-	lines := make([]string, 0)
-	lineHandler := func(s string) bool {
-		lines = append(lines, s)
-		return true
-	}
-
-	lineWriter := NewLineWriter(lineHandler)
-
-	assert := assert.New(t)
-	write := func(s string) {
-		n, err := lineWriter.Write([]byte(s))
-		assert.NoError(err)
-		assert.Equal(len(s), n, s)
-	}
-
-	write("hello")
-	write(" ")
-	write("world!!\nextra")
-	write(" line\n and another\nlast")
-	write(" line\n")
-	write("no newline here...")
-
-	assert.Len(lines, 4)
-	assert.Equal("hello world!!\n", lines[0])
-	assert.Equal("extra line\n", lines[1])
-	assert.Equal(" and another\n", lines[2])
-	assert.Equal("last line\n", lines[3])
-}

pkg/common/logger.go

@@ -1,48 +0,0 @@
-package common
-
-import (
-	"context"
-
-	"github.com/sirupsen/logrus"
-)
-
-type loggerContextKey string
-
-const loggerContextKeyVal = loggerContextKey("logrus.FieldLogger")
-
-// Logger returns the appropriate logger for current context
-func Logger(ctx context.Context) logrus.FieldLogger {
-	val := ctx.Value(loggerContextKeyVal)
-	if val != nil {
-		if logger, ok := val.(logrus.FieldLogger); ok {
-			return logger
-		}
-	}
-	return logrus.StandardLogger()
-}
-
-// WithLogger adds a value to the context for the logger
-func WithLogger(ctx context.Context, logger logrus.FieldLogger) context.Context {
-	return context.WithValue(ctx, loggerContextKeyVal, logger)
-}
-
-type loggerHookKey string
-
-const loggerHookKeyVal = loggerHookKey("logrus.Hook")
-
-// LoggerHook returns the appropriate logger hook for current context
-// the hook affects job logger, not global logger
-func LoggerHook(ctx context.Context) logrus.Hook {
-	val := ctx.Value(loggerHookKeyVal)
-	if val != nil {
-		if hook, ok := val.(logrus.Hook); ok {
-			return hook
-		}
-	}
-	return nil
-}
-
-// WithLoggerHook adds a value to the context for the logger hook
-func WithLoggerHook(ctx context.Context, hook logrus.Hook) context.Context {
-	return context.WithValue(ctx, loggerHookKeyVal, hook)
-}

pkg/common/outbound_ip.go

@@ -1,75 +0,0 @@
-package common
-
-import (
-	"net"
-	"sort"
-	"strings"
-)
-
-// GetOutboundIP returns an outbound IP address of this machine.
-// It tries to access the internet and returns the local IP address of the connection.
-// If the machine cannot access the internet, it returns a preferred IP address from network interfaces.
-// It returns nil if no IP address is found.
-func GetOutboundIP() net.IP {
-	// See https://stackoverflow.com/a/37382208
-	conn, err := net.Dial("udp", "8.8.8.8:80")
-	if err == nil {
-		defer conn.Close()
-		return conn.LocalAddr().(*net.UDPAddr).IP
-	}
-
-	// So the machine cannot access the internet. Pick an IP address from network interfaces.
-	if ifs, err := net.Interfaces(); err == nil {
-		type IP struct {
-			net.IP
-			net.Interface
-		}
-		var ips []IP
-		for _, i := range ifs {
-			if addrs, err := i.Addrs(); err == nil {
-				for _, addr := range addrs {
-					var ip net.IP
-					switch v := addr.(type) {
-					case *net.IPNet:
-						ip = v.IP
-					case *net.IPAddr:
-						ip = v.IP
-					}
-					if ip.IsGlobalUnicast() {
-						ips = append(ips, IP{ip, i})
-					}
-				}
-			}
-		}
-		if len(ips) > 1 {
-			sort.Slice(ips, func(i, j int) bool {
-				ifi := ips[i].Interface
-				ifj := ips[j].Interface
-
-				// ethernet is preferred
-				if vi, vj := strings.HasPrefix(ifi.Name, "e"), strings.HasPrefix(ifj.Name, "e"); vi != vj {
-					return vi
-				}
-
-				ipi := ips[i].IP
-				ipj := ips[j].IP
-
-				// IPv4 is preferred
-				if vi, vj := ipi.To4() != nil, ipj.To4() != nil; vi != vj {
-					return vi
-				}
-
-				// en0 is preferred to en1
-				if ifi.Name != ifj.Name {
-					return ifi.Name < ifj.Name
-				}
-
-				// fallback
-				return ipi.String() < ipj.String()
-			})
-			return ips[0].IP
-		}
-	}
-
-	return nil
-}

pkg/container/DOCKER_LICENSE

@@ -1,191 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        https://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   Copyright 2013-2017 Docker, Inc.
-
-   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
-
-       https://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.

pkg/container/container_types.go

@@ -1,80 +0,0 @@
-package container
-
-import (
-	"context"
-	"io"
-
-	"github.com/docker/go-connections/nat"
-	"github.com/nektos/act/pkg/common"
-)
-
-// NewContainerInput the input for the New function
-type NewContainerInput struct {
-	Image          string
-	Username       string
-	Password       string
-	Entrypoint     []string
-	Cmd            []string
-	WorkingDir     string
-	Env            []string
-	Binds          []string
-	Mounts         map[string]string
-	Name           string
-	Stdout         io.Writer
-	Stderr         io.Writer
-	NetworkMode    string
-	Privileged     bool
-	UsernsMode     string
-	Platform       string
-	Options        string
-	NetworkAliases []string
-	ExposedPorts   nat.PortSet
-	PortBindings   nat.PortMap
-
-	// Gitea specific
-	AutoRemove   bool
-	ValidVolumes []string
-}
-
-// FileEntry is a file to copy to a container
-type FileEntry struct {
-	Name string
-	Mode int64
-	Body string
-}
-
-// Container for managing docker run containers
-type Container interface {
-	Create(capAdd []string, capDrop []string) common.Executor
-	ConnectToNetwork(name string) common.Executor
-	Copy(destPath string, files ...*FileEntry) common.Executor
-	CopyTarStream(ctx context.Context, destPath string, tarStream io.Reader) error
-	CopyDir(destPath string, srcPath string, useGitIgnore bool) common.Executor
-	GetContainerArchive(ctx context.Context, srcPath string) (io.ReadCloser, error)
-	Pull(forcePull bool) common.Executor
-	Start(attach bool) common.Executor
-	Exec(command []string, env map[string]string, user, workdir string) common.Executor
-	UpdateFromEnv(srcPath string, env *map[string]string) common.Executor
-	UpdateFromImageEnv(env *map[string]string) common.Executor
-	Remove() common.Executor
-	Close() common.Executor
-	ReplaceLogWriter(io.Writer, io.Writer) (io.Writer, io.Writer)
-}
-
-// NewDockerBuildExecutorInput the input for the NewDockerBuildExecutor function
-type NewDockerBuildExecutorInput struct {
-	ContextDir   string
-	Dockerfile   string
-	BuildContext io.Reader
-	ImageTag     string
-	Platform     string
-}
-
-// NewDockerPullExecutorInput the input for the NewDockerPullExecutor function
-type NewDockerPullExecutorInput struct {
-	Image     string
-	ForcePull bool
-	Platform  string
-	Username  string
-	Password  string
-}

pkg/container/docker_auth.go

@@ -1,61 +0,0 @@
-//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
-
-package container
-
-import (
-	"context"
-	"strings"
-
-	"github.com/docker/cli/cli/config"
-	"github.com/docker/cli/cli/config/credentials"
-	"github.com/docker/docker/api/types/registry"
-	"github.com/nektos/act/pkg/common"
-)
-
-func LoadDockerAuthConfig(ctx context.Context, image string) (registry.AuthConfig, error) {
-	logger := common.Logger(ctx)
-	config, err := config.Load(config.Dir())
-	if err != nil {
-		logger.Warnf("Could not load docker config: %v", err)
-		return registry.AuthConfig{}, err
-	}
-
-	if !config.ContainsAuth() {
-		config.CredentialsStore = credentials.DetectDefaultStore(config.CredentialsStore)
-	}
-
-	hostName := "index.docker.io"
-	index := strings.IndexRune(image, '/')
-	if index > -1 && (strings.ContainsAny(image[:index], ".:") || image[:index] == "localhost") {
-		hostName = image[:index]
-	}
-
-	authConfig, err := config.GetAuthConfig(hostName)
-	if err != nil {
-		logger.Warnf("Could not get auth config from docker config: %v", err)
-		return registry.AuthConfig{}, err
-	}
-
-	return registry.AuthConfig(authConfig), nil
-}
-
-func LoadDockerAuthConfigs(ctx context.Context) map[string]registry.AuthConfig {
-	logger := common.Logger(ctx)
-	config, err := config.Load(config.Dir())
-	if err != nil {
-		logger.Warnf("Could not load docker config: %v", err)
-		return nil
-	}
-
-	if !config.ContainsAuth() {
-		config.CredentialsStore = credentials.DetectDefaultStore(config.CredentialsStore)
-	}
-
-	creds, _ := config.GetAllCredentials()
-	authConfigs := make(map[string]registry.AuthConfig, len(creds))
-	for k, v := range creds {
-		authConfigs[k] = registry.AuthConfig(v)
-	}
-
-	return authConfigs
-}

pkg/container/docker_build.go

@@ -1,117 +0,0 @@
-//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
-
-package container
-
-import (
-	"context"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/pkg/archive"
-
-	// github.com/docker/docker/builder/dockerignore is deprecated
-	"github.com/moby/buildkit/frontend/dockerfile/dockerignore"
-	"github.com/moby/patternmatcher"
-
-	"github.com/nektos/act/pkg/common"
-)
-
-// NewDockerBuildExecutor function to create a run executor for the container
-func NewDockerBuildExecutor(input NewDockerBuildExecutorInput) common.Executor {
-	return func(ctx context.Context) error {
-		logger := common.Logger(ctx)
-		if input.Platform != "" {
-			logger.Infof("%sdocker build -t %s --platform %s %s", logPrefix, input.ImageTag, input.Platform, input.ContextDir)
-		} else {
-			logger.Infof("%sdocker build -t %s %s", logPrefix, input.ImageTag, input.ContextDir)
-		}
-		if common.Dryrun(ctx) {
-			return nil
-		}
-
-		cli, err := GetDockerClient(ctx)
-		if err != nil {
-			return err
-		}
-		defer cli.Close()
-
-		logger.Debugf("Building image from '%v'", input.ContextDir)
-
-		tags := []string{input.ImageTag}
-		options := types.ImageBuildOptions{
-			Tags:        tags,
-			Remove:      true,
-			Platform:    input.Platform,
-			AuthConfigs: LoadDockerAuthConfigs(ctx),
-			Dockerfile:  input.Dockerfile,
-		}
-		var buildContext io.ReadCloser
-		if input.BuildContext != nil {
-			buildContext = io.NopCloser(input.BuildContext)
-		} else {
-			buildContext, err = createBuildContext(ctx, input.ContextDir, input.Dockerfile)
-		}
-		if err != nil {
-			return err
-		}
-
-		defer buildContext.Close()
-
-		logger.Debugf("Creating image from context dir '%s' with tag '%s' and platform '%s'", input.ContextDir, input.ImageTag, input.Platform)
-		resp, err := cli.ImageBuild(ctx, buildContext, options)
-
-		err = logDockerResponse(logger, resp.Body, err != nil)
-		if err != nil {
-			return err
-		}
-		return nil
-	}
-}
-func createBuildContext(ctx context.Context, contextDir string, relDockerfile string) (io.ReadCloser, error) {
-	common.Logger(ctx).Debugf("Creating archive for build context dir '%s' with relative dockerfile '%s'", contextDir, relDockerfile)
-
-	// And canonicalize dockerfile name to a platform-independent one
-	relDockerfile = archive.CanonicalTarNameForPath(relDockerfile)
-
-	f, err := os.Open(filepath.Join(contextDir, ".dockerignore"))
-	if err != nil && !os.IsNotExist(err) {
-		return nil, err
-	}
-	defer f.Close()
-
-	var excludes []string
-	if err == nil {
-		excludes, err = dockerignore.ReadAll(f)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// If .dockerignore mentions .dockerignore or the Dockerfile
-	// then make sure we send both files over to the daemon
-	// because Dockerfile is, obviously, needed no matter what, and
-	// .dockerignore is needed to know if either one needs to be
-	// removed. The daemon will remove them for us, if needed, after it
-	// parses the Dockerfile. Ignore errors here, as they will have been
-	// caught by validateContextDirectory above.
-	var includes = []string{"."}
-	keepThem1, _ := patternmatcher.Matches(".dockerignore", excludes)
-	keepThem2, _ := patternmatcher.Matches(relDockerfile, excludes)
-	if keepThem1 || keepThem2 {
-		includes = append(includes, ".dockerignore", relDockerfile)
-	}
-
-	compression := archive.Uncompressed
-	buildCtx, err := archive.TarWithOptions(contextDir, &archive.TarOptions{
-		Compression:     compression,
-		ExcludePatterns: excludes,
-		IncludeFiles:    includes,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return buildCtx, nil
-}

pkg/container/docker_cli_test.go

@@ -1,982 +0,0 @@
-// This file is exact copy of https://github.com/docker/cli/blob/9ac8584acfd501c3f4da0e845e3a40ed15c85041/cli/command/container/opts_test.go with:
-// * appended with license information
-// * commented out case 'invalid-mixed-network-types' in test TestParseNetworkConfig
-//
-// docker/cli is licensed under the Apache License, Version 2.0.
-// See DOCKER_LICENSE for the full license text.
-//
-
-//nolint:unparam,whitespace,depguard,dupl,gocritic
-package container
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/docker/docker/api/types/container"
-	networktypes "github.com/docker/docker/api/types/network"
-	"github.com/docker/go-connections/nat"
-	"github.com/pkg/errors"
-	"github.com/spf13/pflag"
-	"gotest.tools/v3/assert"
-	is "gotest.tools/v3/assert/cmp"
-	"gotest.tools/v3/skip"
-)
-
-func TestValidateAttach(t *testing.T) {
-	valid := []string{
-		"stdin",
-		"stdout",
-		"stderr",
-		"STDIN",
-		"STDOUT",
-		"STDERR",
-	}
-	if _, err := validateAttach("invalid"); err == nil {
-		t.Fatal("Expected error with [valid streams are STDIN, STDOUT and STDERR], got nothing")
-	}
-
-	for _, attach := range valid {
-		value, err := validateAttach(attach)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if value != strings.ToLower(attach) {
-			t.Fatalf("Expected [%v], got [%v]", attach, value)
-		}
-	}
-}
-
-func parseRun(args []string) (*container.Config, *container.HostConfig, *networktypes.NetworkingConfig, error) {
-	flags, copts := setupRunFlags()
-	if err := flags.Parse(args); err != nil {
-		return nil, nil, nil, err
-	}
-	// TODO: fix tests to accept ContainerConfig
-	containerConfig, err := parse(flags, copts, runtime.GOOS)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-	return containerConfig.Config, containerConfig.HostConfig, containerConfig.NetworkingConfig, err
-}
-
-func setupRunFlags() (*pflag.FlagSet, *containerOptions) {
-	flags := pflag.NewFlagSet("run", pflag.ContinueOnError)
-	flags.SetOutput(io.Discard)
-	flags.Usage = nil
-	copts := addFlags(flags)
-	return flags, copts
-}
-
-func mustParse(t *testing.T, args string) (*container.Config, *container.HostConfig) {
-	t.Helper()
-	config, hostConfig, _, err := parseRun(append(strings.Split(args, " "), "ubuntu", "bash"))
-	assert.NilError(t, err)
-	return config, hostConfig
-}
-
-func TestParseRunLinks(t *testing.T) {
-	if _, hostConfig := mustParse(t, "--link a:b"); len(hostConfig.Links) == 0 || hostConfig.Links[0] != "a:b" {
-		t.Fatalf("Error parsing links. Expected []string{\"a:b\"}, received: %v", hostConfig.Links)
-	}
-	if _, hostConfig := mustParse(t, "--link a:b --link c:d"); len(hostConfig.Links) < 2 || hostConfig.Links[0] != "a:b" || hostConfig.Links[1] != "c:d" {
-		t.Fatalf("Error parsing links. Expected []string{\"a:b\", \"c:d\"}, received: %v", hostConfig.Links)
-	}
-	if _, hostConfig := mustParse(t, ""); len(hostConfig.Links) != 0 {
-		t.Fatalf("Error parsing links. No link expected, received: %v", hostConfig.Links)
-	}
-}
-
-func TestParseRunAttach(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected container.Config
-	}{
-		{
-			input: "",
-			expected: container.Config{
-				AttachStdout: true,
-				AttachStderr: true,
-			},
-		},
-		{
-			input: "-i",
-			expected: container.Config{
-				AttachStdin:  true,
-				AttachStdout: true,
-				AttachStderr: true,
-			},
-		},
-		{
-			input: "-a stdin",
-			expected: container.Config{
-				AttachStdin: true,
-			},
-		},
-		{
-			input: "-a stdin -a stdout",
-			expected: container.Config{
-				AttachStdin:  true,
-				AttachStdout: true,
-			},
-		},
-		{
-			input: "-a stdin -a stdout -a stderr",
-			expected: container.Config{
-				AttachStdin:  true,
-				AttachStdout: true,
-				AttachStderr: true,
-			},
-		},
-	}
-	for _, tc := range tests {
-		tc := tc
-		t.Run(tc.input, func(t *testing.T) {
-			config, _ := mustParse(t, tc.input)
-			assert.Equal(t, config.AttachStdin, tc.expected.AttachStdin)
-			assert.Equal(t, config.AttachStdout, tc.expected.AttachStdout)
-			assert.Equal(t, config.AttachStderr, tc.expected.AttachStderr)
-		})
-	}
-}
-
-func TestParseRunWithInvalidArgs(t *testing.T) {
-	tests := []struct {
-		args  []string
-		error string
-	}{
-		{
-			args:  []string{"-a", "ubuntu", "bash"},
-			error: `invalid argument "ubuntu" for "-a, --attach" flag: valid streams are STDIN, STDOUT and STDERR`,
-		},
-		{
-			args:  []string{"-a", "invalid", "ubuntu", "bash"},
-			error: `invalid argument "invalid" for "-a, --attach" flag: valid streams are STDIN, STDOUT and STDERR`,
-		},
-		{
-			args:  []string{"-a", "invalid", "-a", "stdout", "ubuntu", "bash"},
-			error: `invalid argument "invalid" for "-a, --attach" flag: valid streams are STDIN, STDOUT and STDERR`,
-		},
-		{
-			args:  []string{"-a", "stdout", "-a", "stderr", "-z", "ubuntu", "bash"},
-			error: `unknown shorthand flag: 'z' in -z`,
-		},
-		{
-			args:  []string{"-a", "stdin", "-z", "ubuntu", "bash"},
-			error: `unknown shorthand flag: 'z' in -z`,
-		},
-		{
-			args:  []string{"-a", "stdout", "-z", "ubuntu", "bash"},
-			error: `unknown shorthand flag: 'z' in -z`,
-		},
-		{
-			args:  []string{"-a", "stderr", "-z", "ubuntu", "bash"},
-			error: `unknown shorthand flag: 'z' in -z`,
-		},
-		{
-			args:  []string{"-z", "--rm", "ubuntu", "bash"},
-			error: `unknown shorthand flag: 'z' in -z`,
-		},
-	}
-	flags, _ := setupRunFlags()
-	for _, tc := range tests {
-		t.Run(strings.Join(tc.args, " "), func(t *testing.T) {
-			assert.Error(t, flags.Parse(tc.args), tc.error)
-		})
-	}
-}
-
-//nolint:gocyclo
-func TestParseWithVolumes(t *testing.T) {
-
-	// A single volume
-	arr, tryit := setupPlatformVolume([]string{`/tmp`}, []string{`c:\tmp`})
-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds != nil {
-		t.Fatalf("Error parsing volume flags, %q should not mount-bind anything. Received %v", tryit, hostConfig.Binds)
-	} else if _, exists := config.Volumes[arr[0]]; !exists {
-		t.Fatalf("Error parsing volume flags, %q is missing from volumes. Received %v", tryit, config.Volumes)
-	}
-
-	// Two volumes
-	arr, tryit = setupPlatformVolume([]string{`/tmp`, `/var`}, []string{`c:\tmp`, `c:\var`})
-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds != nil {
-		t.Fatalf("Error parsing volume flags, %q should not mount-bind anything. Received %v", tryit, hostConfig.Binds)
-	} else if _, exists := config.Volumes[arr[0]]; !exists {
-		t.Fatalf("Error parsing volume flags, %s is missing from volumes. Received %v", arr[0], config.Volumes)
-	} else if _, exists := config.Volumes[arr[1]]; !exists {
-		t.Fatalf("Error parsing volume flags, %s is missing from volumes. Received %v", arr[1], config.Volumes)
-	}
-
-	// A single bind mount
-	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`}, []string{os.Getenv("TEMP") + `:c:\containerTmp`})
-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || hostConfig.Binds[0] != arr[0] {
-		t.Fatalf("Error parsing volume flags, %q should mount-bind the path before the colon into the path after the colon. Received %v %v", arr[0], hostConfig.Binds, config.Volumes)
-	}
-
-	// Two bind mounts.
-	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`, `/hostVar:/containerVar`}, []string{os.Getenv("ProgramData") + `:c:\ContainerPD`, os.Getenv("TEMP") + `:c:\containerTmp`})
-	if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {
-		t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)
-	}
-
-	// Two bind mounts, first read-only, second read-write.
-	// TODO Windows: The Windows version uses read-write as that's the only mode it supports. Can change this post TP4
-	arr, tryit = setupPlatformVolume(
-		[]string{`/hostTmp:/containerTmp:ro`, `/hostVar:/containerVar:rw`},
-		[]string{os.Getenv("TEMP") + `:c:\containerTmp:rw`, os.Getenv("ProgramData") + `:c:\ContainerPD:rw`})
-	if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {
-		t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)
-	}
-
-	// Similar to previous test but with alternate modes which are only supported by Linux
-	if runtime.GOOS != "windows" {
-		arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp:ro,Z`, `/hostVar:/containerVar:rw,Z`}, []string{})
-		if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {
-			t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)
-		}
-
-		arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp:Z`, `/hostVar:/containerVar:z`}, []string{})
-		if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {
-			t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)
-		}
-	}
-
-	// One bind mount and one volume
-	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`, `/containerVar`}, []string{os.Getenv("TEMP") + `:c:\containerTmp`, `c:\containerTmp`})
-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || len(hostConfig.Binds) > 1 || hostConfig.Binds[0] != arr[0] {
-		t.Fatalf("Error parsing volume flags, %s and %s should only one and only one bind mount %s. Received %s", arr[0], arr[1], arr[0], hostConfig.Binds)
-	} else if _, exists := config.Volumes[arr[1]]; !exists {
-		t.Fatalf("Error parsing volume flags %s and %s. %s is missing from volumes. Received %v", arr[0], arr[1], arr[1], config.Volumes)
-	}
-
-	// Root to non-c: drive letter (Windows specific)
-	if runtime.GOOS == "windows" {
-		arr, tryit = setupPlatformVolume([]string{}, []string{os.Getenv("SystemDrive") + `\:d:`})
-		if config, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || len(hostConfig.Binds) > 1 || hostConfig.Binds[0] != arr[0] || len(config.Volumes) != 0 {
-			t.Fatalf("Error parsing %s. Should have a single bind mount and no volumes", arr[0])
-		}
-	}
-
-}
-
-// setupPlatformVolume takes two arrays of volume specs - a Unix style
-// spec and a Windows style spec. Depending on the platform being unit tested,
-// it returns one of them, along with a volume string that would be passed
-// on the docker CLI (e.g. -v /bar -v /foo).
-func setupPlatformVolume(u []string, w []string) ([]string, string) {
-	var a []string
-	if runtime.GOOS == "windows" {
-		a = w
-	} else {
-		a = u
-	}
-	s := ""
-	for _, v := range a {
-		s = s + "-v " + v + " "
-	}
-	return a, s
-}
-
-// check if (a == c && b == d) || (a == d && b == c)
-// because maps are randomized
-func compareRandomizedStrings(a, b, c, d string) error {
-	if a == c && b == d {
-		return nil
-	}
-	if a == d && b == c {
-		return nil
-	}
-	return errors.Errorf("strings don't match")
-}
-
-// Simple parse with MacAddress validation
-func TestParseWithMacAddress(t *testing.T) {
-	invalidMacAddress := "--mac-address=invalidMacAddress"
-	validMacAddress := "--mac-address=92:d0:c6:0a:29:33"
-	if _, _, _, err := parseRun([]string{invalidMacAddress, "img", "cmd"}); err != nil && err.Error() != "invalidMacAddress is not a valid mac address" {
-		t.Fatalf("Expected an error with %v mac-address, got %v", invalidMacAddress, err)
-	}
-	if config, _ := mustParse(t, validMacAddress); config.MacAddress != "92:d0:c6:0a:29:33" {
-		t.Fatalf("Expected the config to have '92:d0:c6:0a:29:33' as MacAddress, got '%v'", config.MacAddress)
-	}
-}
-
-func TestRunFlagsParseWithMemory(t *testing.T) {
-	flags, _ := setupRunFlags()
-	args := []string{"--memory=invalid", "img", "cmd"}
-	err := flags.Parse(args)
-	assert.ErrorContains(t, err, `invalid argument "invalid" for "-m, --memory" flag`)
-
-	_, hostconfig := mustParse(t, "--memory=1G")
-	assert.Check(t, is.Equal(int64(1073741824), hostconfig.Memory))
-}
-
-func TestParseWithMemorySwap(t *testing.T) {
-	flags, _ := setupRunFlags()
-	args := []string{"--memory-swap=invalid", "img", "cmd"}
-	err := flags.Parse(args)
-	assert.ErrorContains(t, err, `invalid argument "invalid" for "--memory-swap" flag`)
-
-	_, hostconfig := mustParse(t, "--memory-swap=1G")
-	assert.Check(t, is.Equal(int64(1073741824), hostconfig.MemorySwap))
-
-	_, hostconfig = mustParse(t, "--memory-swap=-1")
-	assert.Check(t, is.Equal(int64(-1), hostconfig.MemorySwap))
-}
-
-func TestParseHostname(t *testing.T) {
-	validHostnames := map[string]string{
-		"hostname":    "hostname",
-		"host-name":   "host-name",
-		"hostname123": "hostname123",
-		"123hostname": "123hostname",
-		"hostname-of-63-bytes-long-should-be-valid-and-without-any-error": "hostname-of-63-bytes-long-should-be-valid-and-without-any-error",
-	}
-	hostnameWithDomain := "--hostname=hostname.domainname"
-	hostnameWithDomainTld := "--hostname=hostname.domainname.tld"
-	for hostname, expectedHostname := range validHostnames {
-		if config, _ := mustParse(t, fmt.Sprintf("--hostname=%s", hostname)); config.Hostname != expectedHostname {
-			t.Fatalf("Expected the config to have 'hostname' as %q, got %q", expectedHostname, config.Hostname)
-		}
-	}
-	if config, _ := mustParse(t, hostnameWithDomain); config.Hostname != "hostname.domainname" || config.Domainname != "" {
-		t.Fatalf("Expected the config to have 'hostname' as hostname.domainname, got %q", config.Hostname)
-	}
-	if config, _ := mustParse(t, hostnameWithDomainTld); config.Hostname != "hostname.domainname.tld" || config.Domainname != "" {
-		t.Fatalf("Expected the config to have 'hostname' as hostname.domainname.tld, got %q", config.Hostname)
-	}
-}
-
-func TestParseHostnameDomainname(t *testing.T) {
-	validDomainnames := map[string]string{
-		"domainname":    "domainname",
-		"domain-name":   "domain-name",
-		"domainname123": "domainname123",
-		"123domainname": "123domainname",
-		"domainname-63-bytes-long-should-be-valid-and-without-any-errors": "domainname-63-bytes-long-should-be-valid-and-without-any-errors",
-	}
-	for domainname, expectedDomainname := range validDomainnames {
-		if config, _ := mustParse(t, "--domainname="+domainname); config.Domainname != expectedDomainname {
-			t.Fatalf("Expected the config to have 'domainname' as %q, got %q", expectedDomainname, config.Domainname)
-		}
-	}
-	if config, _ := mustParse(t, "--hostname=some.prefix --domainname=domainname"); config.Hostname != "some.prefix" || config.Domainname != "domainname" {
-		t.Fatalf("Expected the config to have 'hostname' as 'some.prefix' and 'domainname' as 'domainname', got %q and %q", config.Hostname, config.Domainname)
-	}
-	if config, _ := mustParse(t, "--hostname=another-prefix --domainname=domainname.tld"); config.Hostname != "another-prefix" || config.Domainname != "domainname.tld" {
-		t.Fatalf("Expected the config to have 'hostname' as 'another-prefix' and 'domainname' as 'domainname.tld', got %q and %q", config.Hostname, config.Domainname)
-	}
-}
-
-func TestParseWithExpose(t *testing.T) {
-	invalids := map[string]string{
-		":":                   "invalid port format for --expose: :",
-		"8080:9090":           "invalid port format for --expose: 8080:9090",
-		"/tcp":                "invalid range format for --expose: /tcp, error: Empty string specified for ports.",
-		"/udp":                "invalid range format for --expose: /udp, error: Empty string specified for ports.",
-		"NaN/tcp":             `invalid range format for --expose: NaN/tcp, error: strconv.ParseUint: parsing "NaN": invalid syntax`,
-		"NaN-NaN/tcp":         `invalid range format for --expose: NaN-NaN/tcp, error: strconv.ParseUint: parsing "NaN": invalid syntax`,
-		"8080-NaN/tcp":        `invalid range format for --expose: 8080-NaN/tcp, error: strconv.ParseUint: parsing "NaN": invalid syntax`,
-		"1234567890-8080/tcp": `invalid range format for --expose: 1234567890-8080/tcp, error: strconv.ParseUint: parsing "1234567890": value out of range`,
-	}
-	valids := map[string][]nat.Port{
-		"8080/tcp":      {"8080/tcp"},
-		"8080/udp":      {"8080/udp"},
-		"8080/ncp":      {"8080/ncp"},
-		"8080-8080/udp": {"8080/udp"},
-		"8080-8082/tcp": {"8080/tcp", "8081/tcp", "8082/tcp"},
-	}
-	for expose, expectedError := range invalids {
-		if _, _, _, err := parseRun([]string{fmt.Sprintf("--expose=%v", expose), "img", "cmd"}); err == nil || err.Error() != expectedError {
-			t.Fatalf("Expected error '%v' with '--expose=%v', got '%v'", expectedError, expose, err)
-		}
-	}
-	for expose, exposedPorts := range valids {
-		config, _, _, err := parseRun([]string{fmt.Sprintf("--expose=%v", expose), "img", "cmd"})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if len(config.ExposedPorts) != len(exposedPorts) {
-			t.Fatalf("Expected %v exposed port, got %v", len(exposedPorts), len(config.ExposedPorts))
-		}
-		for _, port := range exposedPorts {
-			if _, ok := config.ExposedPorts[port]; !ok {
-				t.Fatalf("Expected %v, got %v", exposedPorts, config.ExposedPorts)
-			}
-		}
-	}
-	// Merge with actual published port
-	config, _, _, err := parseRun([]string{"--publish=80", "--expose=80-81/tcp", "img", "cmd"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(config.ExposedPorts) != 2 {
-		t.Fatalf("Expected 2 exposed ports, got %v", config.ExposedPorts)
-	}
-	ports := []nat.Port{"80/tcp", "81/tcp"}
-	for _, port := range ports {
-		if _, ok := config.ExposedPorts[port]; !ok {
-			t.Fatalf("Expected %v, got %v", ports, config.ExposedPorts)
-		}
-	}
-}
-
-func TestParseDevice(t *testing.T) {
-	skip.If(t, runtime.GOOS != "linux") // Windows and macOS validate server-side
-	valids := map[string]container.DeviceMapping{
-		"/dev/snd": {
-			PathOnHost:        "/dev/snd",
-			PathInContainer:   "/dev/snd",
-			CgroupPermissions: "rwm",
-		},
-		"/dev/snd:rw": {
-			PathOnHost:        "/dev/snd",
-			PathInContainer:   "/dev/snd",
-			CgroupPermissions: "rw",
-		},
-		"/dev/snd:/something": {
-			PathOnHost:        "/dev/snd",
-			PathInContainer:   "/something",
-			CgroupPermissions: "rwm",
-		},
-		"/dev/snd:/something:rw": {
-			PathOnHost:        "/dev/snd",
-			PathInContainer:   "/something",
-			CgroupPermissions: "rw",
-		},
-	}
-	for device, deviceMapping := range valids {
-		_, hostconfig, _, err := parseRun([]string{fmt.Sprintf("--device=%v", device), "img", "cmd"})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if len(hostconfig.Devices) != 1 {
-			t.Fatalf("Expected 1 devices, got %v", hostconfig.Devices)
-		}
-		if hostconfig.Devices[0] != deviceMapping {
-			t.Fatalf("Expected %v, got %v", deviceMapping, hostconfig.Devices)
-		}
-	}
-
-}
-
-func TestParseNetworkConfig(t *testing.T) {
-	tests := []struct {
-		name        string
-		flags       []string
-		expected    map[string]*networktypes.EndpointSettings
-		expectedCfg container.HostConfig
-		expectedErr string
-	}{
-		{
-			name:        "single-network-legacy",
-			flags:       []string{"--network", "net1"},
-			expected:    map[string]*networktypes.EndpointSettings{},
-			expectedCfg: container.HostConfig{NetworkMode: "net1"},
-		},
-		{
-			name:        "single-network-advanced",
-			flags:       []string{"--network", "name=net1"},
-			expected:    map[string]*networktypes.EndpointSettings{},
-			expectedCfg: container.HostConfig{NetworkMode: "net1"},
-		},
-		{
-			name: "single-network-legacy-with-options",
-			flags: []string{
-				"--ip", "172.20.88.22",
-				"--ip6", "2001:db8::8822",
-				"--link", "foo:bar",
-				"--link", "bar:baz",
-				"--link-local-ip", "169.254.2.2",
-				"--link-local-ip", "fe80::169:254:2:2",
-				"--network", "name=net1",
-				"--network-alias", "web1",
-				"--network-alias", "web2",
-			},
-			expected: map[string]*networktypes.EndpointSettings{
-				"net1": {
-					IPAMConfig: &networktypes.EndpointIPAMConfig{
-						IPv4Address:  "172.20.88.22",
-						IPv6Address:  "2001:db8::8822",
-						LinkLocalIPs: []string{"169.254.2.2", "fe80::169:254:2:2"},
-					},
-					Links:   []string{"foo:bar", "bar:baz"},
-					Aliases: []string{"web1", "web2"},
-				},
-			},
-			expectedCfg: container.HostConfig{NetworkMode: "net1"},
-		},
-		{
-			name: "multiple-network-advanced-mixed",
-			flags: []string{
-				"--ip", "172.20.88.22",
-				"--ip6", "2001:db8::8822",
-				"--link", "foo:bar",
-				"--link", "bar:baz",
-				"--link-local-ip", "169.254.2.2",
-				"--link-local-ip", "fe80::169:254:2:2",
-				"--network", "name=net1,driver-opt=field1=value1",
-				"--network-alias", "web1",
-				"--network-alias", "web2",
-				"--network", "net2",
-				"--network", "name=net3,alias=web3,driver-opt=field3=value3,ip=172.20.88.22,ip6=2001:db8::8822",
-			},
-			expected: map[string]*networktypes.EndpointSettings{
-				"net1": {
-					DriverOpts: map[string]string{"field1": "value1"},
-					IPAMConfig: &networktypes.EndpointIPAMConfig{
-						IPv4Address:  "172.20.88.22",
-						IPv6Address:  "2001:db8::8822",
-						LinkLocalIPs: []string{"169.254.2.2", "fe80::169:254:2:2"},
-					},
-					Links:   []string{"foo:bar", "bar:baz"},
-					Aliases: []string{"web1", "web2"},
-				},
-				"net2": {},
-				"net3": {
-					DriverOpts: map[string]string{"field3": "value3"},
-					IPAMConfig: &networktypes.EndpointIPAMConfig{
-						IPv4Address: "172.20.88.22",
-						IPv6Address: "2001:db8::8822",
-					},
-					Aliases: []string{"web3"},
-				},
-			},
-			expectedCfg: container.HostConfig{NetworkMode: "net1"},
-		},
-		{
-			name:  "single-network-advanced-with-options",
-			flags: []string{"--network", "name=net1,alias=web1,alias=web2,driver-opt=field1=value1,driver-opt=field2=value2,ip=172.20.88.22,ip6=2001:db8::8822"},
-			expected: map[string]*networktypes.EndpointSettings{
-				"net1": {
-					DriverOpts: map[string]string{
-						"field1": "value1",
-						"field2": "value2",
-					},
-					IPAMConfig: &networktypes.EndpointIPAMConfig{
-						IPv4Address: "172.20.88.22",
-						IPv6Address: "2001:db8::8822",
-					},
-					Aliases: []string{"web1", "web2"},
-				},
-			},
-			expectedCfg: container.HostConfig{NetworkMode: "net1"},
-		},
-		{
-			name:        "multiple-networks",
-			flags:       []string{"--network", "net1", "--network", "name=net2"},
-			expected:    map[string]*networktypes.EndpointSettings{"net1": {}, "net2": {}},
-			expectedCfg: container.HostConfig{NetworkMode: "net1"},
-		},
-		{
-			name:        "conflict-network",
-			flags:       []string{"--network", "duplicate", "--network", "name=duplicate"},
-			expectedErr: `network "duplicate" is specified multiple times`,
-		},
-		{
-			name:        "conflict-options-alias",
-			flags:       []string{"--network", "name=net1,alias=web1", "--network-alias", "web1"},
-			expectedErr: `conflicting options: cannot specify both --network-alias and per-network alias`,
-		},
-		{
-			name:        "conflict-options-ip",
-			flags:       []string{"--network", "name=net1,ip=172.20.88.22,ip6=2001:db8::8822", "--ip", "172.20.88.22"},
-			expectedErr: `conflicting options: cannot specify both --ip and per-network IPv4 address`,
-		},
-		{
-			name:        "conflict-options-ip6",
-			flags:       []string{"--network", "name=net1,ip=172.20.88.22,ip6=2001:db8::8822", "--ip6", "2001:db8::8822"},
-			expectedErr: `conflicting options: cannot specify both --ip6 and per-network IPv6 address`,
-		},
-		// case is skipped as it fails w/o any change
-		//
-		//{
-		//	name:        "invalid-mixed-network-types",
-		//	flags:       []string{"--network", "name=host", "--network", "net1"},
-		//	expectedErr: `conflicting options: cannot attach both user-defined and non-user-defined network-modes`,
-		//},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			_, hConfig, nwConfig, err := parseRun(tc.flags)
-
-			if tc.expectedErr != "" {
-				assert.Error(t, err, tc.expectedErr)
-				return
-			}
-
-			assert.NilError(t, err)
-			assert.DeepEqual(t, hConfig.NetworkMode, tc.expectedCfg.NetworkMode)
-			assert.DeepEqual(t, nwConfig.EndpointsConfig, tc.expected)
-		})
-	}
-}
-
-func TestParseModes(t *testing.T) {
-	// pid ko
-	flags, copts := setupRunFlags()
-	args := []string{"--pid=container:", "img", "cmd"}
-	assert.NilError(t, flags.Parse(args))
-	_, err := parse(flags, copts, runtime.GOOS)
-	assert.ErrorContains(t, err, "--pid: invalid PID mode")
-
-	// pid ok
-	_, hostconfig, _, err := parseRun([]string{"--pid=host", "img", "cmd"})
-	assert.NilError(t, err)
-	if !hostconfig.PidMode.Valid() {
-		t.Fatalf("Expected a valid PidMode, got %v", hostconfig.PidMode)
-	}
-
-	// uts ko
-	_, _, _, err = parseRun([]string{"--uts=container:", "img", "cmd"}) //nolint:dogsled
-	assert.ErrorContains(t, err, "--uts: invalid UTS mode")
-
-	// uts ok
-	_, hostconfig, _, err = parseRun([]string{"--uts=host", "img", "cmd"})
-	assert.NilError(t, err)
-	if !hostconfig.UTSMode.Valid() {
-		t.Fatalf("Expected a valid UTSMode, got %v", hostconfig.UTSMode)
-	}
-}
-
-func TestRunFlagsParseShmSize(t *testing.T) {
-	// shm-size ko
-	flags, _ := setupRunFlags()
-	args := []string{"--shm-size=a128m", "img", "cmd"}
-	expectedErr := `invalid argument "a128m" for "--shm-size" flag:`
-	err := flags.Parse(args)
-	assert.ErrorContains(t, err, expectedErr)
-
-	// shm-size ok
-	_, hostconfig, _, err := parseRun([]string{"--shm-size=128m", "img", "cmd"})
-	assert.NilError(t, err)
-	if hostconfig.ShmSize != 134217728 {
-		t.Fatalf("Expected a valid ShmSize, got %d", hostconfig.ShmSize)
-	}
-}
-
-func TestParseRestartPolicy(t *testing.T) {
-	invalids := map[string]string{
-		"always:2:3":         "invalid restart policy format: maximum retry count must be an integer",
-		"on-failure:invalid": "invalid restart policy format: maximum retry count must be an integer",
-	}
-	valids := map[string]container.RestartPolicy{
-		"": {},
-		"always": {
-			Name:              "always",
-			MaximumRetryCount: 0,
-		},
-		"on-failure:1": {
-			Name:              "on-failure",
-			MaximumRetryCount: 1,
-		},
-	}
-	for restart, expectedError := range invalids {
-		if _, _, _, err := parseRun([]string{fmt.Sprintf("--restart=%s", restart), "img", "cmd"}); err == nil || err.Error() != expectedError {
-			t.Fatalf("Expected an error with message '%v' for %v, got %v", expectedError, restart, err)
-		}
-	}
-	for restart, expected := range valids {
-		_, hostconfig, _, err := parseRun([]string{fmt.Sprintf("--restart=%v", restart), "img", "cmd"})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if hostconfig.RestartPolicy != expected {
-			t.Fatalf("Expected %v, got %v", expected, hostconfig.RestartPolicy)
-		}
-	}
-}
-
-func TestParseRestartPolicyAutoRemove(t *testing.T) {
-	expected := "Conflicting options: --restart and --rm"
-	_, _, _, err := parseRun([]string{"--rm", "--restart=always", "img", "cmd"}) //nolint:dogsled
-	if err == nil || err.Error() != expected {
-		t.Fatalf("Expected error %v, but got none", expected)
-	}
-}
-
-func TestParseHealth(t *testing.T) {
-	checkOk := func(args ...string) *container.HealthConfig {
-		config, _, _, err := parseRun(args)
-		if err != nil {
-			t.Fatalf("%#v: %v", args, err)
-		}
-		return config.Healthcheck
-	}
-	checkError := func(expected string, args ...string) {
-		config, _, _, err := parseRun(args)
-		if err == nil {
-			t.Fatalf("Expected error, but got %#v", config)
-		}
-		if err.Error() != expected {
-			t.Fatalf("Expected %#v, got %#v", expected, err)
-		}
-	}
-	health := checkOk("--no-healthcheck", "img", "cmd")
-	if health == nil || len(health.Test) != 1 || health.Test[0] != "NONE" {
-		t.Fatalf("--no-healthcheck failed: %#v", health)
-	}
-
-	health = checkOk("--health-cmd=/check.sh -q", "img", "cmd")
-	if len(health.Test) != 2 || health.Test[0] != "CMD-SHELL" || health.Test[1] != "/check.sh -q" {
-		t.Fatalf("--health-cmd: got %#v", health.Test)
-	}
-	if health.Timeout != 0 {
-		t.Fatalf("--health-cmd: timeout = %s", health.Timeout)
-	}
-
-	checkError("--no-healthcheck conflicts with --health-* options",
-		"--no-healthcheck", "--health-cmd=/check.sh -q", "img", "cmd")
-
-	health = checkOk("--health-timeout=2s", "--health-retries=3", "--health-interval=4.5s", "--health-start-period=5s", "img", "cmd")
-	if health.Timeout != 2*time.Second || health.Retries != 3 || health.Interval != 4500*time.Millisecond || health.StartPeriod != 5*time.Second {
-		t.Fatalf("--health-*: got %#v", health)
-	}
-}
-
-func TestParseLoggingOpts(t *testing.T) {
-	// logging opts ko
-	if _, _, _, err := parseRun([]string{"--log-driver=none", "--log-opt=anything", "img", "cmd"}); err == nil || err.Error() != "invalid logging opts for driver none" {
-		t.Fatalf("Expected an error with message 'invalid logging opts for driver none', got %v", err)
-	}
-	// logging opts ok
-	_, hostconfig, _, err := parseRun([]string{"--log-driver=syslog", "--log-opt=something", "img", "cmd"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if hostconfig.LogConfig.Type != "syslog" || len(hostconfig.LogConfig.Config) != 1 {
-		t.Fatalf("Expected a 'syslog' LogConfig with one config, got %v", hostconfig.RestartPolicy)
-	}
-}
-
-func TestParseEnvfileVariables(t *testing.T) {
-	e := "open nonexistent: no such file or directory"
-	if runtime.GOOS == "windows" {
-		e = "open nonexistent: The system cannot find the file specified."
-	}
-	// env ko
-	if _, _, _, err := parseRun([]string{"--env-file=nonexistent", "img", "cmd"}); err == nil || err.Error() != e {
-		t.Fatalf("Expected an error with message '%s', got %v", e, err)
-	}
-	// env ok
-	config, _, _, err := parseRun([]string{"--env-file=testdata/valid.env", "img", "cmd"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(config.Env) != 1 || config.Env[0] != "ENV1=value1" {
-		t.Fatalf("Expected a config with [ENV1=value1], got %v", config.Env)
-	}
-	config, _, _, err = parseRun([]string{"--env-file=testdata/valid.env", "--env=ENV2=value2", "img", "cmd"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(config.Env) != 2 || config.Env[0] != "ENV1=value1" || config.Env[1] != "ENV2=value2" {
-		t.Fatalf("Expected a config with [ENV1=value1 ENV2=value2], got %v", config.Env)
-	}
-}
-
-func TestParseEnvfileVariablesWithBOMUnicode(t *testing.T) {
-	// UTF8 with BOM
-	config, _, _, err := parseRun([]string{"--env-file=testdata/utf8.env", "img", "cmd"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	env := []string{"FOO=BAR", "HELLO=" + string([]byte{0xe6, 0x82, 0xa8, 0xe5, 0xa5, 0xbd}), "BAR=FOO"}
-	if len(config.Env) != len(env) {
-		t.Fatalf("Expected a config with %d env variables, got %v: %v", len(env), len(config.Env), config.Env)
-	}
-	for i, v := range env {
-		if config.Env[i] != v {
-			t.Fatalf("Expected a config with [%s], got %v", v, []byte(config.Env[i]))
-		}
-	}
-
-	// UTF16 with BOM
-	e := "contains invalid utf8 bytes at line"
-	if _, _, _, err := parseRun([]string{"--env-file=testdata/utf16.env", "img", "cmd"}); err == nil || !strings.Contains(err.Error(), e) {
-		t.Fatalf("Expected an error with message '%s', got %v", e, err)
-	}
-	// UTF16BE with BOM
-	if _, _, _, err := parseRun([]string{"--env-file=testdata/utf16be.env", "img", "cmd"}); err == nil || !strings.Contains(err.Error(), e) {
-		t.Fatalf("Expected an error with message '%s', got %v", e, err)
-	}
-}
-
-func TestParseLabelfileVariables(t *testing.T) {
-	e := "open nonexistent: no such file or directory"
-	if runtime.GOOS == "windows" {
-		e = "open nonexistent: The system cannot find the file specified."
-	}
-	// label ko
-	if _, _, _, err := parseRun([]string{"--label-file=nonexistent", "img", "cmd"}); err == nil || err.Error() != e {
-		t.Fatalf("Expected an error with message '%s', got %v", e, err)
-	}
-	// label ok
-	config, _, _, err := parseRun([]string{"--label-file=testdata/valid.label", "img", "cmd"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(config.Labels) != 1 || config.Labels["LABEL1"] != "value1" {
-		t.Fatalf("Expected a config with [LABEL1:value1], got %v", config.Labels)
-	}
-	config, _, _, err = parseRun([]string{"--label-file=testdata/valid.label", "--label=LABEL2=value2", "img", "cmd"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(config.Labels) != 2 || config.Labels["LABEL1"] != "value1" || config.Labels["LABEL2"] != "value2" {
-		t.Fatalf("Expected a config with [LABEL1:value1 LABEL2:value2], got %v", config.Labels)
-	}
-}
-
-func TestParseEntryPoint(t *testing.T) {
-	config, _, _, err := parseRun([]string{"--entrypoint=anything", "cmd", "img"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(config.Entrypoint) != 1 && config.Entrypoint[0] != "anything" {
-		t.Fatalf("Expected entrypoint 'anything', got %v", config.Entrypoint)
-	}
-}
-
-func TestValidateDevice(t *testing.T) {
-	skip.If(t, runtime.GOOS != "linux") // Windows and macOS validate server-side
-	valid := []string{
-		"/home",
-		"/home:/home",
-		"/home:/something/else",
-		"/with space",
-		"/home:/with space",
-		"relative:/absolute-path",
-		"hostPath:/containerPath:r",
-		"/hostPath:/containerPath:rw",
-		"/hostPath:/containerPath:mrw",
-	}
-	invalid := map[string]string{
-		"":        "bad format for path: ",
-		"./":      "./ is not an absolute path",
-		"../":     "../ is not an absolute path",
-		"/:../":   "../ is not an absolute path",
-		"/:path":  "path is not an absolute path",
-		":":       "bad format for path: :",
-		"/tmp:":   " is not an absolute path",
-		":test":   "bad format for path: :test",
-		":/test":  "bad format for path: :/test",
-		"tmp:":    " is not an absolute path",
-		":test:":  "bad format for path: :test:",
-		"::":      "bad format for path: ::",
-		":::":     "bad format for path: :::",
-		"/tmp:::": "bad format for path: /tmp:::",
-		":/tmp::": "bad format for path: :/tmp::",
-		"path:ro": "ro is not an absolute path",
-		"path:rr": "rr is not an absolute path",
-		"a:/b:ro": "bad mode specified: ro",
-		"a:/b:rr": "bad mode specified: rr",
-	}
-
-	for _, path := range valid {
-		if _, err := validateDevice(path, runtime.GOOS); err != nil {
-			t.Fatalf("ValidateDevice(`%q`) should succeed: error %q", path, err)
-		}
-	}
-
-	for path, expectedError := range invalid {
-		if _, err := validateDevice(path, runtime.GOOS); err == nil {
-			t.Fatalf("ValidateDevice(`%q`) should have failed validation", path)
-		} else {
-			if err.Error() != expectedError {
-				t.Fatalf("ValidateDevice(`%q`) error should contain %q, got %q", path, expectedError, err.Error())
-			}
-		}
-	}
-}
-
-func TestParseSystemPaths(t *testing.T) {
-	tests := []struct {
-		doc                       string
-		in, out, masked, readonly []string
-	}{
-		{
-			doc: "not set",
-			in:  []string{},
-			out: []string{},
-		},
-		{
-			doc: "not set, preserve other options",
-			in: []string{
-				"seccomp=unconfined",
-				"apparmor=unconfined",
-				"label=user:USER",
-				"foo=bar",
-			},
-			out: []string{
-				"seccomp=unconfined",
-				"apparmor=unconfined",
-				"label=user:USER",
-				"foo=bar",
-			},
-		},
-		{
-			doc:      "unconfined",
-			in:       []string{"systempaths=unconfined"},
-			out:      []string{},
-			masked:   []string{},
-			readonly: []string{},
-		},
-		{
-			doc:      "unconfined and other options",
-			in:       []string{"foo=bar", "bar=baz", "systempaths=unconfined"},
-			out:      []string{"foo=bar", "bar=baz"},
-			masked:   []string{},
-			readonly: []string{},
-		},
-		{
-			doc: "unknown option",
-			in:  []string{"foo=bar", "systempaths=unknown", "bar=baz"},
-			out: []string{"foo=bar", "systempaths=unknown", "bar=baz"},
-		},
-	}
-
-	for _, tc := range tests {
-		securityOpts, maskedPaths, readonlyPaths := parseSystemPaths(tc.in)
-		assert.DeepEqual(t, securityOpts, tc.out)
-		assert.DeepEqual(t, maskedPaths, tc.masked)
-		assert.DeepEqual(t, readonlyPaths, tc.readonly)
-	}
-}
-
-func TestConvertToStandardNotation(t *testing.T) {
-	valid := map[string][]string{
-		"20:10/tcp":               {"target=10,published=20"},
-		"40:30":                   {"40:30"},
-		"20:20 80:4444":           {"20:20", "80:4444"},
-		"1500:2500/tcp 1400:1300": {"target=2500,published=1500", "1400:1300"},
-		"1500:200/tcp 90:80/tcp":  {"published=1500,target=200", "target=80,published=90"},
-	}
-
-	invalid := [][]string{
-		{"published=1500,target:444"},
-		{"published=1500,444"},
-		{"published=1500,target,444"},
-	}
-
-	for key, ports := range valid {
-		convertedPorts, err := convertToStandardNotation(ports)
-
-		if err != nil {
-			assert.NilError(t, err)
-		}
-		assert.DeepEqual(t, strings.Split(key, " "), convertedPorts)
-	}
-
-	for _, ports := range invalid {
-		if _, err := convertToStandardNotation(ports); err == nil {
-			t.Fatalf("ConvertToStandardNotation(`%q`) should have failed conversion", ports)
-		}
-	}
-}

pkg/container/docker_images.go

@@ -1,60 +0,0 @@
-//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
-
-package container
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/client"
-)
-
-// ImageExistsLocally returns a boolean indicating if an image with the
-// requested name, tag and architecture exists in the local docker image store
-func ImageExistsLocally(ctx context.Context, imageName string, platform string) (bool, error) {
-	cli, err := GetDockerClient(ctx)
-	if err != nil {
-		return false, err
-	}
-	defer cli.Close()
-
-	inspectImage, _, err := cli.ImageInspectWithRaw(ctx, imageName)
-	if client.IsErrNotFound(err) {
-		return false, nil
-	} else if err != nil {
-		return false, err
-	}
-
-	if platform == "" || platform == "any" || fmt.Sprintf("%s/%s", inspectImage.Os, inspectImage.Architecture) == platform {
-		return true, nil
-	}
-
-	return false, nil
-}
-
-// RemoveImage removes image from local store, the function is used to run different
-// container image architectures
-func RemoveImage(ctx context.Context, imageName string, force bool, pruneChildren bool) (bool, error) {
-	cli, err := GetDockerClient(ctx)
-	if err != nil {
-		return false, err
-	}
-	defer cli.Close()
-
-	inspectImage, _, err := cli.ImageInspectWithRaw(ctx, imageName)
-	if client.IsErrNotFound(err) {
-		return false, nil
-	} else if err != nil {
-		return false, err
-	}
-
-	if _, err = cli.ImageRemove(ctx, inspectImage.ID, types.ImageRemoveOptions{
-		Force:         force,
-		PruneChildren: pruneChildren,
-	}); err != nil {
-		return false, err
-	}
-
-	return true, nil
-}

pkg/container/docker_images_test.go

@@ -1,67 +0,0 @@
-package container
-
-import (
-	"context"
-	"io"
-	"testing"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/client"
-	log "github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
-)
-
-func init() {
-	log.SetLevel(log.DebugLevel)
-}
-
-func TestImageExistsLocally(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping integration test")
-	}
-	ctx := context.Background()
-	// to help make this test reliable and not flaky, we need to have
-	// an image that will exist, and onew that won't exist
-
-	// Test if image exists with specific tag
-	invalidImageTag, err := ImageExistsLocally(ctx, "library/alpine:this-random-tag-will-never-exist", "linux/amd64")
-	assert.Nil(t, err)
-	assert.Equal(t, false, invalidImageTag)
-
-	// Test if image exists with specific architecture (image platform)
-	invalidImagePlatform, err := ImageExistsLocally(ctx, "alpine:latest", "windows/amd64")
-	assert.Nil(t, err)
-	assert.Equal(t, false, invalidImagePlatform)
-
-	// pull an image
-	cli, err := client.NewClientWithOpts(client.FromEnv)
-	assert.Nil(t, err)
-	cli.NegotiateAPIVersion(context.Background())
-
-	// Chose alpine latest because it's so small
-	// maybe we should build an image instead so that tests aren't reliable on dockerhub
-	readerDefault, err := cli.ImagePull(ctx, "node:16-buster-slim", types.ImagePullOptions{
-		Platform: "linux/amd64",
-	})
-	assert.Nil(t, err)
-	defer readerDefault.Close()
-	_, err = io.ReadAll(readerDefault)
-	assert.Nil(t, err)
-
-	imageDefaultArchExists, err := ImageExistsLocally(ctx, "node:16-buster-slim", "linux/amd64")
-	assert.Nil(t, err)
-	assert.Equal(t, true, imageDefaultArchExists)
-
-	// Validate if another architecture platform can be pulled
-	readerArm64, err := cli.ImagePull(ctx, "node:16-buster-slim", types.ImagePullOptions{
-		Platform: "linux/arm64",
-	})
-	assert.Nil(t, err)
-	defer readerArm64.Close()
-	_, err = io.ReadAll(readerArm64)
-	assert.Nil(t, err)
-
-	imageArm64Exists, err := ImageExistsLocally(ctx, "node:16-buster-slim", "linux/arm64")
-	assert.Nil(t, err)
-	assert.Equal(t, true, imageArm64Exists)
-}

pkg/container/docker_logger.go

@@ -1,83 +0,0 @@
-//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
-
-package container
-
-import (
-	"bufio"
-	"encoding/json"
-	"errors"
-	"io"
-
-	"github.com/sirupsen/logrus"
-)
-
-type dockerMessage struct {
-	ID          string `json:"id"`
-	Stream      string `json:"stream"`
-	Error       string `json:"error"`
-	ErrorDetail struct {
-		Message string
-	}
-	Status   string `json:"status"`
-	Progress string `json:"progress"`
-}
-
-const logPrefix = "  \U0001F433  "
-
-func logDockerResponse(logger logrus.FieldLogger, dockerResponse io.ReadCloser, isError bool) error {
-	if dockerResponse == nil {
-		return nil
-	}
-	defer dockerResponse.Close()
-
-	scanner := bufio.NewScanner(dockerResponse)
-	msg := dockerMessage{}
-
-	for scanner.Scan() {
-		line := scanner.Bytes()
-
-		msg.ID = ""
-		msg.Stream = ""
-		msg.Error = ""
-		msg.ErrorDetail.Message = ""
-		msg.Status = ""
-		msg.Progress = ""
-
-		if err := json.Unmarshal(line, &msg); err != nil {
-			writeLog(logger, false, "Unable to unmarshal line [%s] ==> %v", string(line), err)
-			continue
-		}
-
-		if msg.Error != "" {
-			writeLog(logger, isError, "%s", msg.Error)
-			return errors.New(msg.Error)
-		}
-
-		if msg.ErrorDetail.Message != "" {
-			writeLog(logger, isError, "%s", msg.ErrorDetail.Message)
-			return errors.New(msg.Error)
-		}
-
-		if msg.Status != "" {
-			if msg.Progress != "" {
-				writeLog(logger, isError, "%s :: %s :: %s\n", msg.Status, msg.ID, msg.Progress)
-			} else {
-				writeLog(logger, isError, "%s :: %s\n", msg.Status, msg.ID)
-			}
-		} else if msg.Stream != "" {
-			writeLog(logger, isError, "%s", msg.Stream)
-		} else {
-			writeLog(logger, false, "Unable to handle line: %s", string(line))
-		}
-	}
-
-	return nil
-}
-
-func writeLog(logger logrus.FieldLogger, isError bool, format string, args ...interface{}) {
-	if isError {
-		logger.Errorf(format, args...)
-	} else {
-		logger.Debugf(format, args...)
-	}
-}

pkg/container/docker_network.go

@@ -1,82 +0,0 @@
-//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
-
-package container
-
-import (
-	"context"
-
-	"github.com/docker/docker/api/types"
-
-	"github.com/nektos/act/pkg/common"
-)
-
-func NewDockerNetworkCreateExecutor(name string) common.Executor {
-	return func(ctx context.Context) error {
-		cli, err := GetDockerClient(ctx)
-		if err != nil {
-			return err
-		}
-		defer cli.Close()
-
-		// Only create the network if it doesn't exist
-		networks, err := cli.NetworkList(ctx, types.NetworkListOptions{})
-		if err != nil {
-			return err
-		}
-		// For Gitea, reduce log noise
-		// common.Logger(ctx).Debugf("%v", networks)
-		for _, network := range networks {
-			if network.Name == name {
-				common.Logger(ctx).Debugf("Network %v exists", name)
-				return nil
-			}
-		}
-
-		_, err = cli.NetworkCreate(ctx, name, types.NetworkCreate{
-			Driver: "bridge",
-			Scope:  "local",
-		})
-		if err != nil {
-			return err
-		}
-
-		return nil
-	}
-}
-
-func NewDockerNetworkRemoveExecutor(name string) common.Executor {
-	return func(ctx context.Context) error {
-		cli, err := GetDockerClient(ctx)
-		if err != nil {
-			return err
-		}
-		defer cli.Close()
-
-		// Make shure that all network of the specified name are removed
-		// cli.NetworkRemove refuses to remove a network if there are duplicates
-		networks, err := cli.NetworkList(ctx, types.NetworkListOptions{})
-		if err != nil {
-			return err
-		}
-		// For Gitea, reduce log noise
-		// common.Logger(ctx).Debugf("%v", networks)
-		for _, network := range networks {
-			if network.Name == name {
-				result, err := cli.NetworkInspect(ctx, network.ID, types.NetworkInspectOptions{})
-				if err != nil {
-					return err
-				}
-
-				if len(result.Containers) == 0 {
-					if err = cli.NetworkRemove(ctx, network.ID); err != nil {
-						common.Logger(ctx).Debugf("%v", err)
-					}
-				} else {
-					common.Logger(ctx).Debugf("Refusing to remove network %v because it still has active endpoints", name)
-				}
-			}
-		}
-
-		return err
-	}
-}