Compare commits
No commits in common. "main" and "v9.0.0" have entirely different histories.
239 changed files with 2387 additions and 8715 deletions
|
|
@ -1,46 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -ex
|
||||
|
||||
forgejo=$1
|
||||
forgejo_pr=$2
|
||||
runner=$3
|
||||
runner_pr_or_ref=$4
|
||||
|
||||
#
|
||||
# Get information from the runner
|
||||
#
|
||||
cd $runner
|
||||
#
|
||||
# code.forgejo.org/forgejo/runner/vN may be
|
||||
# upgraded to code.forgejo.org/forgejo/runner/vN+1
|
||||
#
|
||||
module=$(cat go.mod | head -1 | cut -d' ' -f2)
|
||||
test "$module"
|
||||
sha=$(git -C $runner show --no-patch --format=%H)
|
||||
test "$sha"
|
||||
|
||||
#
|
||||
# Update Forgejo to use the runner at $runner_pr_or_ref
|
||||
#
|
||||
cd $forgejo
|
||||
#
|
||||
# Update the runner major version if needed
|
||||
#
|
||||
find * -name '*.go' -o -name 'go.mod' | xargs sed -i -E -e "s|code.forgejo.org/forgejo/runner/v[0-9]+|$module|"
|
||||
#
|
||||
# If it is a pull request, change the module to reference the forked repository so
|
||||
# go mod tidy can find the SHA from a known branch or tag
|
||||
#
|
||||
if test -f "$runner_pr_or_ref"; then
|
||||
repository=$(jq --raw-output .head.repo.full_name <$runner_pr_or_ref)
|
||||
test "$repository"
|
||||
module=$(echo $module | sed -e "s|code.forgejo.org/forgejo/runner|code.forgejo.org/$repository|")
|
||||
fi
|
||||
#
|
||||
# add a "replace code.forgejo.org/forgejo/runner/v?? $sha" line to the forgejo go.mod
|
||||
# so that it uses the branch or pull request from which the cascade is run.
|
||||
#
|
||||
sed -i -e "\|replace $module|d" go.mod
|
||||
echo "replace $module => $module $sha" >>go.mod
|
||||
go mod tidy
|
||||
16
.forgejo/cascading-pr-setup-forgejo
Executable file
16
.forgejo/cascading-pr-setup-forgejo
Executable file
|
|
@ -0,0 +1,16 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -ex
|
||||
|
||||
setup_forgejo=$1
|
||||
setup_forgejo_pr=$2
|
||||
runner=$3
|
||||
runner_pr=$4
|
||||
|
||||
url=$(jq --raw-output .head.repo.html_url < $runner_pr)
|
||||
test "$url" != null
|
||||
branch=$(jq --raw-output .head.ref < $runner_pr)
|
||||
test "$branch" != null
|
||||
cd $setup_forgejo
|
||||
./utils/upgrade-runner.sh $url @$branch
|
||||
date > last-upgrade
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -ex
|
||||
|
||||
setup_forgejo=$1
|
||||
setup_forgejo_pr=$2
|
||||
runner=$3
|
||||
runner_pr_or_ref=$4
|
||||
|
||||
if test -f "$runner_pr_or_ref"; then
|
||||
url=$(jq --raw-output .head.repo.html_url <$runner_pr_or_ref)
|
||||
test "$url" != null
|
||||
branch=$(jq --raw-output .head.ref <$runner_pr_or_ref)
|
||||
else
|
||||
url=https://code.forgejo.org/forgejo/runner
|
||||
branch=${runner_pr_or_ref#refs/heads/}
|
||||
fi
|
||||
test "$url"
|
||||
test "$branch"
|
||||
test "$branch" != null
|
||||
cd $setup_forgejo
|
||||
./utils/upgrade-runner.sh $url @$branch
|
||||
rm -f .forgejo/workflows/integration*.yml
|
||||
date >last-upgrade
|
||||
|
|
@ -8,7 +8,7 @@ expectedLabels = {
|
|||
"org.opencontainers.image.source": "https://code.forgejo.org/forgejo/runner",
|
||||
"org.opencontainers.image.version": "1.2.3",
|
||||
"org.opencontainers.image.vendor": "Forgejo",
|
||||
"org.opencontainers.image.licenses": "GPL-3.0-or-later",
|
||||
"org.opencontainers.image.licenses": "MIT",
|
||||
"org.opencontainers.image.title": "Forgejo Runner",
|
||||
"org.opencontainers.image.description": "A runner for Forgejo Actions.",
|
||||
}
|
||||
|
|
|
|||
78
.forgejo/workflows/act.yml
Normal file
78
.forgejo/workflows/act.yml
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
name: act
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- 'main'
|
||||
pull_request:
|
||||
|
||||
env:
|
||||
GOPROXY: https://goproxy.io,direct
|
||||
GOPATH: /go_path
|
||||
GOCACHE: /go_cache
|
||||
|
||||
jobs:
|
||||
unit:
|
||||
runs-on: docker
|
||||
container:
|
||||
image: 'code.forgejo.org/oci/node:22-bookworm'
|
||||
steps:
|
||||
- name: cache go path
|
||||
id: cache-go-path
|
||||
uses: https://code.forgejo.org/actions/cache@v4
|
||||
with:
|
||||
path: /go_path
|
||||
key: go_path-${{ forge.repository }}-${{ forge.ref_name }}
|
||||
restore-keys: |
|
||||
go_path-${{ forge.repository }}-
|
||||
go_path-
|
||||
- name: cache go cache
|
||||
id: cache-go-cache
|
||||
uses: https://code.forgejo.org/actions/cache@v4
|
||||
with:
|
||||
path: /go_cache
|
||||
key: go_cache-${{ forge.repository }}-${{ forge.ref_name }}
|
||||
restore-keys: |
|
||||
go_cache-${{ forge.repository }}-
|
||||
go_cache-
|
||||
|
||||
- uses: https://code.forgejo.org/actions/checkout@v4
|
||||
|
||||
- uses: https://code.forgejo.org/actions/setup-go@v5
|
||||
with:
|
||||
go-version-file: go.mod
|
||||
|
||||
- name: validate go version
|
||||
run: |
|
||||
set -ex
|
||||
toolchain=$(grep -oP '(?<=toolchain ).+' go.mod)
|
||||
version=$(go version | cut -d' ' -f3)
|
||||
if dpkg --compare-versions ${version#go} lt ${toolchain#go}; then
|
||||
echo "go version too low: $toolchain >= $version"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
- name: unit test
|
||||
run: |
|
||||
go test -short ./act/container
|
||||
go test ./act/artifactcache/... ./act/workflowpattern/... ./act/filecollector/... ./act/common/... ./act/jobparser ./act/model ./act/exprparser ./act/schema
|
||||
|
||||
integration:
|
||||
runs-on: lxc-bookworm
|
||||
needs: [unit]
|
||||
steps:
|
||||
- uses: https://code.forgejo.org/actions/checkout@v4
|
||||
|
||||
- uses: https://code.forgejo.org/actions/setup-go@v5
|
||||
with:
|
||||
go-version-file: go.mod
|
||||
|
||||
- name: apt install docker.io
|
||||
run: |
|
||||
export DEBIAN_FRONTEND=noninteractive
|
||||
apt-get update -qq
|
||||
apt-get -q install -qq -y docker.io
|
||||
|
||||
- name: integration test
|
||||
run: |
|
||||
go test ./act/container
|
||||
go test ./act/runner/...
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
name: ci
|
||||
|
||||
on:
|
||||
push:
|
||||
tags:
|
||||
- v*
|
||||
|
||||
jobs:
|
||||
goreleaser:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Set up Go
|
||||
uses: actions/setup-go@v6
|
||||
with:
|
||||
go-version: ">=1.25.1"
|
||||
- name: Test code
|
||||
run: make test
|
||||
- name: Run GoReleaser
|
||||
uses: https://github.com/goreleaser/goreleaser-action@v6
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.PACKAGES_TOKEN }}
|
||||
with:
|
||||
args: release --clean
|
||||
|
|
@ -18,22 +18,19 @@ on:
|
|||
|
||||
enable-email-notifications: true
|
||||
|
||||
env:
|
||||
FORGEJO_VERSION: 11.0.7 # renovate: datasource=docker depName=code.forgejo.org/forgejo/forgejo
|
||||
|
||||
jobs:
|
||||
release-simulation:
|
||||
runs-on: lxc-bookworm
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
if: forge.repository_owner != 'forgejo-integration' && forge.repository_owner != 'forgejo-release'
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- id: forgejo
|
||||
uses: https://data.forgejo.org/actions/setup-forgejo@v3.0.4
|
||||
uses: https://data.forgejo.org/actions/setup-forgejo@v3.0.1
|
||||
with:
|
||||
user: root
|
||||
password: admin1234
|
||||
image-version: ${{ env.FORGEJO_VERSION }}
|
||||
image-version: 1.20
|
||||
lxc-ip-prefix: 10.0.9
|
||||
|
||||
- name: publish
|
||||
|
|
|
|||
|
|
@ -21,9 +21,9 @@ jobs:
|
|||
release:
|
||||
runs-on: lxc-bookworm
|
||||
# root is used for testing, allow it
|
||||
if: vars.ROLE == 'forgejo-integration' || forge.repository_owner == 'root'
|
||||
if: secrets.ROLE == 'forgejo-integration' || forge.repository_owner == 'root'
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Increase the verbosity when there are no secrets
|
||||
id: verbose
|
||||
|
|
@ -60,9 +60,20 @@ jobs:
|
|||
version=${FORGEJO_REF_NAME##*v}
|
||||
echo "value=$version" >> "$FORGEJO_OUTPUT"
|
||||
|
||||
- name: release notes
|
||||
id: release-notes
|
||||
run: |
|
||||
anchor=${{ steps.tag-version.outputs.value }}
|
||||
anchor=${anchor//./-}
|
||||
cat >> "$FORGEJO_OUTPUT" <<EOF
|
||||
value<<ENDVAR
|
||||
See https://code.forgejo.org/forgejo/runner/src/branch/main/RELEASE-NOTES.md#$anchor
|
||||
ENDVAR
|
||||
EOF
|
||||
|
||||
- name: build without TOKEN
|
||||
if: ${{ secrets.TOKEN == '' }}
|
||||
uses: https://data.forgejo.org/forgejo/forgejo-build-publish/build@v5.4.1
|
||||
uses: https://data.forgejo.org/forgejo/forgejo-build-publish/build@v5.4.0
|
||||
with:
|
||||
forgejo: "${{ env.FORGEJO_SERVER_URL }}"
|
||||
owner: "${{ env.FORGEJO_REPOSITORY_OWNER }}"
|
||||
|
|
@ -72,13 +83,14 @@ jobs:
|
|||
release-version: "${{ steps.tag-version.outputs.value }}"
|
||||
token: ${{ steps.token.outputs.value }}
|
||||
platforms: linux/amd64,linux/arm64
|
||||
release-notes: "${{ steps.release-notes.outputs.value }}"
|
||||
binary-name: forgejo-runner
|
||||
binary-path: /bin/forgejo-runner
|
||||
verbose: ${{ steps.verbose.outputs.value }}
|
||||
|
||||
- name: build with TOKEN
|
||||
if: ${{ secrets.TOKEN != '' }}
|
||||
uses: https://data.forgejo.org/forgejo/forgejo-build-publish/build@v5.4.1
|
||||
uses: https://data.forgejo.org/forgejo/forgejo-build-publish/build@v5.4.0
|
||||
with:
|
||||
forgejo: "${{ env.FORGEJO_SERVER_URL }}"
|
||||
owner: "${{ env.FORGEJO_REPOSITORY_OWNER }}"
|
||||
|
|
@ -88,6 +100,7 @@ jobs:
|
|||
release-version: "${{ steps.tag-version.outputs.value }}"
|
||||
token: "${{ secrets.TOKEN }}"
|
||||
platforms: linux/amd64,linux/arm64
|
||||
release-notes: "${{ steps.release-notes.outputs.value }}"
|
||||
binary-name: forgejo-runner
|
||||
binary-path: /bin/forgejo-runner
|
||||
verbose: ${{ steps.verbose.outputs.value }}
|
||||
|
|
|
|||
|
|
@ -1,110 +0,0 @@
|
|||
# Copyright 2025 The Forgejo Authors
|
||||
# SPDX-License-Identifier: MIT
|
||||
#
|
||||
# FORGEJO_CASCADING_PR_ORIGIN_TOKEN is a token from the https://code.forgejo.org/cascading-pr user
|
||||
# with scope write:issue read:repository read:user
|
||||
# FORGEJO_CASCADING_PR_DESTINATION_TOKEN is a token from the https://codeberg.org/forgejo-cascading-pr user
|
||||
# with scope write:issue write:repository read:user
|
||||
#
|
||||
# To modify this workflow:
|
||||
#
|
||||
# - push it to the wip-cascade branch on the repository
|
||||
# otherwise it will not have access to the secrets required to push
|
||||
# the cascading PR
|
||||
#
|
||||
# - once it works, open a pull request for the sake of keeping track
|
||||
# of the change even if the PR won't run it because it will use
|
||||
# whatever is in the default branch instead
|
||||
#
|
||||
# - after it is merged, double check it works by setting the
|
||||
# label on a pull request (any pull request will do)
|
||||
#
|
||||
name: cascade
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- 'main'
|
||||
- 'wip-cascade'
|
||||
pull_request_target:
|
||||
types:
|
||||
- synchronize
|
||||
- labeled
|
||||
- closed
|
||||
|
||||
enable-email-notifications: true
|
||||
|
||||
jobs:
|
||||
debug:
|
||||
if: >
|
||||
vars.DEBUG == 'yes'
|
||||
runs-on: docker
|
||||
container:
|
||||
image: data.forgejo.org/oci/node:22-bookworm
|
||||
steps:
|
||||
- name: event
|
||||
run: |
|
||||
cat <<'EOF'
|
||||
${{ toJSON(forge.event.pull_request.labels.*.name) }}
|
||||
EOF
|
||||
cat <<'EOF'
|
||||
push => ${{ forge.event_name == 'push' && ( forge.ref_name == 'main' || forge.ref_name == 'wip-cascade') }}
|
||||
pull_request_target synchornized => ${{ ( forge.event.action == 'synchronized' && contains(forge.event.pull_request.labels.*.name, 'run-forgejo-tests') ) }}
|
||||
pull_request_target label_updated => ${{ ( forge.event.action == 'label_updated' && forge.event.label.name == 'run-forgejo-tests' ) }}
|
||||
contains => ${{ contains(forge.event.pull_request.labels.*.name, 'run-forgejo-tests') }}
|
||||
contains boolean => ${{ contains(forge.event.pull_request.labels.*.name, 'run-forgejo-tests') == true }}
|
||||
EOF
|
||||
cat <<'EOF'
|
||||
${{ toJSON(forge) }}
|
||||
EOF
|
||||
|
||||
forgejo:
|
||||
#
|
||||
# Always run when a commit is pushed to the main or wip-cascade branch
|
||||
# If this is a pull request, run
|
||||
# - when the `run-forgejo-tests` label is set (label_updated) (but not if another label is set or if a label is removed)
|
||||
# - when a new commit is pushed to the pull request (synchronized) if the `run-forgejo-tests` is already present
|
||||
# - when the pull request is closed, which also happens when it is merged, so that the Forgejo pull request is closed
|
||||
#
|
||||
if: >
|
||||
vars.ROLE == 'forgejo-coding' && (
|
||||
(
|
||||
forge.event_name == 'push' && ( forge.ref_name == 'main' || forge.ref_name == 'wip-cascade')
|
||||
) || (
|
||||
forge.event_name == 'pull_request_target' && (
|
||||
forge.event.action == 'closed' ||
|
||||
( forge.event.action == 'synchronized' && contains(forge.event.pull_request.labels.*.name, 'run-forgejo-tests') ) ||
|
||||
( forge.event.action == 'label_updated' && forge.event.label.name == 'run-forgejo-tests' )
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
runs-on: docker
|
||||
container:
|
||||
image: data.forgejo.org/oci/node:22-bookworm
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: '0'
|
||||
show-progress: 'false'
|
||||
- uses: https://data.forgejo.org/actions/setup-go@v5
|
||||
with:
|
||||
go-version-file: go.mod
|
||||
- uses: https://data.forgejo.org/actions/cascading-pr@v2.3.0
|
||||
with:
|
||||
origin-url: ${{ forge.server_url }}
|
||||
origin-repo: ${{ forge.repository }}
|
||||
origin-token: ${{ secrets.FORGEJO_CASCADING_PR_ORIGIN_TOKEN }}
|
||||
origin-pr: ${{ forge.event.pull_request.number }}
|
||||
origin-ref: ${{ forge.event_name == 'push' && forge.event.ref || '' }}
|
||||
destination-url: https://codeberg.org
|
||||
destination-fork-repo: forgejo-cascading-pr/forgejo
|
||||
destination-repo: forgejo/forgejo
|
||||
destination-branch: forgejo
|
||||
destination-token: ${{ secrets.FORGEJO_CASCADING_PR_DESTINATION_TOKEN }}
|
||||
prefix: runner
|
||||
close: true
|
||||
verbose: ${{ vars.VERBOSE == 'yes' }}
|
||||
debug: ${{ vars.DEBUG == 'yes' }}
|
||||
wait-iteration: 120
|
||||
update: .forgejo/cascading-forgejo
|
||||
|
|
@ -1,99 +1,31 @@
|
|||
# Copyright 2025 The Forgejo Authors
|
||||
# SPDX-License-Identifier: MIT
|
||||
#
|
||||
# CASCADING_PR_ORIGIN is a token from the https://code.forgejo.org/cascading-pr user
|
||||
# with scope write:issue read:repository read:user
|
||||
# CASCADING_PR_DESTINATION is a token from the https://code.forgejo.org/cascading-pr user
|
||||
# with scope write:issue write:repository read:user
|
||||
#
|
||||
# To modify this workflow:
|
||||
#
|
||||
# - push it to the wip-cascade branch on the repository
|
||||
# otherwise it will not have access to the secrets required to push
|
||||
# the cascading PR
|
||||
#
|
||||
# - once it works, open a pull request for the sake of keeping track
|
||||
# of the change even if the PR won't run it because it will use
|
||||
# whatever is in the default branch instead
|
||||
#
|
||||
# - after it is merged, double check it works by setting the
|
||||
# label on a pull request (any pull request will do)
|
||||
#
|
||||
name: cascade
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- 'wip-cascade'
|
||||
pull_request_target:
|
||||
types:
|
||||
- opened
|
||||
- synchronize
|
||||
- labeled
|
||||
- closed
|
||||
|
||||
enable-email-notifications: true
|
||||
|
||||
jobs:
|
||||
debug:
|
||||
if: >
|
||||
vars.DEBUG == 'yes'
|
||||
runs-on: docker
|
||||
container:
|
||||
image: data.forgejo.org/oci/node:22-bookworm
|
||||
steps:
|
||||
- name: event
|
||||
run: |
|
||||
cat <<'EOF'
|
||||
${{ toJSON(forge.event.pull_request.labels.*.name) }}
|
||||
EOF
|
||||
cat <<'EOF'
|
||||
push => ${{ forge.event_name == 'push' && ( forge.ref_name == 'wip-cascade') }}
|
||||
pull_request_target synchornized => ${{ ( forge.event.action == 'synchronized' && contains(forge.event.pull_request.labels.*.name, 'run-end-to-end-tests') ) }}
|
||||
pull_request_target label_updated => ${{ ( forge.event.action == 'label_updated' && forge.event.label.name == 'run-end-to-end-tests' ) }}
|
||||
contains => ${{ contains(forge.event.pull_request.labels.*.name, 'run-end-to-end-tests') }}
|
||||
contains boolean => ${{ contains(forge.event.pull_request.labels.*.name, 'run-end-to-end-tests') == true }}
|
||||
EOF
|
||||
cat <<'EOF'
|
||||
${{ toJSON(forge) }}
|
||||
EOF
|
||||
|
||||
end-to-end:
|
||||
#
|
||||
# Always run when a commit is pushed to the wip-cascade branch
|
||||
# If this is a pull request, run
|
||||
# - when the `run-end-to-end-tests` label is set (label_updated) (but not if another label is set or if a label is removed)
|
||||
# - when a new commit is pushed to the pull request (synchronized) if the `run-end-to-end-tests` is already present
|
||||
# - when the pull request is closed, which also happens when it is merged, so that the setup-forgejo & end-to-end pull requests are closed
|
||||
#
|
||||
if: >
|
||||
vars.ROLE == 'forgejo-coding' && (
|
||||
(
|
||||
forge.event_name == 'push' && ( forge.ref_name == 'wip-cascade' )
|
||||
) || (
|
||||
forge.event_name == 'pull_request_target' && (
|
||||
forge.event.action == 'closed' ||
|
||||
( forge.event.action == 'synchronized' && contains(forge.event.pull_request.labels.*.name, 'run-end-to-end-tests') ) ||
|
||||
( forge.event.action == 'label_updated' && forge.event.label.name == 'run-end-to-end-tests' )
|
||||
)
|
||||
)
|
||||
)
|
||||
cascade:
|
||||
runs-on: docker
|
||||
container:
|
||||
image: 'code.forgejo.org/oci/node:22-bookworm'
|
||||
if: >
|
||||
! contains(forge.event.pull_request.title, '[skip cascade]')
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/cascading-pr@v2.3.0
|
||||
- uses: https://code.forgejo.org/actions/cascading-pr@v2.2.1
|
||||
with:
|
||||
origin-url: ${{ forge.server_url }}
|
||||
origin-repo: ${{ forge.repository }}
|
||||
origin-url: ${{ env.FORGEJO_SERVER_URL }}
|
||||
origin-repo: forgejo/runner
|
||||
origin-token: ${{ secrets.CASCADING_PR_ORIGIN }}
|
||||
origin-pr: ${{ forge.event.pull_request.number }}
|
||||
origin-ref: ${{ forge.event_name == 'push' && forge.event.ref || '' }}
|
||||
destination-url: ${{ forge.server_url }}
|
||||
destination-url: ${{ env.FORGEJO_SERVER_URL }}
|
||||
destination-repo: actions/setup-forgejo
|
||||
destination-fork-repo: cascading-pr/setup-forgejo
|
||||
destination-branch: main
|
||||
destination-token: ${{ secrets.CASCADING_PR_DESTINATION }}
|
||||
close: true
|
||||
verbose: ${{ vars.VERBOSE == 'yes' }}
|
||||
debug: ${{ vars.DEBUG == 'yes' }}
|
||||
update: .forgejo/cascading-setup-forgejo
|
||||
close-merge: true
|
||||
update: .forgejo/cascading-pr-setup-forgejo
|
||||
|
|
|
|||
|
|
@ -1,85 +0,0 @@
|
|||
#
|
||||
# Example that requires a Forgejo runner with an [LXC backend](https://forgejo.org/docs/latest/admin/actions/runner-installation/#setting-up-the-container-environment).
|
||||
#
|
||||
# - Start a Forgejo instance to be used as a container registry
|
||||
# - Build a container image using the [docker/build-push-action](https://code.forgejo.org/docker/build-push-action) action
|
||||
# - Push the image to the Forgejo instance
|
||||
# - Retrieve the image
|
||||
#
|
||||
# Runs of this workflow can be seen in [the Forgejo runner](https://code.forgejo.org/forgejo/runner/actions?workflow=docker-build-push-action-in-lxc.yml) logs.
|
||||
#
|
||||
name: example
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- 'main'
|
||||
pull_request:
|
||||
paths:
|
||||
- examples/docker-build-push-action/**
|
||||
- .forgejo/workflows/docker-build-push-action-in-lxc.yml
|
||||
|
||||
enable-email-notifications: true
|
||||
|
||||
env:
|
||||
FORGEJO_VERSION: 11.0.7 # renovate: datasource=docker depName=code.forgejo.org/forgejo/forgejo
|
||||
FORGEJO_USER: root
|
||||
FORGEJO_PASSWORD: admin1234
|
||||
|
||||
jobs:
|
||||
docker-build-push-action-in-lxc:
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: lxc-bookworm
|
||||
|
||||
steps:
|
||||
|
||||
- name: install Forgejo so it can be used as a container registry
|
||||
id: registry
|
||||
uses: https://data.forgejo.org/actions/setup-forgejo@v3.0.4
|
||||
with:
|
||||
user: ${{ env.FORGEJO_USER }}
|
||||
password: ${{ env.FORGEJO_PASSWORD }}
|
||||
binary: https://code.forgejo.org/forgejo/forgejo/releases/download/v${{ env.FORGEJO_VERSION }}/forgejo-${{ env.FORGEJO_VERSION }}-linux-amd64
|
||||
lxc-ip-prefix: 10.0.9
|
||||
|
||||
- name: enable insecure / http uploads to the Forgejo registry
|
||||
run: |-
|
||||
set -x
|
||||
# the docker daemon was implicitly installed when Forgejo was
|
||||
# installed in the previous step. But it will refuse to connect
|
||||
# to an insecure / http registry by default and must be told
|
||||
# otherwise
|
||||
cat > /etc/docker/daemon.json <<EOF
|
||||
{
|
||||
"insecure-registries" : ["${{ steps.registry.outputs.host-port }}"]
|
||||
}
|
||||
EOF
|
||||
systemctl restart docker
|
||||
|
||||
- uses: https://data.forgejo.org/docker/setup-qemu-action@v3
|
||||
- uses: https://data.forgejo.org/docker/setup-buildx-action@v2
|
||||
with:
|
||||
# insecure / http connections to the registry are allowed
|
||||
config-inline: |
|
||||
[registry."${{ steps.registry.outputs.host-port }}"]
|
||||
http = true
|
||||
|
||||
- name: login to the Forgejo registry
|
||||
uses: https://data.forgejo.org/docker/login-action@v3
|
||||
with:
|
||||
registry: ${{ steps.registry.outputs.host-port }}
|
||||
username: ${{ env.FORGEJO_USER }}
|
||||
password: ${{ env.FORGEJO_PASSWORD }}
|
||||
|
||||
- name: build and push to the Forgejo registry
|
||||
uses: https://data.forgejo.org/docker/build-push-action@v5
|
||||
with:
|
||||
context: examples/docker-build-push-action
|
||||
push: true
|
||||
tags: ${{ steps.registry.outputs.host-port }}/root/testimage:latest
|
||||
cache-from: type=gha,scope=docker-build-push-action-in-lxc
|
||||
cache-to: type=gha,scope=docker-build-push-action-in-lxc
|
||||
|
||||
- name: verify the image can be read from the Forgejo registry
|
||||
run: |
|
||||
set -x
|
||||
docker pull ${{ steps.registry.outputs.host-port }}/root/testimage:latest
|
||||
|
|
@ -12,10 +12,10 @@ enable-email-notifications: true
|
|||
|
||||
jobs:
|
||||
example-docker-compose:
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
if: forge.repository_owner != 'forgejo-integration' && forge.repository_owner != 'forgejo-experimental' && forge.repository_owner != 'forgejo-release'
|
||||
runs-on: lxc-bookworm
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install docker
|
||||
run: |
|
||||
|
|
|
|||
|
|
@ -14,12 +14,11 @@ env:
|
|||
SERIAL: "30"
|
||||
LIFETIME: "60"
|
||||
SYSTEMD_OPTIONS: "--no-pager --full"
|
||||
USE_VERSION: 11.0.7 # renovate: datasource=docker depName=code.forgejo.org/forgejo/forgejo
|
||||
|
||||
jobs:
|
||||
example-lxc-systemd:
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: lxc-trixie
|
||||
if: forge.repository_owner != 'forgejo-integration' && forge.repository_owner != 'forgejo-experimental' && forge.repository_owner != 'forgejo-release'
|
||||
runs-on: lxc-bookworm
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
|
||||
|
|
@ -54,11 +53,11 @@ jobs:
|
|||
done
|
||||
|
||||
- id: forgejo
|
||||
uses: https://data.forgejo.org/actions/setup-forgejo@v3.0.4
|
||||
uses: https://data.forgejo.org/actions/setup-forgejo@v3.0.1
|
||||
with:
|
||||
user: root
|
||||
password: admin1234
|
||||
binary: https://code.forgejo.org/forgejo/forgejo/releases/download/v${{ env.USE_VERSION }}/forgejo-${{ env.USE_VERSION }}-linux-amd64
|
||||
binary: https://code.forgejo.org/forgejo/forgejo/releases/download/v7.0.12/forgejo-7.0.12-linux-amd64
|
||||
# must be the same as LXC_IPV4_PREFIX in examples/lxc-systemd/forgejo-runner-service.sh
|
||||
lxc-ip-prefix: 10.105.7
|
||||
|
||||
|
|
@ -124,8 +123,8 @@ jobs:
|
|||
started_running=/etc/forgejo-runner/$serial/started-running
|
||||
killed_gracefully=/etc/forgejo-runner/$serial/killed-gracefully
|
||||
stopped_gracefully=/etc/forgejo-runner/$serial/stopped-gracefully
|
||||
retry --delay 10 --times 20 cp -a $started_running /tmp/first-run
|
||||
retry --delay 2 --times 30 grep --quiet 'Starting runner daemon' /var/log/forgejo-runner/$serial.log
|
||||
retry --delay 5 --times 20 cp -a $started_running /tmp/first-run
|
||||
retry --delay 1 --times 30 grep --quiet 'Starting runner daemon' /var/log/forgejo-runner/$serial.log
|
||||
systemctl stop forgejo-runner@$serial
|
||||
! systemctl $all status forgejo-runner@$serial
|
||||
ls -l /etc/forgejo-runner/$serial
|
||||
|
|
@ -137,7 +136,7 @@ jobs:
|
|||
! test -f $killed_gracefully
|
||||
! test -f $stopped_gracefully
|
||||
lifetime=${{ env.LIFETIME }}
|
||||
: give it time to restart at least once
|
||||
# give it time to restart at least once
|
||||
ls -l /etc/forgejo-runner/$serial
|
||||
sleep $lifetime ; sleep $lifetime
|
||||
ls -l /etc/forgejo-runner/$serial
|
||||
|
|
|
|||
|
|
@ -8,7 +8,6 @@
|
|||
# vars.FROM_OWNER: forgejo-integration
|
||||
# vars.TO_OWNER: forgejo
|
||||
# vars.DOER: release-team
|
||||
# vars.ROLE: forgejo-release
|
||||
# secrets.TOKEN: <generated from code.forgejo.org/release-team>
|
||||
# secrets.GPG_PRIVATE_KEY: <XYZ>
|
||||
# secrets.GPG_PASSPHRASE: <ABC>
|
||||
|
|
@ -25,27 +24,19 @@ enable-email-notifications: true
|
|||
jobs:
|
||||
publish:
|
||||
runs-on: lxc-bookworm
|
||||
if: vars.ROLE == 'forgejo-release'
|
||||
if: vars.DOER != '' && vars.FORGEJO != '' && vars.TO_OWNER != '' && vars.FROM_OWNER != '' && secrets.TOKEN != ''
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
|
||||
- name: copy & sign
|
||||
uses: https://data.forgejo.org/forgejo/forgejo-build-publish/publish@v5.4.1
|
||||
uses: https://data.forgejo.org/forgejo/forgejo-build-publish/publish@v5.4.0
|
||||
with:
|
||||
from-forgejo: ${{ vars.FORGEJO }}
|
||||
to-forgejo: ${{ vars.FORGEJO }}
|
||||
from-owner: ${{ vars.FROM_OWNER }}
|
||||
to-owner: ${{ vars.TO_OWNER }}
|
||||
repo: "runner"
|
||||
release-notes: |
|
||||
- [User guide](https://forgejo.org/docs/next/user/actions/overview/)
|
||||
- [Administrator guide](https://forgejo.org/docs/next/admin/actions/)
|
||||
- [Container images](https://code.forgejo.org/forgejo/-/packages/container/runner/versions)
|
||||
|
||||
Release Notes
|
||||
|
||||
---
|
||||
|
||||
release-notes: "See also https://code.forgejo.org/forgejo/runner/src/branch/main/RELEASE-NOTES.md#{ANCHOR}"
|
||||
release-notes-assistant: true
|
||||
ref-name: ${{ forge.ref_name }}
|
||||
sha: ${{ forge.sha }}
|
||||
|
|
|
|||
|
|
@ -6,17 +6,16 @@ name: issue-labels
|
|||
on:
|
||||
pull_request_target:
|
||||
types:
|
||||
- opened
|
||||
- edited
|
||||
- synchronize
|
||||
- labeled
|
||||
|
||||
env:
|
||||
RNA_VERSION: v1.4.1 # renovate: datasource=forgejo-releases depName=forgejo/release-notes-assistant
|
||||
RNA_VERSION: v1.3.5 # renovate: datasource=forgejo-releases depName=forgejo/release-notes-assistant registryUrl=https://code.forgejo.org
|
||||
|
||||
jobs:
|
||||
release-notes:
|
||||
if: vars.ROLE == 'forgejo-coding' && !contains(forge.event.pull_request.labels.*.name, 'Kind/DependencyUpdate')
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: docker
|
||||
container:
|
||||
image: 'data.forgejo.org/oci/ci:1'
|
||||
|
|
|
|||
|
|
@ -14,18 +14,19 @@ env:
|
|||
FORGEJO_RUNNER_SECRET: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
|
||||
FORGEJO_SCRIPT: |
|
||||
/usr/bin/s6-svscan /etc/s6 & sleep 10 ; su -c "forgejo admin user create --admin --username $FORGEJO_ADMIN_USER --password $FORGEJO_ADMIN_PASSWORD --email root@example.com" git && su -c "forgejo forgejo-cli actions register --labels docker --name therunner --secret $FORGEJO_RUNNER_SECRET" git && sleep infinity
|
||||
GOPROXY: https://goproxy.io,direct
|
||||
|
||||
jobs:
|
||||
build-and-tests:
|
||||
name: build and test
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
if: forge.repository_owner != 'forgejo-integration' && forge.repository_owner != 'forgejo-experimental' && forge.repository_owner != 'forgejo-release'
|
||||
runs-on: docker
|
||||
container:
|
||||
image: 'code.forgejo.org/oci/ci:1'
|
||||
|
||||
services:
|
||||
forgejo:
|
||||
image: code.forgejo.org/forgejo/forgejo:11
|
||||
image: codeberg.org/forgejo/forgejo:11
|
||||
env:
|
||||
FORGEJO__security__INSTALL_LOCK: "true"
|
||||
FORGEJO__log__LEVEL: "debug"
|
||||
|
|
@ -39,9 +40,9 @@ jobs:
|
|||
- '/usr/bin/s6-svscan /etc/s6 & sleep 10 ; su -c "forgejo admin user create --admin --username $FORGEJO_ADMIN_USER --password $FORGEJO_ADMIN_PASSWORD --email root@example.com" git && su -c "forgejo forgejo-cli actions register --labels docker --name therunner --secret $FORGEJO_RUNNER_SECRET" git && sleep infinity'
|
||||
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: https://data.forgejo.org/actions/setup-go@v5
|
||||
- uses: actions/setup-go@v5
|
||||
with:
|
||||
go-version-file: go.mod
|
||||
|
||||
|
|
@ -59,7 +60,7 @@ jobs:
|
|||
|
||||
- run: make build
|
||||
|
||||
- uses: https://data.forgejo.org/actions/upload-artifact@v3
|
||||
- uses: https://code.forgejo.org/actions/upload-artifact@v3
|
||||
with:
|
||||
name: forgejo-runner
|
||||
path: forgejo-runner
|
||||
|
|
@ -73,15 +74,16 @@ jobs:
|
|||
- run: make FORGEJO_URL=http://$FORGEJO_HOST_PORT test
|
||||
|
||||
runner-exec-tests:
|
||||
name: runner exec tests
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: lxc-bookworm
|
||||
needs: [build-and-tests]
|
||||
name: runner exec tests
|
||||
if: forge.repository_owner != 'forgejo-integration' && forge.repository_owner != 'forgejo-experimental' && forge.repository_owner != 'forgejo-release'
|
||||
runs-on: lxc-bookworm
|
||||
|
||||
steps:
|
||||
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: https://data.forgejo.org/actions/download-artifact@v3
|
||||
- uses: https://code.forgejo.org/actions/download-artifact@v3
|
||||
with:
|
||||
name: forgejo-runner
|
||||
|
||||
|
|
@ -125,150 +127,3 @@ jobs:
|
|||
set -x
|
||||
./forgejo-runner exec --var MY_VAR=testvariable --workflows .forgejo/testdata/var.yml |& tee /tmp/var.out
|
||||
grep --quiet 'Success - Main echo "VAR -> testvariable"' /tmp/var.out
|
||||
|
||||
integration-tests:
|
||||
name: integration tests
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: lxc-bookworm
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
|
||||
- uses: https://data.forgejo.org/actions/setup-go@v5
|
||||
with:
|
||||
go-version-file: go.mod
|
||||
|
||||
- name: apt install docker.io
|
||||
run: |
|
||||
export DEBIAN_FRONTEND=noninteractive
|
||||
apt-get update -qq
|
||||
apt-get -q install -qq -y docker.io
|
||||
|
||||
- run: apt-get -q install -qq -y gcc # required for `-race`
|
||||
- name: integration test
|
||||
run: |
|
||||
go test -race ./act/container
|
||||
go test -race -timeout 30m ./act/runner/...
|
||||
|
||||
runner-integration-tests:
|
||||
name: runner integration tests
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: lxc-bookworm
|
||||
needs: [build-and-tests]
|
||||
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
|
||||
- uses: https://data.forgejo.org/actions/setup-go@v5
|
||||
with:
|
||||
go-version-file: go.mod
|
||||
|
||||
- name: install docker
|
||||
run: |
|
||||
mkdir /etc/docker
|
||||
cat > /etc/docker/daemon.json <<EOF
|
||||
{
|
||||
"ipv6": true,
|
||||
"experimental": true,
|
||||
"ip6tables": true,
|
||||
"fixed-cidr-v6": "fd05:d0ca:1::/64",
|
||||
"default-address-pools": [
|
||||
{
|
||||
"base": "172.19.0.0/16",
|
||||
"size": 24
|
||||
},
|
||||
{
|
||||
"base": "fd05:d0ca:2::/104",
|
||||
"size": 112
|
||||
}
|
||||
]
|
||||
}
|
||||
EOF
|
||||
apt --quiet install --yes -qq docker.io make
|
||||
|
||||
- name: install LXC
|
||||
run: |
|
||||
act/runner/lxc-helpers.sh lxc_prepare_environment
|
||||
act/runner/lxc-helpers.sh lxc_install_lxc_inside 10.39.28 fdb1
|
||||
|
||||
- run: apt-get -q install -qq -y gcc # required for `-race`
|
||||
|
||||
- run: make integration-test
|
||||
|
||||
validate-mocks:
|
||||
name: validate mocks
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: docker
|
||||
container:
|
||||
image: 'code.forgejo.org/oci/ci:1'
|
||||
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
|
||||
- uses: https://data.forgejo.org/actions/setup-go@v5
|
||||
with:
|
||||
go-version-file: go.mod
|
||||
|
||||
- name: generate mocks
|
||||
run: |
|
||||
set -ex
|
||||
make deps-tools
|
||||
make generate
|
||||
make fmt
|
||||
|
||||
- name: validate mocks
|
||||
run: |
|
||||
git diff --ignore-matching-lines='Code generated by mockery.*DO NOT EDIT' --quiet || {
|
||||
echo "[ERROR] Please apply the changes mockery suggests:"
|
||||
git diff --color=always
|
||||
exit 1
|
||||
}
|
||||
|
||||
validate-pre-commit:
|
||||
name: validate pre-commit-hooks file
|
||||
if: vars.ROLE == 'forgejo-coding'
|
||||
runs-on: docker
|
||||
container:
|
||||
image: 'code.forgejo.org/oci/ci:1'
|
||||
|
||||
steps:
|
||||
- uses: https://data.forgejo.org/actions/checkout@v4
|
||||
|
||||
- name: install pre-commit
|
||||
env:
|
||||
DEBIAN_FRONTEND: noninteractive
|
||||
PIP_ROOT_USER_ACTION: ignore
|
||||
PIP_BREAK_SYSTEM_PACKAGES: 1
|
||||
PIP_PROGRESS_BAR: off
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get -q install -qq -y python3-pip
|
||||
python3 -m pip install 'pre-commit>=3.2.0'
|
||||
|
||||
- name: validate .pre-commit-hooks.yaml
|
||||
run: pre-commit validate-manifest .pre-commit-hooks.yaml
|
||||
|
||||
# Will fail due to `act/runner/testdata/local-action-fails-schema-validation/action/action.yml`
|
||||
- name: check pre-commit hook against local action files (should fail)
|
||||
continue-on-error: true
|
||||
run: |
|
||||
pre-commit try-repo --all-files --verbose . forgejo-runner-validate
|
||||
|
||||
- name: check that a bad workflow file doesn’t validate (should fail)
|
||||
continue-on-error: true
|
||||
run: |
|
||||
mkdir -p test-repo
|
||||
cd test-repo
|
||||
git config set advice.defaultBranchName false
|
||||
git init --quiet
|
||||
mkdir -p .forgejo/workflows
|
||||
cp ../act/runner/testdata/local-action-fails-schema-validation/action/action.yml ./
|
||||
touch .forgejo/workflows/bad-workflow.yml
|
||||
cat > .pre-commit-config.yaml <<EOF
|
||||
repos:
|
||||
- repo: ..
|
||||
rev: ${{ forge.sha }}
|
||||
hooks:
|
||||
- id: forgejo-runner-validate
|
||||
EOF
|
||||
git add .
|
||||
pre-commit run --all-files --verbose forgejo-runner-validate
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@ linters:
|
|||
- staticcheck
|
||||
- unconvert
|
||||
- unused
|
||||
- usetesting
|
||||
- wastedassign
|
||||
settings:
|
||||
depguard:
|
||||
|
|
|
|||
|
|
@ -1,60 +0,0 @@
|
|||
version: 2
|
||||
|
||||
before:
|
||||
hooks:
|
||||
- go mod download
|
||||
|
||||
builds:
|
||||
- env:
|
||||
- CGO_ENABLED=0
|
||||
goos:
|
||||
- linux
|
||||
- darwin
|
||||
- windows
|
||||
goarch:
|
||||
- amd64
|
||||
- arm64
|
||||
|
||||
archives:
|
||||
- formats: [binary]
|
||||
# this name template makes the OS and Arch compatible with the results of `uname`.
|
||||
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 }}
|
||||
|
||||
changelog:
|
||||
abbrev: 10
|
||||
filters:
|
||||
exclude:
|
||||
- "^docs:"
|
||||
- "^test:"
|
||||
format: "{{.SHA}}: {{.Message}}"
|
||||
groups:
|
||||
- title: Features
|
||||
regexp: '^.*?feat(\([[:word:]]+\))??!?:.+$'
|
||||
order: 0
|
||||
- title: "Bug fixes"
|
||||
regexp: '^.*?fix(\([[:word:]]+\))??!?:.+$'
|
||||
order: 1
|
||||
- title: "Chores"
|
||||
regexp: '^.*?chore(\([[:word:]]+\))??!?:.+$'
|
||||
order: 2
|
||||
- title: Others
|
||||
order: 999
|
||||
sort: asc
|
||||
|
||||
release:
|
||||
gitea:
|
||||
owner: DevFW-CICD
|
||||
name: runner
|
||||
|
||||
force_token: gitea
|
||||
gitea_urls:
|
||||
api: https://edp.buildth.ing/api/v1
|
||||
download: https://edp.buildth.ing
|
||||
# set to true if you use a self-signed certificate
|
||||
skip_tls_verify: false
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
- id: forgejo-runner-validate
|
||||
name: Validate Forgejo Actions files
|
||||
description: This hook validates Forgejo Actions action and workflow files.
|
||||
language: golang
|
||||
entry: runner validate
|
||||
args: ['--directory', '.']
|
||||
pass_filenames: false
|
||||
files: (?:(?:^|/)action|^\.(?:forgejo|github|gitea)/workflows/[^/\n]+)\.ya?ml$
|
||||
types: [yaml]
|
||||
# 3.2.0 is when the pre-* `stages` used here were added.
|
||||
# Old names (without the pre- prefix) are deprecated since 4.0.0.
|
||||
minimum_pre_commit_version: '3.2.0'
|
||||
stages: [pre-commit, pre-merge-commit, pre-push, manual]
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
FROM --platform=$BUILDPLATFORM data.forgejo.org/oci/xx AS xx
|
||||
|
||||
FROM --platform=$BUILDPLATFORM data.forgejo.org/oci/golang:1.25-alpine3.22 AS build-env
|
||||
FROM --platform=$BUILDPLATFORM data.forgejo.org/oci/golang:1.24-alpine3.22 AS build-env
|
||||
|
||||
#
|
||||
# Transparently cross compile for the target platform
|
||||
|
|
@ -32,7 +32,7 @@ LABEL maintainer="contact@forgejo.org" \
|
|||
org.opencontainers.image.source="https://code.forgejo.org/forgejo/runner" \
|
||||
org.opencontainers.image.version="${RELEASE_VERSION}" \
|
||||
org.opencontainers.image.vendor="Forgejo" \
|
||||
org.opencontainers.image.licenses="GPL-3.0-or-later" \
|
||||
org.opencontainers.image.licenses="MIT" \
|
||||
org.opencontainers.image.title="Forgejo Runner" \
|
||||
org.opencontainers.image.description="A runner for Forgejo Actions."
|
||||
|
||||
|
|
|
|||
694
LICENSE
694
LICENSE
|
|
@ -1,674 +1,20 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users. We, the Free Software Foundation, use the
|
||||
GNU General Public License for most of our software; it applies also to
|
||||
any other work released this way by its authors. You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you have
|
||||
certain responsibilities if you distribute copies of the software, or if
|
||||
you modify it: responsibilities to respect the freedom of others.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the manufacturer
|
||||
can do so. This is fundamentally incompatible with the aim of
|
||||
protecting users' freedom to change the software. The systematic
|
||||
pattern of such abuse occurs in the area of products for individuals to
|
||||
use, which is precisely where it is most unacceptable. Therefore, we
|
||||
have designed this version of the GPL to prohibit the practice for those
|
||||
products. If such problems arise substantially in other domains, we
|
||||
stand ready to extend this provision to those domains in future versions
|
||||
of the GPL, as needed to protect the freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish to
|
||||
avoid the special danger that patents applied to a free program could
|
||||
make it effectively proprietary. To prevent this, the GPL assures that
|
||||
patents cannot be used to render the program non-free.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Use with the GNU Affero General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
||||
Copyright (c) 2023-2025 The Forgejo Authors
|
||||
Copyright (c) 2022 The Gitea Authors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
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 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.
|
||||
|
|
|
|||
21
Makefile
21
Makefile
|
|
@ -13,8 +13,8 @@ WINDOWS_ARCHS ?= windows/amd64
|
|||
GO_FMT_FILES := $(shell find . -type f -name "*.go" ! -name "generated.*")
|
||||
GOFILES := $(shell find . -type f -name "*.go" -o -name "go.mod" ! -name "generated.*")
|
||||
|
||||
MOCKERY_PACKAGE ?= github.com/vektra/mockery/v2@v2.53.5 # renovate: datasource=go
|
||||
GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.5.0 # renovate: datasource=go
|
||||
MOCKERY_PACKAGE ?= github.com/vektra/mockery/v2@v2.53.4 # renovate: datasource=go
|
||||
GOLANGCI_LINT_PACKAGE ?= github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.3.0 # renovate: datasource=go
|
||||
|
||||
DOCKER_IMAGE ?= gitea/act_runner
|
||||
DOCKER_TAG ?= nightly
|
||||
|
|
@ -62,18 +62,18 @@ else
|
|||
endif
|
||||
endif
|
||||
|
||||
GO_PACKAGES_TO_VET ?= $(filter-out code.forgejo.org/forgejo/runner/v11/internal/pkg/client/mocks code.forgejo.org/forgejo/runner/v11/act/artifactcache/mock_caches.go,$(shell $(GO) list ./...))
|
||||
GO_PACKAGES_TO_VET ?= $(filter-out code.forgejo.org/forgejo/runner/internal/pkg/client/mocks,$(shell $(GO) list ./...))
|
||||
|
||||
TAGS ?=
|
||||
LDFLAGS ?= -X "code.forgejo.org/forgejo/runner/v11/internal/pkg/ver.version=v$(RELEASE_VERSION)"
|
||||
LDFLAGS ?= -X "code.forgejo.org/forgejo/runner/internal/pkg/ver.version=v$(RELEASE_VERSION)"
|
||||
|
||||
all: build
|
||||
|
||||
.PHONY: lint-check
|
||||
.PHONY: lint
|
||||
lint-check:
|
||||
$(GO) run $(GOLANGCI_LINT_PACKAGE) run $(GOLANGCI_LINT_ARGS)
|
||||
|
||||
.PHONY: lint
|
||||
.PHONY: lint-fix
|
||||
lint:
|
||||
$(GO) run $(GOLANGCI_LINT_PACKAGE) run $(GOLANGCI_LINT_ARGS) --fix
|
||||
|
||||
|
|
@ -106,12 +106,7 @@ fmt-check:
|
|||
fi;
|
||||
|
||||
test: lint-check fmt-check
|
||||
$(GO) test -v -race -short -cover -coverprofile coverage.txt ./internal/...
|
||||
$(GO) test -race -short ./act/container
|
||||
$(GO) test -race ./act/artifactcache/... ./act/workflowpattern/... ./act/filecollector/... ./act/common/... ./act/jobparser ./act/model ./act/exprparser ./act/schema
|
||||
|
||||
integration-test:
|
||||
@$(GO) test -race -v ./internal/app/run/...
|
||||
@$(GO) test -v -cover -coverprofile coverage.txt ./internal/... && echo "\n==>\033[32m Ok\033[m\n" || exit 1
|
||||
|
||||
.PHONY: vet
|
||||
vet:
|
||||
|
|
@ -120,7 +115,7 @@ vet:
|
|||
|
||||
.PHONY: generate
|
||||
generate:
|
||||
$(GO) generate ./...
|
||||
$(GO) generate ./internal/...
|
||||
|
||||
install: $(GOFILES)
|
||||
$(GO) install -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)'
|
||||
|
|
|
|||
101
README.md
101
README.md
|
|
@ -1,15 +1,15 @@
|
|||
# Forgejo Runner
|
||||
|
||||
**WARNING:** this is [alpha release quality](https://en.wikipedia.org/wiki/Software_release_life_cycle#Alpha) code and should not be considered secure enough to deploy in production.
|
||||
|
||||
A daemon that connects to a Forgejo instance and runs jobs for continuous integration. The [installation and usage instructions](https://forgejo.org/docs/next/admin/actions/) are part of the Forgejo documentation.
|
||||
|
||||
# Reporting security-related issues
|
||||
# Reporting bugs
|
||||
|
||||
When filing a bug in [the issue tracker](https://code.forgejo.org/forgejo/runner/issues), it is very helpful to propose a pull request [in the end-to-end tests](https://code.forgejo.org/forgejo/end-to-end/src/branch/main/actions) repository that adds a reproducer. It will fail the CI and unambiguously demonstrate that the problem exists. In most cases it is enough to add a workflow ([see the echo example](https://code.forgejo.org/forgejo/end-to-end/src/branch/main/actions/example-echo)). For more complicated cases it is also possible to add a runner config file as well as shell scripts to setup and teardown the test case ([see the service example](https://code.forgejo.org/forgejo/end-to-end/src/branch/main/actions/example-service)).
|
||||
|
||||
Sensitive security-related issues should be reported to [security@forgejo.org](mailto:security@forgejo.org) using [encryption](https://keyoxide.org/security@forgejo.org).
|
||||
|
||||
## License
|
||||
|
||||
The Forgejo runner is distributed under the terms of the [GPL version 3.0](LICENSE) or any later version.
|
||||
|
||||
# Architectures & OS
|
||||
|
||||
The Forgejo runner is supported and tested on `amd64` and `arm64` ([binaries](https://code.forgejo.org/forgejo/runner/releases) and [containers](https://code.forgejo.org/forgejo/-/packages/container/runner/versions)) on Operating Systems based on the Linux kernel.
|
||||
|
|
@ -30,44 +30,77 @@ The Forgejo runner is a dependency of the [setup-forgejo action](https://code.fo
|
|||
- Install [Go](https://go.dev/doc/install) and `make(1)`
|
||||
- `make build`
|
||||
|
||||
## Linting
|
||||
The [test workflow](.forgejo/workflows/test.yml) is a full example that builds the binary, runs the tests and launches the runner binary against a live Forgejo instance.
|
||||
|
||||
- `make lint-check`
|
||||
- `make lint` # will fix some lint errors
|
||||
## Generate mocks
|
||||
|
||||
## Testing
|
||||
- `make deps-tools`
|
||||
- `make generate`
|
||||
|
||||
The [workflow](.forgejo/workflows/test.yml) that runs in the CI uses similar commands.
|
||||
If there are changes, commit them to the repository.
|
||||
|
||||
### Without a Forgejo instance
|
||||
## Local debug
|
||||
|
||||
- Install [Docker](https://docs.docker.com/engine/install/)
|
||||
- `make test integration-test`
|
||||
The repositories are checked out in the same directory:
|
||||
|
||||
The `TestRunner_RunEvent` test suite contains most integration tests
|
||||
with real-world workflows and is time-consuming to run. During
|
||||
development, it is helpful to run a specific test through a targeted
|
||||
command such as this:
|
||||
- **runner**: [Forgejo runner](https://code.forgejo.org/forgejo/runner)
|
||||
- **setup-forgejo**: [setup-forgejo](https://code.forgejo.org/actions/setup-forgejo)
|
||||
|
||||
- `go test -count=1 -run='TestRunner_RunEvent$/local-action-dockerfile$' ./act/runner`
|
||||
### Install dependencies
|
||||
|
||||
### With a Forgejo instance
|
||||
The dependencies are installed manually or with:
|
||||
|
||||
- Run a Forgejo instance locally (for instance at http://0.0.0.0:8080) and create as shared secret
|
||||
```sh
|
||||
export FORGEJO_RUNNER_SECRET='AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
|
||||
export FORGEJO_URL=http://0.0.0.0:8080
|
||||
forgejo forgejo-cli actions register --labels docker --name therunner --secret $FORGEJO_RUNNER_SECRET
|
||||
```shell
|
||||
setup-forgejo/forgejo-dependencies.sh
|
||||
```
|
||||
- `make test integration-test` # which will run addional tests because FORGEJO_URL is set
|
||||
|
||||
### end-to-end
|
||||
### Build the Forgejo runner
|
||||
|
||||
- Follow the instructions from the end-to-end tests to [run actions tests locally](https://code.forgejo.org/forgejo/end-to-end#running-from-locally-built-binary).
|
||||
- `./end-to-end.sh actions_teardown` # stop the Forgejo and runner daemons running in the end-to-end environment
|
||||
- `( cd ~/clone-of-the-runner-repo ; make build ; cp forgejo-runner /tmp/forgejo-end-to-end/forgejo-runner )` # install the runner built from sources
|
||||
- `./end-to-end.sh actions_setup 13.0` # start Forgejo v13.0 and the runner daemon in the end-to-end environment
|
||||
- `./end-to-end.sh actions_verify_example echo` # run the [echo workflow](https://code.forgejo.org/forgejo/end-to-end/src/branch/main/actions/example-echo/.forgejo/workflows/test.yml)
|
||||
- `xdg-open http://127.0.0.1:3000/root/example-echo/actions/runs/1` # see the logs workflow
|
||||
- `less /tmp/forgejo-end-to-end/forgejo-runner.log` # analyze the runner logs
|
||||
- `less /tmp/forgejo-end-to-end/forgejo-work-path/log/forgejo.log` # analyze the Forgejo logs
|
||||
```shell
|
||||
cd runner ; rm -f forgejo-runner ; make forgejo-runner
|
||||
```
|
||||
|
||||
### Launch Forgejo and the runner
|
||||
|
||||
A Forgejo instance is launched with:
|
||||
|
||||
```shell
|
||||
cd setup-forgejo
|
||||
./forgejo.sh setup
|
||||
firefox $(cat forgejo-url)
|
||||
```
|
||||
|
||||
The user is `root` with password `admin1234`. The runner is registered with:
|
||||
|
||||
```
|
||||
cd setup-forgejo
|
||||
docker exec --user 1000 forgejo forgejo actions generate-runner-token > forgejo-runner-token
|
||||
../runner/forgejo-runner register --no-interactive --instance "$(cat forgejo-url)" --name runner --token $(cat forgejo-runner-token) --labels docker:docker://node:22-bookworm,self-hosted:host,lxc:lxc://debian:bookworm
|
||||
```
|
||||
|
||||
And launched with:
|
||||
|
||||
```shell
|
||||
cd setup-forgejo ; ../runner/forgejo-runner --config runner-config.yml daemon
|
||||
```
|
||||
|
||||
Note that the `runner-config.yml` is required in that particular case
|
||||
to configure the network in `bridge` mode, otherwise the runner will
|
||||
create a network that cannot reach the forgejo instance.
|
||||
|
||||
### Try a sample workflow
|
||||
|
||||
From the Forgejo web interface, create a repository and add the
|
||||
following to `.forgejo/workflows/try.yaml`. It will launch the job and
|
||||
the result can be observed from the `actions` tab.
|
||||
|
||||
```yaml
|
||||
on: [push]
|
||||
jobs:
|
||||
ls:
|
||||
runs-on: docker
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- run: |
|
||||
ls ${{ github.workspace }}
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
# Release Notes
|
||||
|
||||
As of [Forgejo runner v9.0.0](https://code.forgejo.org/forgejo/runner/releases/tag/v9.0.0) the release notes are published in the release itself and this file will no longer be updated.
|
||||
## 9.0.0
|
||||
|
||||
* Breaking change: forgejo-runner exec --artifact-server-* options are deprecated. In order to test workflows using the artifact server, a local Forgejo instance can be used.
|
||||
|
||||
## 8.0.1
|
||||
|
||||
|
|
|
|||
|
|
@ -1,324 +0,0 @@
|
|||
package artifactcache
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/sirupsen/logrus"
|
||||
"github.com/timshannon/bolthold"
|
||||
"go.etcd.io/bbolt"
|
||||
)
|
||||
|
||||
//go:generate mockery --inpackage --name caches
|
||||
type caches interface {
|
||||
getDB() *bolthold.Store
|
||||
validateMac(rundata RunData) (string, error)
|
||||
readCache(id uint64, repo string) (*Cache, error)
|
||||
useCache(id uint64) error
|
||||
setgcAt(at time.Time)
|
||||
gcCache()
|
||||
close()
|
||||
|
||||
serve(w http.ResponseWriter, r *http.Request, id uint64)
|
||||
commit(id uint64, size int64) (int64, error)
|
||||
exist(id uint64) (bool, error)
|
||||
write(id, offset uint64, reader io.Reader) error
|
||||
}
|
||||
|
||||
type cachesImpl struct {
|
||||
dir string
|
||||
storage *Storage
|
||||
logger logrus.FieldLogger
|
||||
secret string
|
||||
|
||||
db *bolthold.Store
|
||||
|
||||
gcing atomic.Bool
|
||||
gcAt time.Time
|
||||
}
|
||||
|
||||
func newCaches(dir, secret string, logger logrus.FieldLogger) (caches, error) {
|
||||
c := &cachesImpl{
|
||||
secret: secret,
|
||||
}
|
||||
|
||||
c.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
|
||||
}
|
||||
|
||||
c.dir = dir
|
||||
|
||||
storage, err := NewStorage(filepath.Join(dir, "cache"))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c.storage = storage
|
||||
|
||||
file := filepath.Join(c.dir, "bolt.db")
|
||||
db, err := bolthold.Open(file, 0o644, &bolthold.Options{
|
||||
Encoder: json.Marshal,
|
||||
Decoder: json.Unmarshal,
|
||||
Options: &bbolt.Options{
|
||||
Timeout: 5 * time.Second,
|
||||
NoGrowSync: bbolt.DefaultOptions.NoGrowSync,
|
||||
FreelistType: bbolt.DefaultOptions.FreelistType,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Open(%s): %w", file, err)
|
||||
}
|
||||
c.db = db
|
||||
|
||||
c.gcCache()
|
||||
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (c *cachesImpl) close() {
|
||||
if c.db != nil {
|
||||
c.db.Close()
|
||||
c.db = nil
|
||||
}
|
||||
}
|
||||
|
||||
func (c *cachesImpl) getDB() *bolthold.Store {
|
||||
return c.db
|
||||
}
|
||||
|
||||
var findCacheWithIsolationKeyFallback = func(db *bolthold.Store, repo string, keys []string, version, writeIsolationKey string) (*Cache, error) {
|
||||
cache, err := findCache(db, repo, keys, version, writeIsolationKey)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// If read was scoped to WriteIsolationKey and didn't find anything, we can fallback to the non-isolated cache read
|
||||
if cache == nil && writeIsolationKey != "" {
|
||||
cache, err = findCache(db, repo, keys, version, "")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return cache, nil
|
||||
}
|
||||
|
||||
// if not found, return (nil, nil) instead of an error.
|
||||
func findCache(db *bolthold.Store, repo string, keys []string, version, writeIsolationKey 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("Repo").Eq(repo).Index("Repo").
|
||||
And("Key").Eq(prefix).
|
||||
And("Version").Eq(version).
|
||||
And("WriteIsolationKey").Eq(writeIsolationKey).
|
||||
And("Complete").Eq(true).
|
||||
SortBy("CreatedAt").Reverse()); err == nil || !errors.Is(err, bolthold.ErrNotFound) {
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("find cache entry equal to %s: %w", prefix, 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("Repo").Eq(repo).Index("Repo").
|
||||
And("Key").RegExp(re).
|
||||
And("Version").Eq(version).
|
||||
And("WriteIsolationKey").Eq(writeIsolationKey).
|
||||
And("Complete").Eq(true).
|
||||
SortBy("CreatedAt").Reverse()); err != nil {
|
||||
if errors.Is(err, bolthold.ErrNotFound) {
|
||||
continue
|
||||
}
|
||||
return nil, fmt.Errorf("find cache entry starting with %s: %w", prefix, 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 (c *cachesImpl) readCache(id uint64, repo string) (*Cache, error) {
|
||||
db := c.getDB()
|
||||
cache := &Cache{}
|
||||
if err := db.Get(id, cache); err != nil {
|
||||
return nil, fmt.Errorf("readCache: Get(%v): %w", id, err)
|
||||
}
|
||||
if cache.Repo != repo {
|
||||
return nil, fmt.Errorf("readCache: Get(%v): cache.Repo %s != repo %s", id, cache.Repo, repo)
|
||||
}
|
||||
|
||||
return cache, nil
|
||||
}
|
||||
|
||||
func (c *cachesImpl) useCache(id uint64) error {
|
||||
db := c.getDB()
|
||||
cache := &Cache{}
|
||||
if err := db.Get(id, cache); err != nil {
|
||||
return fmt.Errorf("useCache: Get(%v): %w", id, err)
|
||||
}
|
||||
cache.UsedAt = time.Now().Unix()
|
||||
if err := db.Update(cache.ID, cache); err != nil {
|
||||
return fmt.Errorf("useCache: Update(%v): %v", cache.ID, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *cachesImpl) serve(w http.ResponseWriter, r *http.Request, id uint64) {
|
||||
c.storage.Serve(w, r, id)
|
||||
}
|
||||
|
||||
func (c *cachesImpl) commit(id uint64, size int64) (int64, error) {
|
||||
return c.storage.Commit(id, size)
|
||||
}
|
||||
|
||||
func (c *cachesImpl) exist(id uint64) (bool, error) {
|
||||
return c.storage.Exist(id)
|
||||
}
|
||||
|
||||
func (c *cachesImpl) write(id, offset uint64, reader io.Reader) error {
|
||||
return c.storage.Write(id, offset, reader)
|
||||
}
|
||||
|
||||
const (
|
||||
keepUsed = 30 * 24 * time.Hour
|
||||
keepUnused = 7 * 24 * time.Hour
|
||||
keepTemp = 5 * time.Minute
|
||||
keepOld = 5 * time.Minute
|
||||
)
|
||||
|
||||
func (c *cachesImpl) setgcAt(at time.Time) {
|
||||
c.gcAt = at
|
||||
}
|
||||
|
||||
func (c *cachesImpl) gcCache() {
|
||||
if c.gcing.Load() {
|
||||
return
|
||||
}
|
||||
if !c.gcing.CompareAndSwap(false, true) {
|
||||
return
|
||||
}
|
||||
defer c.gcing.Store(false)
|
||||
|
||||
if time.Since(c.gcAt) < time.Hour {
|
||||
c.logger.Debugf("skip gc: %v", c.gcAt.String())
|
||||
return
|
||||
}
|
||||
c.gcAt = time.Now()
|
||||
c.logger.Debugf("gc: %v", c.gcAt.String())
|
||||
|
||||
db := c.getDB()
|
||||
|
||||
// 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 {
|
||||
fatal(c.logger, fmt.Errorf("gc caches not completed: %v", err))
|
||||
} else {
|
||||
for _, cache := range caches {
|
||||
c.storage.Remove(cache.ID)
|
||||
if err := db.Delete(cache.ID, cache); err != nil {
|
||||
c.logger.Errorf("delete cache: %v", err)
|
||||
continue
|
||||
}
|
||||
c.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 {
|
||||
fatal(c.logger, fmt.Errorf("gc caches old not used: %v", err))
|
||||
} else {
|
||||
for _, cache := range caches {
|
||||
c.storage.Remove(cache.ID)
|
||||
if err := db.Delete(cache.ID, cache); err != nil {
|
||||
c.logger.Warnf("delete cache: %v", err)
|
||||
continue
|
||||
}
|
||||
c.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 {
|
||||
fatal(c.logger, fmt.Errorf("gc caches too old: %v", err))
|
||||
} else {
|
||||
for _, cache := range caches {
|
||||
c.storage.Remove(cache.ID)
|
||||
if err := db.Delete(cache.ID, cache); err != nil {
|
||||
c.logger.Warnf("delete cache: %v", err)
|
||||
continue
|
||||
}
|
||||
c.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 {
|
||||
fatal(c.logger, fmt.Errorf("gc 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
|
||||
}
|
||||
c.storage.Remove(cache.ID)
|
||||
if err := db.Delete(cache.ID, cache); err != nil {
|
||||
c.logger.Warnf("delete cache: %v", err)
|
||||
continue
|
||||
}
|
||||
c.logger.Infof("deleted cache: %+v", cache)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
package artifactcache
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/sirupsen/logrus"
|
||||
"github.com/timshannon/bolthold"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestCacheReadWrite(t *testing.T) {
|
||||
caches, err := newCaches(t.TempDir(), "secret", logrus.New())
|
||||
require.NoError(t, err)
|
||||
defer caches.close()
|
||||
t.Run("NotFound", func(t *testing.T) {
|
||||
found, err := caches.readCache(456, "repo")
|
||||
assert.Nil(t, found)
|
||||
assert.ErrorIs(t, err, bolthold.ErrNotFound)
|
||||
})
|
||||
|
||||
repo := "repository"
|
||||
cache := &Cache{
|
||||
Repo: repo,
|
||||
Key: "key",
|
||||
Version: "version",
|
||||
Size: 444,
|
||||
}
|
||||
now := time.Now().Unix()
|
||||
cache.CreatedAt = now
|
||||
cache.UsedAt = now
|
||||
cache.Repo = repo
|
||||
|
||||
t.Run("Insert", func(t *testing.T) {
|
||||
db := caches.getDB()
|
||||
assert.NoError(t, insertCache(db, cache))
|
||||
})
|
||||
|
||||
t.Run("Found", func(t *testing.T) {
|
||||
found, err := caches.readCache(cache.ID, cache.Repo)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, cache.ID, found.ID)
|
||||
})
|
||||
|
||||
t.Run("InvalidRepo", func(t *testing.T) {
|
||||
invalidRepo := "INVALID REPO"
|
||||
found, err := caches.readCache(cache.ID, invalidRepo)
|
||||
assert.Nil(t, found)
|
||||
assert.ErrorContains(t, err, invalidRepo)
|
||||
})
|
||||
}
|
||||
|
|
@ -7,56 +7,46 @@ import (
|
|||
"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"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/cacheproxy"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
const (
|
||||
urlBase = "/_apis/artifactcache"
|
||||
)
|
||||
|
||||
var fatal = func(logger logrus.FieldLogger, err error) {
|
||||
logger.Errorf("unrecoverable error in the cache: %v", err)
|
||||
if err := suicide(); err != nil {
|
||||
logger.Errorf("unrecoverable error in the cache: failed to send the TERM signal to shutdown the daemon %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
type Handler interface {
|
||||
ExternalURL() string
|
||||
Close() error
|
||||
isClosed() bool
|
||||
getCaches() caches
|
||||
setCaches(caches caches)
|
||||
find(w http.ResponseWriter, r *http.Request, params httprouter.Params)
|
||||
reserve(w http.ResponseWriter, r *http.Request, params httprouter.Params)
|
||||
upload(w http.ResponseWriter, r *http.Request, params httprouter.Params)
|
||||
commit(w http.ResponseWriter, r *http.Request, params httprouter.Params)
|
||||
get(w http.ResponseWriter, r *http.Request, params httprouter.Params)
|
||||
clean(w http.ResponseWriter, r *http.Request, _ httprouter.Params)
|
||||
middleware(handler httprouter.Handle) httprouter.Handle
|
||||
responseJSON(w http.ResponseWriter, r *http.Request, code int, v ...any)
|
||||
}
|
||||
|
||||
type handler struct {
|
||||
caches caches
|
||||
type Handler struct {
|
||||
dir string
|
||||
storage *Storage
|
||||
router *httprouter.Router
|
||||
listener net.Listener
|
||||
server *http.Server
|
||||
logger logrus.FieldLogger
|
||||
secret string
|
||||
|
||||
gcing atomic.Bool
|
||||
gcAt time.Time
|
||||
|
||||
outboundIP string
|
||||
}
|
||||
|
||||
func StartHandler(dir, outboundIP string, port uint16, secret string, logger logrus.FieldLogger) (Handler, error) {
|
||||
h := &handler{}
|
||||
func StartHandler(dir, outboundIP string, port uint16, secret string, logger logrus.FieldLogger) (*Handler, error) {
|
||||
h := &Handler{
|
||||
secret: secret,
|
||||
}
|
||||
|
||||
if logger == nil {
|
||||
discard := logrus.New()
|
||||
|
|
@ -66,11 +56,24 @@ func StartHandler(dir, outboundIP string, port uint16, secret string, logger log
|
|||
logger = logger.WithField("module", "artifactcache")
|
||||
h.logger = logger
|
||||
|
||||
caches, err := newCaches(dir, secret, 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.caches = caches
|
||||
h.storage = storage
|
||||
|
||||
if outboundIP != "" {
|
||||
h.outboundIP = outboundIP
|
||||
|
|
@ -90,6 +93,8 @@ func StartHandler(dir, outboundIP string, port uint16, secret string, logger log
|
|||
|
||||
h.router = router
|
||||
|
||||
h.gcCache()
|
||||
|
||||
listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port)) // listen on all interfaces
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -109,22 +114,18 @@ func StartHandler(dir, outboundIP string, port uint16, secret string, logger log
|
|||
return h, nil
|
||||
}
|
||||
|
||||
func (h *handler) ExternalURL() string {
|
||||
func (h *Handler) ExternalURL() string {
|
||||
port := strconv.Itoa(h.listener.Addr().(*net.TCPAddr).Port)
|
||||
|
||||
// TODO: make the external url configurable if necessary
|
||||
return fmt.Sprintf("http://%s", net.JoinHostPort(h.outboundIP, port))
|
||||
}
|
||||
|
||||
func (h *handler) Close() error {
|
||||
func (h *Handler) Close() error {
|
||||
if h == nil {
|
||||
return nil
|
||||
}
|
||||
var retErr error
|
||||
if h.caches != nil {
|
||||
h.caches.close()
|
||||
h.caches = nil
|
||||
}
|
||||
if h.server != nil {
|
||||
err := h.server.Close()
|
||||
if err != nil {
|
||||
|
|
@ -145,25 +146,22 @@ func (h *handler) Close() error {
|
|||
return retErr
|
||||
}
|
||||
|
||||
func (h *handler) isClosed() bool {
|
||||
return h.listener == nil && h.server == nil
|
||||
}
|
||||
|
||||
func (h *handler) getCaches() caches {
|
||||
return h.caches
|
||||
}
|
||||
|
||||
func (h *handler) setCaches(caches caches) {
|
||||
if h.caches != nil {
|
||||
h.caches.close()
|
||||
}
|
||||
h.caches = caches
|
||||
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, params httprouter.Params) {
|
||||
func (h *Handler) find(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
rundata := runDataFromHeaders(r)
|
||||
repo, err := h.caches.validateMac(rundata)
|
||||
repo, err := h.validateMac(rundata)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 403, err)
|
||||
return
|
||||
|
|
@ -176,11 +174,16 @@ func (h *handler) find(w http.ResponseWriter, r *http.Request, params httprouter
|
|||
}
|
||||
version := r.URL.Query().Get("version")
|
||||
|
||||
db := h.caches.getDB()
|
||||
|
||||
cache, err := findCacheWithIsolationKeyFallback(db, repo, keys, version, rundata.WriteIsolationKey)
|
||||
db, err := h.openDB()
|
||||
if err != nil {
|
||||
h.responseFatalJSON(w, r, err)
|
||||
h.responseJSON(w, r, 500, err)
|
||||
return
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
cache, err := findCache(db, repo, keys, version)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 500, err)
|
||||
return
|
||||
}
|
||||
if cache == nil {
|
||||
|
|
@ -188,7 +191,7 @@ func (h *handler) find(w http.ResponseWriter, r *http.Request, params httprouter
|
|||
return
|
||||
}
|
||||
|
||||
if ok, err := h.caches.exist(cache.ID); err != nil {
|
||||
if ok, err := h.storage.Exist(cache.ID); err != nil {
|
||||
h.responseJSON(w, r, 500, err)
|
||||
return
|
||||
} else if !ok {
|
||||
|
|
@ -205,9 +208,9 @@ func (h *handler) find(w http.ResponseWriter, r *http.Request, params httprouter
|
|||
}
|
||||
|
||||
// POST /_apis/artifactcache/caches
|
||||
func (h *handler) reserve(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
func (h *Handler) reserve(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
rundata := runDataFromHeaders(r)
|
||||
repo, err := h.caches.validateMac(rundata)
|
||||
repo, err := h.validateMac(rundata)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 403, err)
|
||||
return
|
||||
|
|
@ -222,13 +225,17 @@ func (h *handler) reserve(w http.ResponseWriter, r *http.Request, params httprou
|
|||
api.Key = strings.ToLower(api.Key)
|
||||
|
||||
cache := api.ToCache()
|
||||
db := h.caches.getDB()
|
||||
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
|
||||
cache.Repo = repo
|
||||
cache.WriteIsolationKey = rundata.WriteIsolationKey
|
||||
if err := insertCache(db, cache); err != nil {
|
||||
h.responseJSON(w, r, 500, err)
|
||||
return
|
||||
|
|
@ -239,9 +246,9 @@ func (h *handler) reserve(w http.ResponseWriter, r *http.Request, params httprou
|
|||
}
|
||||
|
||||
// PATCH /_apis/artifactcache/caches/:id
|
||||
func (h *handler) upload(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
func (h *Handler) upload(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
rundata := runDataFromHeaders(r)
|
||||
repo, err := h.caches.validateMac(rundata)
|
||||
repo, err := h.validateMac(rundata)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 403, err)
|
||||
return
|
||||
|
|
@ -253,18 +260,19 @@ func (h *handler) upload(w http.ResponseWriter, r *http.Request, params httprout
|
|||
return
|
||||
}
|
||||
|
||||
cache, err := h.caches.readCache(id, repo)
|
||||
cache, err := h.readCache(id)
|
||||
if err != nil {
|
||||
if errors.Is(err, bolthold.ErrNotFound) {
|
||||
h.responseJSON(w, r, 404, fmt.Errorf("cache %d: not reserved", id))
|
||||
return
|
||||
}
|
||||
h.responseFatalJSON(w, r, fmt.Errorf("cache Get: %w", err))
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache Get: %w", err))
|
||||
return
|
||||
}
|
||||
|
||||
if cache.WriteIsolationKey != rundata.WriteIsolationKey {
|
||||
h.responseJSON(w, r, 403, fmt.Errorf("cache authorized for write isolation %q, but attempting to operate on %q", rundata.WriteIsolationKey, cache.WriteIsolationKey))
|
||||
// Should not happen
|
||||
if cache.Repo != repo {
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache repo is not valid"))
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -277,11 +285,11 @@ func (h *handler) upload(w http.ResponseWriter, r *http.Request, params httprout
|
|||
h.responseJSON(w, r, 400, fmt.Errorf("cache parseContentRange(%s): %w", r.Header.Get("Content-Range"), err))
|
||||
return
|
||||
}
|
||||
if err := h.caches.write(cache.ID, start, r.Body); err != nil {
|
||||
if err := h.storage.Write(cache.ID, start, r.Body); err != nil {
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache storage.Write: %w", err))
|
||||
return
|
||||
}
|
||||
if err := h.caches.useCache(id); err != nil {
|
||||
if err := h.useCache(id); err != nil {
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache useCache: %w", err))
|
||||
return
|
||||
}
|
||||
|
|
@ -289,9 +297,9 @@ func (h *handler) upload(w http.ResponseWriter, r *http.Request, params httprout
|
|||
}
|
||||
|
||||
// POST /_apis/artifactcache/caches/:id
|
||||
func (h *handler) commit(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
func (h *Handler) commit(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
rundata := runDataFromHeaders(r)
|
||||
repo, err := h.caches.validateMac(rundata)
|
||||
repo, err := h.validateMac(rundata)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 403, err)
|
||||
return
|
||||
|
|
@ -303,18 +311,19 @@ func (h *handler) commit(w http.ResponseWriter, r *http.Request, params httprout
|
|||
return
|
||||
}
|
||||
|
||||
cache, err := h.caches.readCache(id, repo)
|
||||
cache, err := h.readCache(id)
|
||||
if err != nil {
|
||||
if errors.Is(err, bolthold.ErrNotFound) {
|
||||
h.responseJSON(w, r, 404, fmt.Errorf("cache %d: not reserved", id))
|
||||
return
|
||||
}
|
||||
h.responseFatalJSON(w, r, fmt.Errorf("cache Get: %w", err))
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache Get: %w", err))
|
||||
return
|
||||
}
|
||||
|
||||
if cache.WriteIsolationKey != rundata.WriteIsolationKey {
|
||||
h.responseJSON(w, r, 403, fmt.Errorf("cache authorized for write isolation %q, but attempting to operate on %q", rundata.WriteIsolationKey, cache.WriteIsolationKey))
|
||||
// Should not happen
|
||||
if cache.Repo != repo {
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache repo is not valid"))
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -323,15 +332,20 @@ func (h *handler) commit(w http.ResponseWriter, r *http.Request, params httprout
|
|||
return
|
||||
}
|
||||
|
||||
size, err := h.caches.commit(cache.ID, cache.Size)
|
||||
size, err := h.storage.Commit(cache.ID, cache.Size)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("commit(%v): %w", cache.ID, err))
|
||||
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 := h.caches.getDB()
|
||||
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 {
|
||||
|
|
@ -343,9 +357,9 @@ func (h *handler) commit(w http.ResponseWriter, r *http.Request, params httprout
|
|||
}
|
||||
|
||||
// GET /_apis/artifactcache/artifacts/:id
|
||||
func (h *handler) get(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
func (h *Handler) get(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
|
||||
rundata := runDataFromHeaders(r)
|
||||
repo, err := h.caches.validateMac(rundata)
|
||||
repo, err := h.validateMac(rundata)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 403, err)
|
||||
return
|
||||
|
|
@ -357,33 +371,33 @@ func (h *handler) get(w http.ResponseWriter, r *http.Request, params httprouter.
|
|||
return
|
||||
}
|
||||
|
||||
cache, err := h.caches.readCache(id, repo)
|
||||
cache, err := h.readCache(id)
|
||||
if err != nil {
|
||||
if errors.Is(err, bolthold.ErrNotFound) {
|
||||
h.responseJSON(w, r, 404, fmt.Errorf("cache %d: not reserved", id))
|
||||
return
|
||||
}
|
||||
h.responseFatalJSON(w, r, fmt.Errorf("cache Get: %w", err))
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache Get: %w", err))
|
||||
return
|
||||
}
|
||||
|
||||
// reads permitted against caches w/ the same isolation key, or no isolation key
|
||||
if cache.WriteIsolationKey != rundata.WriteIsolationKey && cache.WriteIsolationKey != "" {
|
||||
h.responseJSON(w, r, 403, fmt.Errorf("cache authorized for write isolation %q, but attempting to operate on %q", rundata.WriteIsolationKey, cache.WriteIsolationKey))
|
||||
// Should not happen
|
||||
if cache.Repo != repo {
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache repo is not valid"))
|
||||
return
|
||||
}
|
||||
|
||||
if err := h.caches.useCache(id); err != nil {
|
||||
if err := h.useCache(id); err != nil {
|
||||
h.responseJSON(w, r, 500, fmt.Errorf("cache useCache: %w", err))
|
||||
return
|
||||
}
|
||||
h.caches.serve(w, r, id)
|
||||
h.storage.Serve(w, r, id)
|
||||
}
|
||||
|
||||
// POST /_apis/artifactcache/clean
|
||||
func (h *handler) clean(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
|
||||
func (h *Handler) clean(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
|
||||
rundata := runDataFromHeaders(r)
|
||||
_, err := h.caches.validateMac(rundata)
|
||||
_, err := h.validateMac(rundata)
|
||||
if err != nil {
|
||||
h.responseJSON(w, r, 403, err)
|
||||
return
|
||||
|
|
@ -394,20 +408,204 @@ func (h *handler) clean(w http.ResponseWriter, r *http.Request, _ httprouter.Par
|
|||
h.responseJSON(w, r, 200)
|
||||
}
|
||||
|
||||
func (h *handler) middleware(handler httprouter.Handle) httprouter.Handle {
|
||||
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.caches.gcCache()
|
||||
go h.gcCache()
|
||||
}
|
||||
}
|
||||
|
||||
func (h *handler) responseFatalJSON(w http.ResponseWriter, r *http.Request, err error) {
|
||||
h.responseJSON(w, r, 500, err)
|
||||
fatal(h.logger, err)
|
||||
// if not found, return (nil, nil) instead of an error.
|
||||
func findCache(db *bolthold.Store, repo string, 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("Repo").Eq(repo).
|
||||
And("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("Repo").Eq(repo).
|
||||
And("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 (h *handler) responseJSON(w http.ResponseWriter, r *http.Request, code int, v ...any) {
|
||||
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) readCache(id uint64) (*Cache, error) {
|
||||
db, err := h.openDB()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer db.Close()
|
||||
cache := &Cache{}
|
||||
if err := db.Get(id, cache); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return cache, nil
|
||||
}
|
||||
|
||||
func (h *Handler) useCache(id uint64) error {
|
||||
db, err := h.openDB()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer db.Close()
|
||||
cache := &Cache{}
|
||||
if err := db.Get(id, cache); err != nil {
|
||||
return err
|
||||
}
|
||||
cache.UsedAt = time.Now().Unix()
|
||||
return 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 {
|
||||
|
|
@ -440,20 +638,11 @@ func parseContentRange(s string) (uint64, uint64, error) {
|
|||
return start, stop, nil
|
||||
}
|
||||
|
||||
type RunData struct {
|
||||
RepositoryFullName string
|
||||
RunNumber string
|
||||
Timestamp string
|
||||
RepositoryMAC string
|
||||
WriteIsolationKey string
|
||||
}
|
||||
|
||||
func runDataFromHeaders(r *http.Request) RunData {
|
||||
return RunData{
|
||||
func runDataFromHeaders(r *http.Request) cacheproxy.RunData {
|
||||
return cacheproxy.RunData{
|
||||
RepositoryFullName: r.Header.Get("Forgejo-Cache-Repo"),
|
||||
RunNumber: r.Header.Get("Forgejo-Cache-RunNumber"),
|
||||
Timestamp: r.Header.Get("Forgejo-Cache-Timestamp"),
|
||||
RepositoryMAC: r.Header.Get("Forgejo-Cache-MAC"),
|
||||
WriteIsolationKey: r.Header.Get("Forgejo-Cache-WriteIsolationKey"),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,71 +4,48 @@ import (
|
|||
"bytes"
|
||||
"crypto/rand"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"syscall"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/testutils"
|
||||
"github.com/julienschmidt/httprouter"
|
||||
"github.com/sirupsen/logrus"
|
||||
"github.com/stretchr/testify/mock"
|
||||
"github.com/timshannon/bolthold"
|
||||
"go.etcd.io/bbolt"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"github.com/timshannon/bolthold"
|
||||
"go.etcd.io/bbolt"
|
||||
)
|
||||
|
||||
const (
|
||||
cacheRepo = "testuser/repo"
|
||||
cacheRunnum = "1"
|
||||
cacheTimestamp = "0"
|
||||
cacheMac = "bc2e9167f9e310baebcead390937264e4c0b21d2fdd49f5b9470d54406099360"
|
||||
cacheMac = "c13854dd1ac599d1d61680cd93c26b77ba0ee10f374a3408bcaea82f38ca1865"
|
||||
)
|
||||
|
||||
var handlerExternalURL string
|
||||
|
||||
type AuthHeaderTransport struct {
|
||||
T http.RoundTripper
|
||||
WriteIsolationKey string
|
||||
OverrideDefaultMac string
|
||||
T http.RoundTripper
|
||||
}
|
||||
|
||||
func (t *AuthHeaderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
|
||||
req.Header.Set("Forgejo-Cache-Repo", cacheRepo)
|
||||
req.Header.Set("Forgejo-Cache-RunNumber", cacheRunnum)
|
||||
req.Header.Set("Forgejo-Cache-Timestamp", cacheTimestamp)
|
||||
if t.OverrideDefaultMac != "" {
|
||||
req.Header.Set("Forgejo-Cache-MAC", t.OverrideDefaultMac)
|
||||
} else {
|
||||
req.Header.Set("Forgejo-Cache-MAC", cacheMac)
|
||||
}
|
||||
req.Header.Set("Forgejo-Cache-MAC", cacheMac)
|
||||
req.Header.Set("Forgejo-Cache-Host", handlerExternalURL)
|
||||
if t.WriteIsolationKey != "" {
|
||||
req.Header.Set("Forgejo-Cache-WriteIsolationKey", t.WriteIsolationKey)
|
||||
}
|
||||
return t.T.RoundTrip(req)
|
||||
}
|
||||
|
||||
var (
|
||||
httpClientTransport = AuthHeaderTransport{T: http.DefaultTransport}
|
||||
httpClientTransport = AuthHeaderTransport{http.DefaultTransport}
|
||||
httpClient = http.Client{Transport: &httpClientTransport}
|
||||
)
|
||||
|
||||
func TestHandler(t *testing.T) {
|
||||
defer testutils.MockVariable(&fatal, func(_ logrus.FieldLogger, err error) {
|
||||
t.Fatalf("unexpected call to fatal(%v)", err)
|
||||
})()
|
||||
|
||||
dir := filepath.Join(t.TempDir(), "artifactcache")
|
||||
handler, err := StartHandler(dir, "", 0, "secret", nil)
|
||||
require.NoError(t, err)
|
||||
|
|
@ -77,8 +54,10 @@ func TestHandler(t *testing.T) {
|
|||
base := fmt.Sprintf("%s%s", handler.ExternalURL(), urlBase)
|
||||
|
||||
defer func() {
|
||||
t.Run("inspect db", func(t *testing.T) {
|
||||
db := handler.getCaches().getDB()
|
||||
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)
|
||||
|
|
@ -88,7 +67,8 @@ func TestHandler(t *testing.T) {
|
|||
})
|
||||
t.Run("close", func(t *testing.T) {
|
||||
require.NoError(t, handler.Close())
|
||||
assert.True(t, handler.isClosed())
|
||||
assert.Nil(t, handler.server)
|
||||
assert.Nil(t, handler.listener)
|
||||
_, err := httpClient.Post(fmt.Sprintf("%s/caches/%d", base, 1), "", nil)
|
||||
assert.Error(t, err)
|
||||
})
|
||||
|
|
@ -108,7 +88,7 @@ func TestHandler(t *testing.T) {
|
|||
content := make([]byte, 100)
|
||||
_, err := rand.Read(content)
|
||||
require.NoError(t, err)
|
||||
uploadCacheNormally(t, base, key, version, "", content)
|
||||
uploadCacheNormally(t, base, key, version, content)
|
||||
})
|
||||
|
||||
t.Run("clean", func(t *testing.T) {
|
||||
|
|
@ -400,7 +380,7 @@ func TestHandler(t *testing.T) {
|
|||
_, err := rand.Read(content)
|
||||
require.NoError(t, err)
|
||||
|
||||
uploadCacheNormally(t, base, key, version, "", content)
|
||||
uploadCacheNormally(t, base, key, version, content)
|
||||
|
||||
// Perform the request with the custom `httpClient` which will send correct MAC data
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
|
||||
|
|
@ -436,7 +416,7 @@ func TestHandler(t *testing.T) {
|
|||
for i := range contents {
|
||||
_, err := rand.Read(contents[i])
|
||||
require.NoError(t, err)
|
||||
uploadCacheNormally(t, base, keys[i], version, "", contents[i])
|
||||
uploadCacheNormally(t, base, keys[i], version, contents[i])
|
||||
time.Sleep(time.Second) // ensure CreatedAt of caches are different
|
||||
}
|
||||
|
||||
|
|
@ -474,98 +454,13 @@ func TestHandler(t *testing.T) {
|
|||
assert.Equal(t, contents[except], content)
|
||||
})
|
||||
|
||||
t.Run("find can't match without WriteIsolationKey match", func(t *testing.T) {
|
||||
defer func() { httpClientTransport.WriteIsolationKey = "" }()
|
||||
|
||||
version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
|
||||
key := strings.ToLower(t.Name())
|
||||
|
||||
uploadCacheNormally(t, base, key, version, "TestWriteKey", make([]byte, 64))
|
||||
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("AnotherTestWriteKey")()
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 204, resp.StatusCode)
|
||||
}()
|
||||
|
||||
{
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 204, resp.StatusCode)
|
||||
}
|
||||
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("TestWriteKey")()
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 200, resp.StatusCode)
|
||||
}()
|
||||
})
|
||||
|
||||
t.Run("find prefers WriteIsolationKey match", func(t *testing.T) {
|
||||
version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d21"
|
||||
key := strings.ToLower(t.Name())
|
||||
|
||||
// Between two values with the same `key`...
|
||||
uploadCacheNormally(t, base, key, version, "TestWriteKey", make([]byte, 64))
|
||||
uploadCacheNormally(t, base, key, version, "", make([]byte, 128))
|
||||
|
||||
// We should read the value with the matching WriteIsolationKey from the cache...
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("TestWriteKey")()
|
||||
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 200, resp.StatusCode)
|
||||
|
||||
got := struct {
|
||||
ArchiveLocation string `json:"archiveLocation"`
|
||||
}{}
|
||||
require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
|
||||
contentResp, err := httpClient.Get(got.ArchiveLocation)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 200, contentResp.StatusCode)
|
||||
content, err := io.ReadAll(contentResp.Body)
|
||||
require.NoError(t, err)
|
||||
// Which we finally check matches the correct WriteIsolationKey's content here.
|
||||
assert.Equal(t, make([]byte, 64), content)
|
||||
}()
|
||||
})
|
||||
|
||||
t.Run("find falls back if matching WriteIsolationKey not available", func(t *testing.T) {
|
||||
version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d21"
|
||||
key := strings.ToLower(t.Name())
|
||||
|
||||
uploadCacheNormally(t, base, key, version, "", make([]byte, 128))
|
||||
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("TestWriteKey")()
|
||||
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 200, resp.StatusCode)
|
||||
|
||||
got := struct {
|
||||
ArchiveLocation string `json:"archiveLocation"`
|
||||
}{}
|
||||
require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
|
||||
contentResp, err := httpClient.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, make([]byte, 128), 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)
|
||||
uploadCacheNormally(t, base, key+"_ABC", version, content)
|
||||
|
||||
{
|
||||
reqKey := key + "_aBc"
|
||||
|
|
@ -599,7 +494,7 @@ func TestHandler(t *testing.T) {
|
|||
for i := range contents {
|
||||
_, err := rand.Read(contents[i])
|
||||
require.NoError(t, err)
|
||||
uploadCacheNormally(t, base, keys[i], version, "", contents[i])
|
||||
uploadCacheNormally(t, base, keys[i], version, contents[i])
|
||||
time.Sleep(time.Second) // ensure CreatedAt of caches are different
|
||||
}
|
||||
|
||||
|
|
@ -650,7 +545,7 @@ func TestHandler(t *testing.T) {
|
|||
for i := range contents {
|
||||
_, err := rand.Read(contents[i])
|
||||
require.NoError(t, err)
|
||||
uploadCacheNormally(t, base, keys[i], version, "", contents[i])
|
||||
uploadCacheNormally(t, base, keys[i], version, contents[i])
|
||||
time.Sleep(time.Second) // ensure CreatedAt of caches are different
|
||||
}
|
||||
|
||||
|
|
@ -686,166 +581,9 @@ func TestHandler(t *testing.T) {
|
|||
require.NoError(t, err)
|
||||
assert.Equal(t, contents[expect], content)
|
||||
})
|
||||
|
||||
t.Run("upload across WriteIsolationKey", func(t *testing.T) {
|
||||
defer overrideWriteIsolationKey("CorrectKey")()
|
||||
|
||||
key := strings.ToLower(t.Name())
|
||||
version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
|
||||
content := make([]byte, 256)
|
||||
|
||||
var id uint64
|
||||
// reserve
|
||||
{
|
||||
body, err := json.Marshal(&Request{
|
||||
Key: key,
|
||||
Version: version,
|
||||
Size: int64(len(content)),
|
||||
})
|
||||
require.NoError(t, err)
|
||||
resp, err := httpClient.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
|
||||
}
|
||||
// upload, but with the incorrect write isolation key relative to the cache obj created
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("WrongKey")()
|
||||
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 := httpClient.Do(req)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, 403, resp.StatusCode)
|
||||
}()
|
||||
})
|
||||
|
||||
t.Run("commit across WriteIsolationKey", func(t *testing.T) {
|
||||
defer overrideWriteIsolationKey("CorrectKey")()
|
||||
|
||||
key := strings.ToLower(t.Name())
|
||||
version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d20"
|
||||
content := make([]byte, 256)
|
||||
|
||||
var id uint64
|
||||
// reserve
|
||||
{
|
||||
body, err := json.Marshal(&Request{
|
||||
Key: key,
|
||||
Version: version,
|
||||
Size: int64(len(content)),
|
||||
})
|
||||
require.NoError(t, err)
|
||||
resp, err := httpClient.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
|
||||
}
|
||||
// upload
|
||||
{
|
||||
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 := httpClient.Do(req)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, 200, resp.StatusCode)
|
||||
}
|
||||
// commit, but with the incorrect write isolation key relative to the cache obj created
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("WrongKey")()
|
||||
resp, err := httpClient.Post(fmt.Sprintf("%s/caches/%d", base, id), "", nil)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, 403, resp.StatusCode)
|
||||
}()
|
||||
})
|
||||
|
||||
t.Run("get across WriteIsolationKey", func(t *testing.T) {
|
||||
defer func() { httpClientTransport.WriteIsolationKey = "" }()
|
||||
|
||||
version := "c19da02a2bd7e77277f1ac29ab45c09b7d46a4ee758284e26bb3045ad11d9d21"
|
||||
key := strings.ToLower(t.Name())
|
||||
uploadCacheNormally(t, base, key, version, "", make([]byte, 128))
|
||||
keyIsolated := strings.ToLower(t.Name()) + "_isolated"
|
||||
uploadCacheNormally(t, base, keyIsolated, version, "CorrectKey", make([]byte, 128))
|
||||
|
||||
// Perform the 'get' without the right WriteIsolationKey for the cache entry... should be OK for `key` since it
|
||||
// was written with WriteIsolationKey "" meaning it is available for non-isolated access
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("WhoopsWrongKey")()
|
||||
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, key, version))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 200, resp.StatusCode)
|
||||
got := struct {
|
||||
ArchiveLocation string `json:"archiveLocation"`
|
||||
}{}
|
||||
require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
|
||||
|
||||
contentResp, err := httpClient.Get(got.ArchiveLocation)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 200, contentResp.StatusCode)
|
||||
httpClientTransport.WriteIsolationKey = "CorrectKey" // reset for next find
|
||||
}()
|
||||
|
||||
// Perform the 'get' without the right WriteIsolationKey for the cache entry... should be 403 for `keyIsolated`
|
||||
// because it was written with a different WriteIsolationKey.
|
||||
{
|
||||
got := func() struct {
|
||||
ArchiveLocation string `json:"archiveLocation"`
|
||||
} {
|
||||
defer overrideWriteIsolationKey("CorrectKey")() // for test purposes make the `find` successful...
|
||||
resp, err := httpClient.Get(fmt.Sprintf("%s/cache?keys=%s&version=%s", base, keyIsolated, version))
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 200, resp.StatusCode)
|
||||
got := struct {
|
||||
ArchiveLocation string `json:"archiveLocation"`
|
||||
}{}
|
||||
require.NoError(t, json.NewDecoder(resp.Body).Decode(&got))
|
||||
return got
|
||||
}()
|
||||
|
||||
func() {
|
||||
defer overrideWriteIsolationKey("WhoopsWrongKey")() // but then access w/ the wrong key for `get`
|
||||
contentResp, err := httpClient.Get(got.ArchiveLocation)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, 403, contentResp.StatusCode)
|
||||
}()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func overrideWriteIsolationKey(writeIsolationKey string) func() {
|
||||
originalWriteIsolationKey := httpClientTransport.WriteIsolationKey
|
||||
originalMac := httpClientTransport.OverrideDefaultMac
|
||||
|
||||
httpClientTransport.WriteIsolationKey = writeIsolationKey
|
||||
httpClientTransport.OverrideDefaultMac = ComputeMac("secret", cacheRepo, cacheRunnum, cacheTimestamp, httpClientTransport.WriteIsolationKey)
|
||||
|
||||
return func() {
|
||||
httpClientTransport.WriteIsolationKey = originalWriteIsolationKey
|
||||
httpClientTransport.OverrideDefaultMac = originalMac
|
||||
}
|
||||
}
|
||||
|
||||
func uploadCacheNormally(t *testing.T, base, key, version, writeIsolationKey string, content []byte) {
|
||||
if writeIsolationKey != "" {
|
||||
defer overrideWriteIsolationKey(writeIsolationKey)()
|
||||
}
|
||||
|
||||
func uploadCacheNormally(t *testing.T, base, key, version string, content []byte) {
|
||||
var id uint64
|
||||
{
|
||||
body, err := json.Marshal(&Request{
|
||||
|
|
@ -904,130 +642,6 @@ func uploadCacheNormally(t *testing.T, base, key, version, writeIsolationKey str
|
|||
}
|
||||
}
|
||||
|
||||
func TestHandlerAPIFatalErrors(t *testing.T) {
|
||||
for _, testCase := range []struct {
|
||||
name string
|
||||
prepare func(message string) func()
|
||||
caches func(t *testing.T, message string) caches
|
||||
call func(t *testing.T, handler Handler, w http.ResponseWriter)
|
||||
}{
|
||||
{
|
||||
name: "find",
|
||||
prepare: func(message string) func() {
|
||||
return testutils.MockVariable(&findCacheWithIsolationKeyFallback, func(db *bolthold.Store, repo string, keys []string, version, writeIsolationKey string) (*Cache, error) {
|
||||
return nil, errors.New(message)
|
||||
})
|
||||
},
|
||||
caches: func(t *testing.T, message string) caches {
|
||||
caches, err := newCaches(t.TempDir(), "secret", logrus.New())
|
||||
require.NoError(t, err)
|
||||
return caches
|
||||
},
|
||||
call: func(t *testing.T, handler Handler, w http.ResponseWriter) {
|
||||
keyOne := "ONE"
|
||||
req, err := http.NewRequest("GET", fmt.Sprintf("http://example.com/cache?keys=%s", keyOne), nil)
|
||||
require.NoError(t, err)
|
||||
req.Header.Set("Forgejo-Cache-Repo", cacheRepo)
|
||||
req.Header.Set("Forgejo-Cache-RunNumber", cacheRunnum)
|
||||
req.Header.Set("Forgejo-Cache-Timestamp", cacheTimestamp)
|
||||
req.Header.Set("Forgejo-Cache-MAC", cacheMac)
|
||||
req.Header.Set("Forgejo-Cache-Host", "http://example.com")
|
||||
handler.find(w, req, nil)
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "upload",
|
||||
caches: func(t *testing.T, message string) caches {
|
||||
caches := newMockCaches(t)
|
||||
caches.On("close").Return()
|
||||
caches.On("validateMac", RunData{}).Return(cacheRepo, nil)
|
||||
caches.On("readCache", mock.Anything, mock.Anything).Return(nil, errors.New(message))
|
||||
return caches
|
||||
},
|
||||
call: func(t *testing.T, handler Handler, w http.ResponseWriter) {
|
||||
id := 1234
|
||||
req, err := http.NewRequest("PATCH", fmt.Sprintf("http://example.com/caches/%d", id), nil)
|
||||
require.NoError(t, err)
|
||||
handler.upload(w, req, httprouter.Params{
|
||||
httprouter.Param{Key: "id", Value: fmt.Sprintf("%d", id)},
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "commit",
|
||||
caches: func(t *testing.T, message string) caches {
|
||||
caches := newMockCaches(t)
|
||||
caches.On("close").Return()
|
||||
caches.On("validateMac", RunData{}).Return(cacheRepo, nil)
|
||||
caches.On("readCache", mock.Anything, mock.Anything).Return(nil, errors.New(message))
|
||||
return caches
|
||||
},
|
||||
call: func(t *testing.T, handler Handler, w http.ResponseWriter) {
|
||||
id := 1234
|
||||
req, err := http.NewRequest("POST", fmt.Sprintf("http://example.com/caches/%d", id), nil)
|
||||
require.NoError(t, err)
|
||||
handler.commit(w, req, httprouter.Params{
|
||||
httprouter.Param{Key: "id", Value: fmt.Sprintf("%d", id)},
|
||||
})
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "get",
|
||||
caches: func(t *testing.T, message string) caches {
|
||||
caches := newMockCaches(t)
|
||||
caches.On("close").Return()
|
||||
caches.On("validateMac", RunData{}).Return(cacheRepo, nil)
|
||||
caches.On("readCache", mock.Anything, mock.Anything).Return(nil, errors.New(message))
|
||||
return caches
|
||||
},
|
||||
call: func(t *testing.T, handler Handler, w http.ResponseWriter) {
|
||||
id := 1234
|
||||
req, err := http.NewRequest("GET", fmt.Sprintf("http://example.com/artifacts/%d", id), nil)
|
||||
require.NoError(t, err)
|
||||
handler.get(w, req, httprouter.Params{
|
||||
httprouter.Param{Key: "id", Value: fmt.Sprintf("%d", id)},
|
||||
})
|
||||
},
|
||||
},
|
||||
// it currently is a noop
|
||||
//{
|
||||
//name: "clean",
|
||||
//}
|
||||
} {
|
||||
t.Run(testCase.name, func(t *testing.T) {
|
||||
message := "ERROR MESSAGE"
|
||||
if testCase.prepare != nil {
|
||||
defer testCase.prepare(message)()
|
||||
}
|
||||
|
||||
fatalMessage := "<unset>"
|
||||
defer testutils.MockVariable(&fatal, func(_ logrus.FieldLogger, err error) {
|
||||
fatalMessage = err.Error()
|
||||
})()
|
||||
|
||||
assertFatalMessage := func(t *testing.T, expected string) {
|
||||
t.Helper()
|
||||
assert.Contains(t, fatalMessage, expected)
|
||||
}
|
||||
|
||||
dir := filepath.Join(t.TempDir(), "artifactcache")
|
||||
handler, err := StartHandler(dir, "", 0, "secret", nil)
|
||||
require.NoError(t, err)
|
||||
defer handler.Close()
|
||||
|
||||
fatalMessage = "<unset>"
|
||||
|
||||
caches := testCase.caches(t, message) // doesn't need to be closed because it will be given to handler
|
||||
handler.setCaches(caches)
|
||||
|
||||
w := httptest.NewRecorder()
|
||||
testCase.call(t, handler, w)
|
||||
require.Equal(t, 500, w.Code)
|
||||
assertFatalMessage(t, message)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandler_gcCache(t *testing.T) {
|
||||
dir := filepath.Join(t.TempDir(), "artifactcache")
|
||||
handler, err := StartHandler(dir, "", 0, "", nil)
|
||||
|
|
@ -1111,15 +725,18 @@ func TestHandler_gcCache(t *testing.T) {
|
|||
},
|
||||
}
|
||||
|
||||
db := handler.getCaches().getDB()
|
||||
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.getCaches().setgcAt(time.Time{}) // ensure gcCache will not skip
|
||||
handler.getCaches().gcCache()
|
||||
handler.gcAt = time.Time{} // ensure gcCache will not skip
|
||||
handler.gcCache()
|
||||
|
||||
db = handler.getCaches().getDB()
|
||||
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{}
|
||||
|
|
@ -1131,6 +748,7 @@ func TestHandler_gcCache(t *testing.T) {
|
|||
}
|
||||
})
|
||||
}
|
||||
require.NoError(t, db.Close())
|
||||
}
|
||||
|
||||
func TestHandler_ExternalURL(t *testing.T) {
|
||||
|
|
@ -1141,7 +759,8 @@ func TestHandler_ExternalURL(t *testing.T) {
|
|||
|
||||
assert.Equal(t, handler.ExternalURL(), "http://127.0.0.1:34567")
|
||||
require.NoError(t, handler.Close())
|
||||
assert.True(t, handler.isClosed())
|
||||
assert.Nil(t, handler.server)
|
||||
assert.Nil(t, handler.listener)
|
||||
})
|
||||
|
||||
t.Run("reports correct URL on IPv6 zero host", func(t *testing.T) {
|
||||
|
|
@ -1151,7 +770,8 @@ func TestHandler_ExternalURL(t *testing.T) {
|
|||
|
||||
assert.Equal(t, handler.ExternalURL(), "http://[2001:db8::]:34567")
|
||||
require.NoError(t, handler.Close())
|
||||
assert.True(t, handler.isClosed())
|
||||
assert.Nil(t, handler.server)
|
||||
assert.Nil(t, handler.listener)
|
||||
})
|
||||
|
||||
t.Run("reports correct URL on IPv6", func(t *testing.T) {
|
||||
|
|
@ -1161,45 +781,7 @@ func TestHandler_ExternalURL(t *testing.T) {
|
|||
|
||||
assert.Equal(t, handler.ExternalURL(), "http://[2001:db8::1:2:3:4]:34567")
|
||||
require.NoError(t, handler.Close())
|
||||
assert.True(t, handler.isClosed())
|
||||
assert.Nil(t, handler.server)
|
||||
assert.Nil(t, handler.listener)
|
||||
})
|
||||
}
|
||||
|
||||
var (
|
||||
settleTime = 100 * time.Millisecond
|
||||
fatalWaitingTime = 30 * time.Second
|
||||
)
|
||||
|
||||
func waitSig(t *testing.T, c <-chan os.Signal, sig os.Signal) {
|
||||
t.Helper()
|
||||
|
||||
// Sleep multiple times to give the kernel more tries to
|
||||
// deliver the signal.
|
||||
start := time.Now()
|
||||
timer := time.NewTimer(settleTime / 10)
|
||||
defer timer.Stop()
|
||||
for time.Since(start) < fatalWaitingTime {
|
||||
select {
|
||||
case s := <-c:
|
||||
if s == sig {
|
||||
return
|
||||
}
|
||||
t.Fatalf("signal was %v, want %v", s, sig)
|
||||
case <-timer.C:
|
||||
timer.Reset(settleTime / 10)
|
||||
}
|
||||
}
|
||||
t.Fatalf("timeout after %v waiting for %v", fatalWaitingTime, sig)
|
||||
}
|
||||
|
||||
func TestHandler_fatal(t *testing.T) {
|
||||
c := make(chan os.Signal, 1)
|
||||
signal.Notify(c, syscall.SIGTERM)
|
||||
defer signal.Stop(c)
|
||||
|
||||
discard := logrus.New()
|
||||
discard.Out = io.Discard
|
||||
fatal(discard, errors.New("fatal error"))
|
||||
|
||||
waitSig(t, c, syscall.SIGTERM)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,17 +10,19 @@ import (
|
|||
"errors"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/act/cacheproxy"
|
||||
)
|
||||
|
||||
var ErrValidation = errors.New("validation error")
|
||||
|
||||
func (c *cachesImpl) validateMac(rundata RunData) (string, error) {
|
||||
func (h *Handler) validateMac(rundata cacheproxy.RunData) (string, error) {
|
||||
// TODO: allow configurable max age
|
||||
if !validateAge(rundata.Timestamp) {
|
||||
return "", ErrValidation
|
||||
}
|
||||
|
||||
expectedMAC := ComputeMac(c.secret, rundata.RepositoryFullName, rundata.RunNumber, rundata.Timestamp, rundata.WriteIsolationKey)
|
||||
expectedMAC := computeMac(h.secret, rundata.RepositoryFullName, rundata.RunNumber, rundata.Timestamp)
|
||||
if hmac.Equal([]byte(expectedMAC), []byte(rundata.RepositoryMAC)) {
|
||||
return rundata.RepositoryFullName, nil
|
||||
}
|
||||
|
|
@ -38,14 +40,12 @@ func validateAge(ts string) bool {
|
|||
return true
|
||||
}
|
||||
|
||||
func ComputeMac(secret, repo, run, ts, writeIsolationKey string) string {
|
||||
func computeMac(secret, repo, run, ts string) string {
|
||||
mac := hmac.New(sha256.New, []byte(secret))
|
||||
mac.Write([]byte(repo))
|
||||
mac.Write([]byte(">"))
|
||||
mac.Write([]byte(run))
|
||||
mac.Write([]byte(">"))
|
||||
mac.Write([]byte(ts))
|
||||
mac.Write([]byte(">"))
|
||||
mac.Write([]byte(writeIsolationKey))
|
||||
return hex.EncodeToString(mac.Sum(nil))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,11 +5,12 @@ import (
|
|||
"testing"
|
||||
"time"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/act/cacheproxy"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestMac(t *testing.T) {
|
||||
cache := &cachesImpl{
|
||||
handler := &Handler{
|
||||
secret: "secret for testing",
|
||||
}
|
||||
|
||||
|
|
@ -18,15 +19,15 @@ func TestMac(t *testing.T) {
|
|||
run := "1"
|
||||
ts := strconv.FormatInt(time.Now().Unix(), 10)
|
||||
|
||||
mac := ComputeMac(cache.secret, name, run, ts, "")
|
||||
rundata := RunData{
|
||||
mac := computeMac(handler.secret, name, run, ts)
|
||||
rundata := cacheproxy.RunData{
|
||||
RepositoryFullName: name,
|
||||
RunNumber: run,
|
||||
Timestamp: ts,
|
||||
RepositoryMAC: mac,
|
||||
}
|
||||
|
||||
repoName, err := cache.validateMac(rundata)
|
||||
repoName, err := handler.validateMac(rundata)
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, name, repoName)
|
||||
})
|
||||
|
|
@ -36,15 +37,15 @@ func TestMac(t *testing.T) {
|
|||
run := "1"
|
||||
ts := "9223372036854775807" // This should last us for a while...
|
||||
|
||||
mac := ComputeMac(cache.secret, name, run, ts, "")
|
||||
rundata := RunData{
|
||||
mac := computeMac(handler.secret, name, run, ts)
|
||||
rundata := cacheproxy.RunData{
|
||||
RepositoryFullName: name,
|
||||
RunNumber: run,
|
||||
Timestamp: ts,
|
||||
RepositoryMAC: mac,
|
||||
}
|
||||
|
||||
_, err := cache.validateMac(rundata)
|
||||
_, err := handler.validateMac(rundata)
|
||||
require.Error(t, err)
|
||||
})
|
||||
|
||||
|
|
@ -53,14 +54,14 @@ func TestMac(t *testing.T) {
|
|||
run := "1"
|
||||
ts := strconv.FormatInt(time.Now().Unix(), 10)
|
||||
|
||||
rundata := RunData{
|
||||
rundata := cacheproxy.RunData{
|
||||
RepositoryFullName: name,
|
||||
RunNumber: run,
|
||||
Timestamp: ts,
|
||||
RepositoryMAC: "this is not the right mac :D",
|
||||
}
|
||||
|
||||
repoName, err := cache.validateMac(rundata)
|
||||
repoName, err := handler.validateMac(rundata)
|
||||
require.Error(t, err)
|
||||
require.Equal(t, "", repoName)
|
||||
})
|
||||
|
|
@ -71,12 +72,9 @@ func TestMac(t *testing.T) {
|
|||
run := "42"
|
||||
ts := "1337"
|
||||
|
||||
mac := ComputeMac(secret, name, run, ts, "")
|
||||
expectedMac := "4754474b21329e8beadd2b4054aa4be803965d66e710fa1fee091334ed804f29" // * Precomputed, anytime the ComputeMac function changes this needs to be recalculated
|
||||
require.Equal(t, expectedMac, mac)
|
||||
mac := computeMac(secret, name, run, ts)
|
||||
expectedMac := "f666f06f917acb7186e152195b2a8c8d36d068ce683454be0878806e08e04f2b" // * Precomputed, anytime the computeMac function changes this needs to be recalculated
|
||||
|
||||
mac = ComputeMac(secret, name, run, ts, "refs/pull/12/head")
|
||||
expectedMac = "9ca8f4cb5e1b083ee8cd215215bc00f379b28511d3ef7930bf054767de34766d" // * Precomputed, anytime the ComputeMac function changes this needs to be recalculated
|
||||
require.Equal(t, expectedMac, mac)
|
||||
require.Equal(t, mac, expectedMac)
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,225 +0,0 @@
|
|||
// Code generated by mockery v2.53.5. DO NOT EDIT.
|
||||
|
||||
package artifactcache
|
||||
|
||||
import (
|
||||
http "net/http"
|
||||
|
||||
bolthold "github.com/timshannon/bolthold"
|
||||
|
||||
io "io"
|
||||
|
||||
mock "github.com/stretchr/testify/mock"
|
||||
|
||||
time "time"
|
||||
)
|
||||
|
||||
// mockCaches is an autogenerated mock type for the caches type
|
||||
type mockCaches struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
// close provides a mock function with no fields
|
||||
func (_m *mockCaches) close() {
|
||||
_m.Called()
|
||||
}
|
||||
|
||||
// commit provides a mock function with given fields: id, size
|
||||
func (_m *mockCaches) commit(id uint64, size int64) (int64, error) {
|
||||
ret := _m.Called(id, size)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for commit")
|
||||
}
|
||||
|
||||
var r0 int64
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(uint64, int64) (int64, error)); ok {
|
||||
return rf(id, size)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(uint64, int64) int64); ok {
|
||||
r0 = rf(id, size)
|
||||
} else {
|
||||
r0 = ret.Get(0).(int64)
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(uint64, int64) error); ok {
|
||||
r1 = rf(id, size)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// exist provides a mock function with given fields: id
|
||||
func (_m *mockCaches) exist(id uint64) (bool, error) {
|
||||
ret := _m.Called(id)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for exist")
|
||||
}
|
||||
|
||||
var r0 bool
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(uint64) (bool, error)); ok {
|
||||
return rf(id)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(uint64) bool); ok {
|
||||
r0 = rf(id)
|
||||
} else {
|
||||
r0 = ret.Get(0).(bool)
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(uint64) error); ok {
|
||||
r1 = rf(id)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// gcCache provides a mock function with no fields
|
||||
func (_m *mockCaches) gcCache() {
|
||||
_m.Called()
|
||||
}
|
||||
|
||||
// getDB provides a mock function with no fields
|
||||
func (_m *mockCaches) getDB() *bolthold.Store {
|
||||
ret := _m.Called()
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for getDB")
|
||||
}
|
||||
|
||||
var r0 *bolthold.Store
|
||||
if rf, ok := ret.Get(0).(func() *bolthold.Store); ok {
|
||||
r0 = rf()
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*bolthold.Store)
|
||||
}
|
||||
}
|
||||
|
||||
return r0
|
||||
}
|
||||
|
||||
// readCache provides a mock function with given fields: id, repo
|
||||
func (_m *mockCaches) readCache(id uint64, repo string) (*Cache, error) {
|
||||
ret := _m.Called(id, repo)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for readCache")
|
||||
}
|
||||
|
||||
var r0 *Cache
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(uint64, string) (*Cache, error)); ok {
|
||||
return rf(id, repo)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(uint64, string) *Cache); ok {
|
||||
r0 = rf(id, repo)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*Cache)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(uint64, string) error); ok {
|
||||
r1 = rf(id, repo)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// serve provides a mock function with given fields: w, r, id
|
||||
func (_m *mockCaches) serve(w http.ResponseWriter, r *http.Request, id uint64) {
|
||||
_m.Called(w, r, id)
|
||||
}
|
||||
|
||||
// setgcAt provides a mock function with given fields: at
|
||||
func (_m *mockCaches) setgcAt(at time.Time) {
|
||||
_m.Called(at)
|
||||
}
|
||||
|
||||
// useCache provides a mock function with given fields: id
|
||||
func (_m *mockCaches) useCache(id uint64) error {
|
||||
ret := _m.Called(id)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for useCache")
|
||||
}
|
||||
|
||||
var r0 error
|
||||
if rf, ok := ret.Get(0).(func(uint64) error); ok {
|
||||
r0 = rf(id)
|
||||
} else {
|
||||
r0 = ret.Error(0)
|
||||
}
|
||||
|
||||
return r0
|
||||
}
|
||||
|
||||
// validateMac provides a mock function with given fields: rundata
|
||||
func (_m *mockCaches) validateMac(rundata RunData) (string, error) {
|
||||
ret := _m.Called(rundata)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for validateMac")
|
||||
}
|
||||
|
||||
var r0 string
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(RunData) (string, error)); ok {
|
||||
return rf(rundata)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(RunData) string); ok {
|
||||
r0 = rf(rundata)
|
||||
} else {
|
||||
r0 = ret.Get(0).(string)
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(RunData) error); ok {
|
||||
r1 = rf(rundata)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// write provides a mock function with given fields: id, offset, reader
|
||||
func (_m *mockCaches) write(id uint64, offset uint64, reader io.Reader) error {
|
||||
ret := _m.Called(id, offset, reader)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for write")
|
||||
}
|
||||
|
||||
var r0 error
|
||||
if rf, ok := ret.Get(0).(func(uint64, uint64, io.Reader) error); ok {
|
||||
r0 = rf(id, offset, reader)
|
||||
} else {
|
||||
r0 = ret.Error(0)
|
||||
}
|
||||
|
||||
return r0
|
||||
}
|
||||
|
||||
// newMockCaches creates a new instance of mockCaches. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
||||
// The first argument is typically a *testing.T value.
|
||||
func newMockCaches(t interface {
|
||||
mock.TestingT
|
||||
Cleanup(func())
|
||||
},
|
||||
) *mockCaches {
|
||||
mock := &mockCaches{}
|
||||
mock.Mock.Test(t)
|
||||
|
||||
t.Cleanup(func() { mock.AssertExpectations(t) })
|
||||
|
||||
return mock
|
||||
}
|
||||
|
|
@ -24,13 +24,12 @@ func (c *Request) ToCache() *Cache {
|
|||
}
|
||||
|
||||
type Cache struct {
|
||||
ID uint64 `json:"id" boltholdKey:"ID"`
|
||||
Repo string `json:"repo" boltholdIndex:"Repo"`
|
||||
Key string `json:"key"`
|
||||
Version string `json:"version"`
|
||||
Size int64 `json:"cacheSize"`
|
||||
Complete bool `json:"complete"`
|
||||
UsedAt int64 `json:"usedAt"`
|
||||
CreatedAt int64 `json:"createdAt"`
|
||||
WriteIsolationKey string `json:"writeIsolationKey"`
|
||||
ID uint64 `json:"id" boltholdKey:"ID"`
|
||||
Repo string `json:"repo" boltholdIndex:"Repo"`
|
||||
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"`
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +0,0 @@
|
|||
//go:build !windows
|
||||
|
||||
package artifactcache
|
||||
|
||||
import "syscall"
|
||||
|
||||
func suicide() error {
|
||||
return syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
//go:build windows
|
||||
|
||||
package artifactcache
|
||||
|
||||
import "syscall"
|
||||
|
||||
func suicide() error {
|
||||
handle, err := syscall.GetCurrentProcess()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return syscall.TerminateProcess(handle, uint32(syscall.SIGTERM))
|
||||
}
|
||||
|
|
@ -4,6 +4,9 @@
|
|||
package cacheproxy
|
||||
|
||||
import (
|
||||
"crypto/hmac"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
|
|
@ -19,8 +22,7 @@ import (
|
|||
"github.com/julienschmidt/httprouter"
|
||||
"github.com/sirupsen/logrus"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/artifactcache"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
const (
|
||||
|
|
@ -37,26 +39,31 @@ type Handler struct {
|
|||
|
||||
outboundIP string
|
||||
|
||||
cacheServerHost string
|
||||
cacheProxyHostOverride string
|
||||
cacheServerHost string
|
||||
|
||||
cacheSecret string
|
||||
|
||||
runs sync.Map
|
||||
}
|
||||
|
||||
func (h *Handler) CreateRunData(fullName, runNumber, timestamp, writeIsolationKey string) artifactcache.RunData {
|
||||
mac := artifactcache.ComputeMac(h.cacheSecret, fullName, runNumber, timestamp, writeIsolationKey)
|
||||
return artifactcache.RunData{
|
||||
type RunData struct {
|
||||
RepositoryFullName string
|
||||
RunNumber string
|
||||
Timestamp string
|
||||
RepositoryMAC string
|
||||
}
|
||||
|
||||
func (h *Handler) CreateRunData(fullName, runNumber, timestamp string) RunData {
|
||||
mac := computeMac(h.cacheSecret, fullName, runNumber, timestamp)
|
||||
return RunData{
|
||||
RepositoryFullName: fullName,
|
||||
RunNumber: runNumber,
|
||||
Timestamp: timestamp,
|
||||
RepositoryMAC: mac,
|
||||
WriteIsolationKey: writeIsolationKey,
|
||||
}
|
||||
}
|
||||
|
||||
func StartHandler(targetHost, outboundIP string, port uint16, cacheProxyHostOverride, cacheSecret string, logger logrus.FieldLogger) (*Handler, error) {
|
||||
func StartHandler(targetHost, outboundIP string, port uint16, cacheSecret string, logger logrus.FieldLogger) (*Handler, error) {
|
||||
h := &Handler{}
|
||||
|
||||
if logger == nil {
|
||||
|
|
@ -64,7 +71,7 @@ func StartHandler(targetHost, outboundIP string, port uint16, cacheProxyHostOver
|
|||
discard.Out = io.Discard
|
||||
logger = discard
|
||||
}
|
||||
logger = logger.WithField("module", "cacheproxy")
|
||||
logger = logger.WithField("module", "artifactcache")
|
||||
h.logger = logger
|
||||
|
||||
h.cacheSecret = cacheSecret
|
||||
|
|
@ -78,11 +85,10 @@ func StartHandler(targetHost, outboundIP string, port uint16, cacheProxyHostOver
|
|||
}
|
||||
|
||||
h.cacheServerHost = targetHost
|
||||
h.cacheProxyHostOverride = cacheProxyHostOverride
|
||||
|
||||
proxy, err := h.newReverseProxy(targetHost)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unable to set up proxy to target host: %v", err)
|
||||
return nil, fmt.Errorf("unable to set up proxy to target host")
|
||||
}
|
||||
|
||||
router := httprouter.New()
|
||||
|
|
@ -134,12 +140,11 @@ func (h *Handler) newReverseProxy(targetHost string) (*httputil.ReverseProxy, er
|
|||
h.logger.Warn(fmt.Sprintf("Tried starting a cache proxy with id %s, which does not exist.", id))
|
||||
return
|
||||
}
|
||||
runData := data.(artifactcache.RunData)
|
||||
runData := data.(RunData)
|
||||
uri := matches[2]
|
||||
|
||||
r.SetURL(targetURL)
|
||||
r.Out.URL.Path = uri
|
||||
h.logger.Debugf("proxy req %s %q to %q", r.In.Method, r.In.URL, r.Out.URL)
|
||||
|
||||
r.Out.Header.Set("Forgejo-Cache-Repo", runData.RepositoryFullName)
|
||||
r.Out.Header.Set("Forgejo-Cache-RunNumber", runData.RunNumber)
|
||||
|
|
@ -147,31 +152,26 @@ func (h *Handler) newReverseProxy(targetHost string) (*httputil.ReverseProxy, er
|
|||
r.Out.Header.Set("Forgejo-Cache-Timestamp", runData.Timestamp)
|
||||
r.Out.Header.Set("Forgejo-Cache-MAC", runData.RepositoryMAC)
|
||||
r.Out.Header.Set("Forgejo-Cache-Host", h.ExternalURL())
|
||||
if runData.WriteIsolationKey != "" {
|
||||
r.Out.Header.Set("Forgejo-Cache-WriteIsolationKey", runData.WriteIsolationKey)
|
||||
}
|
||||
},
|
||||
ModifyResponse: func(r *http.Response) error {
|
||||
h.logger.Debugf("proxy resp %s w/ %d bytes", r.Status, r.ContentLength)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
return proxy, nil
|
||||
}
|
||||
|
||||
func (h *Handler) ExternalURL() string {
|
||||
if h.cacheProxyHostOverride != "" {
|
||||
return h.cacheProxyHostOverride
|
||||
}
|
||||
// TODO: make the external url configurable if necessary
|
||||
return fmt.Sprintf("http://%s", net.JoinHostPort(h.outboundIP, strconv.Itoa(h.listener.Addr().(*net.TCPAddr).Port)))
|
||||
}
|
||||
|
||||
// Informs the proxy of a workflow run that can make cache requests.
|
||||
// The RunData contains the information about the repository.
|
||||
// The function returns the 32-bit random key which the run will use to identify itself.
|
||||
func (h *Handler) AddRun(data artifactcache.RunData) (string, error) {
|
||||
for range 3 {
|
||||
key := common.MustRandName(4)
|
||||
func (h *Handler) AddRun(data RunData) (string, error) {
|
||||
for retries := 0; retries < 3; retries++ {
|
||||
key, err := common.RandName(4)
|
||||
if err != nil {
|
||||
return "", errors.New("Could not generate the run id")
|
||||
}
|
||||
|
||||
_, loaded := h.runs.LoadOrStore(key, data)
|
||||
if !loaded {
|
||||
// The key was unique and added successfully
|
||||
|
|
@ -210,3 +210,13 @@ func (h *Handler) Close() error {
|
|||
}
|
||||
return retErr
|
||||
}
|
||||
|
||||
func computeMac(secret, repo, run, ts string) string {
|
||||
mac := hmac.New(sha256.New, []byte(secret))
|
||||
mac.Write([]byte(repo))
|
||||
mac.Write([]byte(">"))
|
||||
mac.Write([]byte(run))
|
||||
mac.Write([]byte(">"))
|
||||
mac.Write([]byte(ts))
|
||||
return hex.EncodeToString(mac.Sum(nil))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
package common
|
||||
|
||||
// CartesianProduct takes map of lists and returns list of unique tuples
|
||||
func CartesianProduct(mapOfLists map[string][]any) []map[string]any {
|
||||
func CartesianProduct(mapOfLists map[string][]interface{}) []map[string]interface{} {
|
||||
listNames := make([]string, 0)
|
||||
lists := make([][]any, 0)
|
||||
lists := make([][]interface{}, 0)
|
||||
for k, v := range mapOfLists {
|
||||
listNames = append(listNames, k)
|
||||
lists = append(lists, v)
|
||||
|
|
@ -11,9 +11,9 @@ func CartesianProduct(mapOfLists map[string][]any) []map[string]any {
|
|||
|
||||
listCart := cartN(lists...)
|
||||
|
||||
rtn := make([]map[string]any, 0)
|
||||
rtn := make([]map[string]interface{}, 0)
|
||||
for _, list := range listCart {
|
||||
vMap := make(map[string]any)
|
||||
vMap := make(map[string]interface{})
|
||||
for i, v := range list {
|
||||
vMap[listNames[i]] = v
|
||||
}
|
||||
|
|
@ -22,7 +22,7 @@ func CartesianProduct(mapOfLists map[string][]any) []map[string]any {
|
|||
return rtn
|
||||
}
|
||||
|
||||
func cartN(a ...[]any) [][]any {
|
||||
func cartN(a ...[]interface{}) [][]interface{} {
|
||||
c := 1
|
||||
for _, a := range a {
|
||||
c *= len(a)
|
||||
|
|
@ -30,8 +30,8 @@ func cartN(a ...[]any) [][]any {
|
|||
if c == 0 || len(a) == 0 {
|
||||
return nil
|
||||
}
|
||||
p := make([][]any, c)
|
||||
b := make([]any, c*len(a))
|
||||
p := make([][]interface{}, c)
|
||||
b := make([]interface{}, c*len(a))
|
||||
n := make([]int, len(a))
|
||||
s := 0
|
||||
for i := range p {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ import (
|
|||
|
||||
func TestCartesianProduct(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
input := map[string][]any{
|
||||
input := map[string][]interface{}{
|
||||
"foo": {1, 2, 3, 4},
|
||||
"bar": {"a", "b", "c"},
|
||||
"baz": {false, true},
|
||||
|
|
@ -25,7 +25,7 @@ func TestCartesianProduct(t *testing.T) {
|
|||
assert.Contains(v, "baz")
|
||||
}
|
||||
|
||||
input = map[string][]any{
|
||||
input = map[string][]interface{}{
|
||||
"foo": {1, 2, 3, 4},
|
||||
"bar": {},
|
||||
"baz": {false, true},
|
||||
|
|
@ -33,7 +33,7 @@ func TestCartesianProduct(t *testing.T) {
|
|||
output = CartesianProduct(input)
|
||||
assert.Len(output, 0)
|
||||
|
||||
input = map[string][]any{}
|
||||
input = map[string][]interface{}{}
|
||||
output = CartesianProduct(input)
|
||||
assert.Len(output, 0)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -127,8 +127,11 @@ func (p *Pen) DrawBoxes(labels ...string) *Drawing {
|
|||
|
||||
// Draw to writer
|
||||
func (d *Drawing) Draw(writer io.Writer, centerOnWidth int) {
|
||||
padSize := max((centerOnWidth-d.GetWidth())/2, 0)
|
||||
for l := range strings.SplitSeq(d.buf.String(), "\n") {
|
||||
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)
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ func (w Warning) Error() string {
|
|||
}
|
||||
|
||||
// Warningf create a warning
|
||||
func Warningf(format string, args ...any) Warning {
|
||||
func Warningf(format string, args ...interface{}) Warning {
|
||||
w := Warning{
|
||||
Message: fmt.Sprintf(format, args...),
|
||||
}
|
||||
|
|
@ -32,7 +32,7 @@ type Executor func(ctx context.Context) error
|
|||
type Conditional func(ctx context.Context) bool
|
||||
|
||||
// NewInfoExecutor is an executor that logs messages
|
||||
func NewInfoExecutor(format string, args ...any) Executor {
|
||||
func NewInfoExecutor(format string, args ...interface{}) Executor {
|
||||
return func(ctx context.Context) error {
|
||||
logger := Logger(ctx)
|
||||
logger.Infof(format, args...)
|
||||
|
|
@ -41,7 +41,7 @@ func NewInfoExecutor(format string, args ...any) Executor {
|
|||
}
|
||||
|
||||
// NewDebugExecutor is an executor that logs messages
|
||||
func NewDebugExecutor(format string, args ...any) Executor {
|
||||
func NewDebugExecutor(format string, args ...interface{}) Executor {
|
||||
return func(ctx context.Context) error {
|
||||
logger := Logger(ctx)
|
||||
logger.Debugf(format, args...)
|
||||
|
|
@ -109,14 +109,14 @@ func NewParallelExecutor(parallel int, executors ...Executor) Executor {
|
|||
}(work, errs)
|
||||
}
|
||||
|
||||
for i := range executors {
|
||||
for i := 0; i < len(executors); i++ {
|
||||
work <- executors[i]
|
||||
}
|
||||
close(work)
|
||||
|
||||
// Executor waits all executors to cleanup these resources.
|
||||
var firstErr error
|
||||
for range executors {
|
||||
for i := 0; i < len(executors); i++ {
|
||||
err := <-errs
|
||||
if firstErr == nil {
|
||||
firstErr = err
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@ package common
|
|||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
|
|
@ -13,7 +12,7 @@ import (
|
|||
func TestNewWorkflow(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
// empty
|
||||
emptyWorkflow := NewPipelineExecutor()
|
||||
|
|
@ -41,7 +40,7 @@ func TestNewWorkflow(t *testing.T) {
|
|||
func TestNewConditionalExecutor(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
trueCount := 0
|
||||
falseCount := 0
|
||||
|
|
@ -78,50 +77,39 @@ func TestNewConditionalExecutor(t *testing.T) {
|
|||
func TestNewParallelExecutor(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
ctx := t.Context()
|
||||
|
||||
var count atomic.Int32
|
||||
var activeCount atomic.Int32
|
||||
var maxCount atomic.Int32
|
||||
ctx := context.Background()
|
||||
|
||||
count := 0
|
||||
activeCount := 0
|
||||
maxCount := 0
|
||||
emptyWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
|
||||
count.Add(1)
|
||||
count++
|
||||
|
||||
currentActive := activeCount.Add(1)
|
||||
|
||||
// maxCount = max(maxCount, currentActive) -- but concurrent-safe by using CompareAndSwap.
|
||||
for {
|
||||
currentMax := maxCount.Load()
|
||||
if currentActive <= currentMax {
|
||||
break
|
||||
}
|
||||
if maxCount.CompareAndSwap(currentMax, currentActive) {
|
||||
break
|
||||
}
|
||||
// If CompareAndSwap failed, retry due to concurrent update by another goroutine.
|
||||
activeCount++
|
||||
if activeCount > maxCount {
|
||||
maxCount = activeCount
|
||||
}
|
||||
|
||||
time.Sleep(2 * time.Second)
|
||||
activeCount.Add(-1)
|
||||
activeCount--
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
err := NewParallelExecutor(2, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
|
||||
|
||||
assert.Equal(int32(3), count.Load(), "should run all 3 executors")
|
||||
assert.Equal(int32(2), maxCount.Load(), "should run at most 2 executors in parallel")
|
||||
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.Store(0)
|
||||
activeCount.Store(0)
|
||||
maxCount.Store(0)
|
||||
count = 0
|
||||
activeCount = 0
|
||||
maxCount = 0
|
||||
|
||||
errSingle := NewParallelExecutor(0, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
|
||||
|
||||
assert.Equal(int32(3), count.Load(), "should run all 3 executors")
|
||||
assert.Equal(int32(1), maxCount.Load(), "should run at most 1 executors in parallel")
|
||||
assert.Equal(3, count, "should run all 3 executors")
|
||||
assert.Equal(1, maxCount, "should run at most 1 executors in parallel")
|
||||
assert.Nil(errSingle)
|
||||
}
|
||||
|
||||
|
|
@ -131,13 +119,13 @@ func TestNewParallelExecutorFailed(t *testing.T) {
|
|||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
|
||||
var count atomic.Int32
|
||||
count := 0
|
||||
errorWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
|
||||
count.Add(1)
|
||||
count++
|
||||
return fmt.Errorf("fake error")
|
||||
})
|
||||
err := NewParallelExecutor(1, errorWorkflow)(ctx)
|
||||
assert.Equal(int32(1), count.Load())
|
||||
assert.Equal(1, count)
|
||||
assert.ErrorIs(context.Canceled, err)
|
||||
}
|
||||
|
||||
|
|
@ -149,16 +137,16 @@ func TestNewParallelExecutorCanceled(t *testing.T) {
|
|||
|
||||
errExpected := fmt.Errorf("fake error")
|
||||
|
||||
var count atomic.Int32
|
||||
count := 0
|
||||
successWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
|
||||
count.Add(1)
|
||||
count++
|
||||
return nil
|
||||
})
|
||||
errorWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
|
||||
count.Add(1)
|
||||
count++
|
||||
return errExpected
|
||||
})
|
||||
err := NewParallelExecutor(3, errorWorkflow, successWorkflow, successWorkflow)(ctx)
|
||||
assert.Equal(int32(3), count.Load())
|
||||
assert.Equal(3, count)
|
||||
assert.Error(errExpected, err)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ import (
|
|||
"github.com/mattn/go-isatty"
|
||||
log "github.com/sirupsen/logrus"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
var (
|
||||
|
|
@ -305,7 +305,7 @@ func gitOptions(token string) (fetchOptions git.FetchOptions, pullOptions git.Pu
|
|||
func NewGitCloneExecutor(input NewGitCloneExecutorInput) common.Executor {
|
||||
return func(ctx context.Context) error {
|
||||
logger := common.Logger(ctx)
|
||||
logger.Infof(" \u2601\ufe0f git clone '%s' # ref=%s", input.URL, input.Ref)
|
||||
logger.Infof(" \u2601 git clone '%s' # ref=%s", input.URL, input.Ref)
|
||||
logger.Debugf(" cloning %s to %s", input.URL, input.Dir)
|
||||
|
||||
cloneLock.Lock()
|
||||
|
|
@ -340,7 +340,7 @@ func NewGitCloneExecutor(input NewGitCloneExecutorInput) common.Executor {
|
|||
logger.Errorf("Unable to resolve %s: %v", input.Ref, err)
|
||||
}
|
||||
|
||||
if hash.String() != input.Ref && len(input.Ref) >= 4 && strings.HasPrefix(hash.String(), input.Ref) {
|
||||
if hash.String() != input.Ref && strings.HasPrefix(hash.String(), input.Ref) {
|
||||
return &Error{
|
||||
err: ErrShortRef,
|
||||
commit: hash.String(),
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
package git
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
|
|
@ -12,7 +13,7 @@ import (
|
|||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
func TestFindGitSlug(t *testing.T) {
|
||||
|
|
@ -53,6 +54,13 @@ func TestFindGitSlug(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
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)
|
||||
|
|
@ -77,7 +85,7 @@ func cleanGitHooks(dir string) error {
|
|||
func TestFindGitRemoteURL(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
basedir := t.TempDir()
|
||||
basedir := testDir(t)
|
||||
gitConfig()
|
||||
err := gitCmd("init", basedir)
|
||||
assert.NoError(err)
|
||||
|
|
@ -88,20 +96,20 @@ func TestFindGitRemoteURL(t *testing.T) {
|
|||
err = gitCmd("-C", basedir, "remote", "add", "origin", remoteURL)
|
||||
assert.NoError(err)
|
||||
|
||||
u, err := findGitRemoteURL(t.Context(), basedir, "origin")
|
||||
u, err := findGitRemoteURL(context.Background(), basedir, "origin")
|
||||
assert.NoError(err)
|
||||
assert.Equal(remoteURL, u)
|
||||
|
||||
remoteURL = "git@github.com/AwesomeOwner/MyAwesomeRepo.git"
|
||||
err = gitCmd("-C", basedir, "remote", "add", "upstream", remoteURL)
|
||||
assert.NoError(err)
|
||||
u, err = findGitRemoteURL(t.Context(), basedir, "upstream")
|
||||
u, err = findGitRemoteURL(context.Background(), basedir, "upstream")
|
||||
assert.NoError(err)
|
||||
assert.Equal(remoteURL, u)
|
||||
}
|
||||
|
||||
func TestGitFindRef(t *testing.T) {
|
||||
basedir := t.TempDir()
|
||||
basedir := testDir(t)
|
||||
gitConfig()
|
||||
|
||||
for name, tt := range map[string]struct {
|
||||
|
|
@ -166,6 +174,8 @@ func TestGitFindRef(t *testing.T) {
|
|||
},
|
||||
},
|
||||
} {
|
||||
tt := tt
|
||||
name := name
|
||||
t.Run(name, func(t *testing.T) {
|
||||
dir := filepath.Join(basedir, name)
|
||||
require.NoError(t, os.MkdirAll(dir, 0o755))
|
||||
|
|
@ -174,7 +184,7 @@ func TestGitFindRef(t *testing.T) {
|
|||
require.NoError(t, gitCmd("-C", dir, "config", "user.email", "user@example.com"))
|
||||
require.NoError(t, cleanGitHooks(dir))
|
||||
tt.Prepare(t, dir)
|
||||
ref, err := FindGitRef(t.Context(), dir)
|
||||
ref, err := FindGitRef(context.Background(), dir)
|
||||
tt.Assert(t, ref, err)
|
||||
})
|
||||
}
|
||||
|
|
@ -210,10 +220,10 @@ func TestGitCloneExecutor(t *testing.T) {
|
|||
clone := NewGitCloneExecutor(NewGitCloneExecutorInput{
|
||||
URL: tt.URL,
|
||||
Ref: tt.Ref,
|
||||
Dir: t.TempDir(),
|
||||
Dir: testDir(t),
|
||||
})
|
||||
|
||||
err := clone(t.Context())
|
||||
err := clone(context.Background())
|
||||
if tt.Err != nil {
|
||||
assert.Error(t, err)
|
||||
assert.Equal(t, tt.Err, err)
|
||||
|
|
@ -253,7 +263,7 @@ func gitCmd(args ...string) error {
|
|||
|
||||
func TestCloneIfRequired(t *testing.T) {
|
||||
tempDir := t.TempDir()
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
t.Run("clone", func(t *testing.T) {
|
||||
repo, err := CloneIfRequired(ctx, "refs/heads/main", NewGitCloneExecutorInput{
|
||||
|
|
|
|||
|
|
@ -5,21 +5,12 @@ package common
|
|||
import (
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
func randName(size int) (string, error) {
|
||||
func RandName(size int) (string, error) {
|
||||
randBytes := make([]byte, size)
|
||||
if _, err := rand.Read(randBytes); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(randBytes), nil
|
||||
}
|
||||
|
||||
func MustRandName(size int) string {
|
||||
name, err := randName(size)
|
||||
if err != nil {
|
||||
panic(fmt.Errorf("RandName(%d): %v", size, err))
|
||||
}
|
||||
return name
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,9 +3,8 @@ package container
|
|||
import (
|
||||
"context"
|
||||
"io"
|
||||
"time"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"github.com/docker/go-connections/nat"
|
||||
)
|
||||
|
||||
|
|
@ -35,6 +34,9 @@ type NewContainerInput struct {
|
|||
ConfigOptions string
|
||||
JobOptions string
|
||||
|
||||
// Gitea specific
|
||||
AutoRemove bool
|
||||
|
||||
ValidVolumes []string
|
||||
}
|
||||
|
||||
|
|
@ -61,7 +63,6 @@ type Container interface {
|
|||
Remove() common.Executor
|
||||
Close() common.Executor
|
||||
ReplaceLogWriter(io.Writer, io.Writer) (io.Writer, io.Writer)
|
||||
IsHealthy(ctx context.Context) (time.Duration, error)
|
||||
}
|
||||
|
||||
// NewDockerBuildExecutorInput the input for the NewDockerBuildExecutor function
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
|
|
@ -6,7 +6,7 @@ import (
|
|||
"context"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"github.com/docker/cli/cli/config"
|
||||
"github.com/docker/cli/cli/config/credentials"
|
||||
"github.com/docker/docker/api/types/registry"
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
|
|
@ -14,7 +14,7 @@ import (
|
|||
"github.com/moby/patternmatcher"
|
||||
"github.com/moby/patternmatcher/ignorefile"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
// NewDockerBuildExecutor function to create a run executor for the container
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
// This file is exact copy of https://github.com/docker/cli/blob/9ac8584acfd501c3f4da0e845e3a40ed15c85041/cli/command/container/opts.go
|
||||
// appended with license information.
|
||||
|
|
@ -13,7 +13,6 @@ package container
|
|||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path"
|
||||
|
|
@ -33,6 +32,7 @@ import (
|
|||
"github.com/docker/docker/api/types/versions"
|
||||
"github.com/docker/docker/errdefs"
|
||||
"github.com/docker/go-connections/nat"
|
||||
"github.com/pkg/errors"
|
||||
"github.com/sirupsen/logrus"
|
||||
"github.com/spf13/pflag"
|
||||
)
|
||||
|
|
@ -331,7 +331,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
// Validate the input mac address
|
||||
if copts.macAddress != "" {
|
||||
if _, err := opts.ValidateMACAddress(copts.macAddress); err != nil {
|
||||
return nil, fmt.Errorf("%s is not a valid mac address", copts.macAddress)
|
||||
return nil, errors.Errorf("%s is not a valid mac address", copts.macAddress)
|
||||
}
|
||||
}
|
||||
if copts.stdin {
|
||||
|
|
@ -347,7 +347,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
|
||||
swappiness := copts.swappiness
|
||||
if swappiness != -1 && (swappiness < 0 || swappiness > 100) {
|
||||
return nil, fmt.Errorf("invalid value: %d. Valid memory swappiness range is 0-100", swappiness)
|
||||
return nil, errors.Errorf("invalid value: %d. Valid memory swappiness range is 0-100", swappiness)
|
||||
}
|
||||
|
||||
mounts := copts.mounts.Value()
|
||||
|
|
@ -430,7 +430,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
// Merge in exposed ports to the map of published ports
|
||||
for _, e := range copts.expose.GetSlice() {
|
||||
if strings.Contains(e, ":") {
|
||||
return nil, fmt.Errorf("invalid port format for --expose: %s", e)
|
||||
return nil, errors.Errorf("invalid port format for --expose: %s", e)
|
||||
}
|
||||
// support two formats for expose, original format <portnum>/[<proto>]
|
||||
// or <startport-endport>/[<proto>]
|
||||
|
|
@ -439,7 +439,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
// if expose a port, the start and end port are the same
|
||||
start, end, err := nat.ParsePortRange(port)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid range format for --expose: %s, error: %s", e, err)
|
||||
return nil, errors.Errorf("invalid range format for --expose: %s, error: %s", e, err)
|
||||
}
|
||||
for i := start; i <= end; i++ {
|
||||
p, err := nat.NewPort(proto, strconv.FormatUint(i, 10))
|
||||
|
|
@ -488,22 +488,22 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
|
||||
pidMode := container.PidMode(copts.pidMode)
|
||||
if !pidMode.Valid() {
|
||||
return nil, errors.New("--pid: invalid PID mode")
|
||||
return nil, errors.Errorf("--pid: invalid PID mode")
|
||||
}
|
||||
|
||||
utsMode := container.UTSMode(copts.utsMode)
|
||||
if !utsMode.Valid() {
|
||||
return nil, errors.New("--uts: invalid UTS mode")
|
||||
return nil, errors.Errorf("--uts: invalid UTS mode")
|
||||
}
|
||||
|
||||
usernsMode := container.UsernsMode(copts.usernsMode)
|
||||
if !usernsMode.Valid() {
|
||||
return nil, errors.New("--userns: invalid USER mode")
|
||||
return nil, errors.Errorf("--userns: invalid USER mode")
|
||||
}
|
||||
|
||||
cgroupnsMode := container.CgroupnsMode(copts.cgroupnsMode)
|
||||
if !cgroupnsMode.Valid() {
|
||||
return nil, errors.New("--cgroupns: invalid CGROUP mode")
|
||||
return nil, errors.Errorf("--cgroupns: invalid CGROUP mode")
|
||||
}
|
||||
|
||||
restartPolicy, err := opts.ParseRestartPolicy(copts.restartPolicy)
|
||||
|
|
@ -537,7 +537,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
copts.healthRetries != 0
|
||||
if copts.noHealthcheck {
|
||||
if haveHealthSettings {
|
||||
return nil, errors.New("--no-healthcheck conflicts with --health-* options")
|
||||
return nil, errors.Errorf("--no-healthcheck conflicts with --health-* options")
|
||||
}
|
||||
test := strslice.StrSlice{"NONE"}
|
||||
healthConfig = &container.HealthConfig{Test: test}
|
||||
|
|
@ -548,16 +548,16 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
probe = strslice.StrSlice(args)
|
||||
}
|
||||
if copts.healthInterval < 0 {
|
||||
return nil, errors.New("--health-interval cannot be negative")
|
||||
return nil, errors.Errorf("--health-interval cannot be negative")
|
||||
}
|
||||
if copts.healthTimeout < 0 {
|
||||
return nil, errors.New("--health-timeout cannot be negative")
|
||||
return nil, errors.Errorf("--health-timeout cannot be negative")
|
||||
}
|
||||
if copts.healthRetries < 0 {
|
||||
return nil, errors.New("--health-retries cannot be negative")
|
||||
return nil, errors.Errorf("--health-retries cannot be negative")
|
||||
}
|
||||
if copts.healthStartPeriod < 0 {
|
||||
return nil, errors.New("--health-start-period cannot be negative")
|
||||
return nil, fmt.Errorf("--health-start-period cannot be negative")
|
||||
}
|
||||
|
||||
healthConfig = &container.HealthConfig{
|
||||
|
|
@ -677,7 +677,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
|
|||
}
|
||||
|
||||
if copts.autoRemove && !hostConfig.RestartPolicy.IsNone() {
|
||||
return nil, errors.New("Conflicting options: --restart and --rm")
|
||||
return nil, errors.Errorf("Conflicting options: --restart and --rm")
|
||||
}
|
||||
|
||||
// only set this value if the user provided the flag, else it should default to nil
|
||||
|
|
@ -741,7 +741,7 @@ func parseNetworkOpts(copts *containerOptions) (map[string]*networktypes.Endpoin
|
|||
return nil, err
|
||||
}
|
||||
if _, ok := endpoints[n.Target]; ok {
|
||||
return nil, errdefs.InvalidParameter(fmt.Errorf("network %q is specified multiple times", n.Target))
|
||||
return nil, errdefs.InvalidParameter(errors.Errorf("network %q is specified multiple times", n.Target))
|
||||
}
|
||||
|
||||
// For backward compatibility: if no custom options are provided for the network,
|
||||
|
|
@ -838,7 +838,7 @@ func convertToStandardNotation(ports []string) ([]string, error) {
|
|||
for _, param := range strings.Split(publish, ",") {
|
||||
opt := strings.Split(param, "=")
|
||||
if len(opt) < 2 {
|
||||
return optsList, fmt.Errorf("invalid publish opts format (should be name=value but got '%s')", param)
|
||||
return optsList, errors.Errorf("invalid publish opts format (should be name=value but got '%s')", param)
|
||||
}
|
||||
|
||||
params[opt[0]] = opt[1]
|
||||
|
|
@ -854,7 +854,7 @@ func convertToStandardNotation(ports []string) ([]string, error) {
|
|||
func parseLoggingOpts(loggingDriver string, loggingOpts []string) (map[string]string, error) {
|
||||
loggingOptsMap := opts.ConvertKVStringsToMap(loggingOpts)
|
||||
if loggingDriver == "none" && len(loggingOpts) > 0 {
|
||||
return map[string]string{}, fmt.Errorf("invalid logging opts for driver %s", loggingDriver)
|
||||
return map[string]string{}, errors.Errorf("invalid logging opts for driver %s", loggingDriver)
|
||||
}
|
||||
return loggingOptsMap, nil
|
||||
}
|
||||
|
|
@ -867,17 +867,17 @@ func parseSecurityOpts(securityOpts []string) ([]string, error) {
|
|||
if strings.Contains(opt, ":") {
|
||||
con = strings.SplitN(opt, ":", 2)
|
||||
} else {
|
||||
return securityOpts, fmt.Errorf("Invalid --security-opt: %q", opt)
|
||||
return securityOpts, errors.Errorf("Invalid --security-opt: %q", opt)
|
||||
}
|
||||
}
|
||||
if con[0] == "seccomp" && con[1] != "unconfined" {
|
||||
f, err := os.ReadFile(con[1])
|
||||
if err != nil {
|
||||
return securityOpts, fmt.Errorf("opening seccomp profile (%s) failed: %v", con[1], err)
|
||||
return securityOpts, errors.Errorf("opening seccomp profile (%s) failed: %v", con[1], err)
|
||||
}
|
||||
b := bytes.NewBuffer(nil)
|
||||
if err := json.Compact(b, f); err != nil {
|
||||
return securityOpts, fmt.Errorf("compacting json for seccomp profile (%s) failed: %v", con[1], err)
|
||||
return securityOpts, errors.Errorf("compacting json for seccomp profile (%s) failed: %v", con[1], err)
|
||||
}
|
||||
securityOpts[key] = fmt.Sprintf("seccomp=%s", b.Bytes())
|
||||
}
|
||||
|
|
@ -913,7 +913,7 @@ func parseStorageOpts(storageOpts []string) (map[string]string, error) {
|
|||
opt := strings.SplitN(option, "=", 2)
|
||||
m[opt[0]] = opt[1]
|
||||
} else {
|
||||
return nil, errors.New("invalid storage option")
|
||||
return nil, errors.Errorf("invalid storage option")
|
||||
}
|
||||
}
|
||||
return m, nil
|
||||
|
|
@ -927,7 +927,7 @@ func parseDevice(device, serverOS string) (container.DeviceMapping, error) {
|
|||
case "windows":
|
||||
return parseWindowsDevice(device)
|
||||
}
|
||||
return container.DeviceMapping{}, fmt.Errorf("unknown server OS: %s", serverOS)
|
||||
return container.DeviceMapping{}, errors.Errorf("unknown server OS: %s", serverOS)
|
||||
}
|
||||
|
||||
// parseLinuxDevice parses a device mapping string to a container.DeviceMapping struct
|
||||
|
|
@ -950,7 +950,7 @@ func parseLinuxDevice(device string) (container.DeviceMapping, error) {
|
|||
case 1:
|
||||
src = arr[0]
|
||||
default:
|
||||
return container.DeviceMapping{}, fmt.Errorf("invalid device specification: %s", device)
|
||||
return container.DeviceMapping{}, errors.Errorf("invalid device specification: %s", device)
|
||||
}
|
||||
|
||||
if dst == "" {
|
||||
|
|
@ -980,7 +980,7 @@ func validateDeviceCgroupRule(val string) (string, error) {
|
|||
return val, nil
|
||||
}
|
||||
|
||||
return val, fmt.Errorf("invalid device cgroup format '%s'", val)
|
||||
return val, errors.Errorf("invalid device cgroup format '%s'", val)
|
||||
}
|
||||
|
||||
// validDeviceMode checks if the mode for device is valid or not.
|
||||
|
|
@ -1012,7 +1012,7 @@ func validateDevice(val, serverOS string) (string, error) {
|
|||
// Windows does validation entirely server-side
|
||||
return val, nil
|
||||
}
|
||||
return "", fmt.Errorf("unknown server OS: %s", serverOS)
|
||||
return "", errors.Errorf("unknown server OS: %s", serverOS)
|
||||
}
|
||||
|
||||
// validateLinuxPath is the implementation of validateDevice knowing that the
|
||||
|
|
@ -1027,12 +1027,12 @@ func validateLinuxPath(val string, validator func(string) bool) (string, error)
|
|||
var mode string
|
||||
|
||||
if strings.Count(val, ":") > 2 {
|
||||
return val, fmt.Errorf("bad format for path: %s", val)
|
||||
return val, errors.Errorf("bad format for path: %s", val)
|
||||
}
|
||||
|
||||
split := strings.SplitN(val, ":", 3)
|
||||
if split[0] == "" {
|
||||
return val, fmt.Errorf("bad format for path: %s", val)
|
||||
return val, errors.Errorf("bad format for path: %s", val)
|
||||
}
|
||||
switch len(split) {
|
||||
case 1:
|
||||
|
|
@ -1051,13 +1051,13 @@ func validateLinuxPath(val string, validator func(string) bool) (string, error)
|
|||
containerPath = split[1]
|
||||
mode = split[2]
|
||||
if isValid := validator(split[2]); !isValid {
|
||||
return val, fmt.Errorf("bad mode specified: %s", mode)
|
||||
return val, errors.Errorf("bad mode specified: %s", mode)
|
||||
}
|
||||
val = fmt.Sprintf("%s:%s:%s", split[0], containerPath, mode)
|
||||
}
|
||||
|
||||
if !path.IsAbs(containerPath) {
|
||||
return val, fmt.Errorf("%s is not an absolute path", containerPath)
|
||||
return val, errors.Errorf("%s is not an absolute path", containerPath)
|
||||
}
|
||||
return val, nil
|
||||
}
|
||||
|
|
@ -1070,13 +1070,13 @@ func validateAttach(val string) (string, error) {
|
|||
return s, nil
|
||||
}
|
||||
}
|
||||
return val, errors.New("valid streams are STDIN, STDOUT and STDERR")
|
||||
return val, errors.Errorf("valid streams are STDIN, STDOUT and STDERR")
|
||||
}
|
||||
|
||||
func validateAPIVersion(c *containerConfig, serverAPIVersion string) error {
|
||||
for _, m := range c.HostConfig.Mounts {
|
||||
if m.BindOptions != nil && m.BindOptions.NonRecursive && versions.LessThan(serverAPIVersion, "1.40") {
|
||||
return errors.New("bind-nonrecursive requires API v1.40 or later")
|
||||
return errors.Errorf("bind-nonrecursive requires API v1.40 or later")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@
|
|||
package container
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
|
|
@ -22,6 +21,7 @@ import (
|
|||
"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"
|
||||
|
|
@ -288,7 +288,7 @@ func compareRandomizedStrings(a, b, c, d string) error {
|
|||
if a == d && b == c {
|
||||
return nil
|
||||
}
|
||||
return errors.New("strings don't match")
|
||||
return errors.Errorf("strings don't match")
|
||||
}
|
||||
|
||||
// Simple parse with MacAddress validation
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
|
|
@ -6,7 +6,6 @@ import (
|
|||
"context"
|
||||
"fmt"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
cerrdefs "github.com/containerd/errdefs"
|
||||
"github.com/docker/docker/api/types/image"
|
||||
)
|
||||
|
|
@ -27,15 +26,10 @@ func ImageExistsLocally(ctx context.Context, imageName, platform string) (bool,
|
|||
return false, err
|
||||
}
|
||||
|
||||
imagePlatform := fmt.Sprintf("%s/%s", inspectImage.Os, inspectImage.Architecture)
|
||||
|
||||
if platform == "" || platform == "any" || imagePlatform == platform {
|
||||
if platform == "" || platform == "any" || fmt.Sprintf("%s/%s", inspectImage.Os, inspectImage.Architecture) == platform {
|
||||
return true, nil
|
||||
}
|
||||
|
||||
logger := common.Logger(ctx)
|
||||
logger.Infof("image found but platform does not match: %s (image) != %s (platform)\n", imagePlatform, platform)
|
||||
|
||||
return false, nil
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
package container
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"testing"
|
||||
|
||||
|
|
@ -18,7 +19,7 @@ func TestImageExistsLocally(t *testing.T) {
|
|||
if testing.Short() {
|
||||
t.Skip("skipping integration test")
|
||||
}
|
||||
ctx := t.Context()
|
||||
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
|
||||
|
||||
|
|
@ -35,7 +36,7 @@ func TestImageExistsLocally(t *testing.T) {
|
|||
// pull an image
|
||||
cli, err := client.NewClientWithOpts(client.FromEnv)
|
||||
assert.Nil(t, err)
|
||||
cli.NegotiateAPIVersion(t.Context())
|
||||
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
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
|
|
@ -74,7 +74,7 @@ func logDockerResponse(logger logrus.FieldLogger, dockerResponse io.ReadCloser,
|
|||
return nil
|
||||
}
|
||||
|
||||
func writeLog(logger logrus.FieldLogger, isError bool, format string, args ...any) {
|
||||
func writeLog(logger logrus.FieldLogger, isError bool, format string, args ...interface{}) {
|
||||
if isError {
|
||||
logger.Errorf(format, args...)
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"github.com/docker/docker/api/types/network"
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
|
|
@ -13,7 +13,7 @@ import (
|
|||
"github.com/docker/docker/api/types/image"
|
||||
"github.com/docker/docker/api/types/registry"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
// NewDockerPullExecutor function to create a run executor for the container
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
package container
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/docker/cli/cli/config"
|
||||
|
|
@ -28,13 +29,13 @@ func TestCleanImage(t *testing.T) {
|
|||
}
|
||||
|
||||
for _, table := range tables {
|
||||
imageOut := cleanImage(t.Context(), table.imageIn)
|
||||
imageOut := cleanImage(context.Background(), table.imageIn)
|
||||
assert.Equal(t, table.imageOut, imageOut)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetImagePullOptions(t *testing.T) {
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
config.SetDir("/non-existent/docker")
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
|
|
@ -15,9 +15,7 @@ import (
|
|||
"runtime"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"dario.cat/mergo"
|
||||
"github.com/Masterminds/semver"
|
||||
"github.com/docker/cli/cli/compose/loader"
|
||||
"github.com/docker/cli/cli/connhelper"
|
||||
|
|
@ -32,14 +30,15 @@ import (
|
|||
"github.com/go-git/go-billy/v5/osfs"
|
||||
"github.com/go-git/go-git/v5/plumbing/format/gitignore"
|
||||
"github.com/gobwas/glob"
|
||||
"github.com/imdario/mergo"
|
||||
"github.com/joho/godotenv"
|
||||
"github.com/kballard/go-shellquote"
|
||||
specs "github.com/opencontainers/image-spec/specs-go/v1"
|
||||
"github.com/spf13/pflag"
|
||||
"golang.org/x/term"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/filecollector"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/filecollector"
|
||||
)
|
||||
|
||||
// NewContainer creates a reference to a container
|
||||
|
|
@ -192,47 +191,6 @@ func (cr *containerReference) Remove() common.Executor {
|
|||
).IfNot(common.Dryrun)
|
||||
}
|
||||
|
||||
func (cr *containerReference) inspect(ctx context.Context) (container.InspectResponse, error) {
|
||||
resp, err := cr.cli.ContainerInspect(ctx, cr.id)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("service %v: %s", cr.input.NetworkAliases, err)
|
||||
}
|
||||
return resp, err
|
||||
}
|
||||
|
||||
func (cr *containerReference) IsHealthy(ctx context.Context) (time.Duration, error) {
|
||||
resp, err := cr.inspect(ctx)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return cr.isHealthy(ctx, resp)
|
||||
}
|
||||
|
||||
func (cr *containerReference) isHealthy(ctx context.Context, resp container.InspectResponse) (time.Duration, error) {
|
||||
logger := common.Logger(ctx)
|
||||
if resp.Config == nil || resp.Config.Healthcheck == nil || resp.State == nil || resp.State.Health == nil || len(resp.Config.Healthcheck.Test) == 1 && strings.EqualFold(resp.Config.Healthcheck.Test[0], "NONE") {
|
||||
logger.Debugf("no container health check defined, hope for the best")
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
switch resp.State.Health.Status {
|
||||
case container.Starting:
|
||||
wait := resp.Config.Healthcheck.Interval
|
||||
if wait <= 0 {
|
||||
wait = time.Second
|
||||
}
|
||||
logger.Infof("service %v: container health check %s (%s) is starting, waiting %v", cr.input.NetworkAliases, cr.id, resp.Config.Image, wait)
|
||||
return wait, nil
|
||||
case container.Healthy:
|
||||
logger.Infof("service %v: container health check %s (%s) is healthy", cr.input.NetworkAliases, cr.id, resp.Config.Image)
|
||||
return 0, nil
|
||||
case container.Unhealthy:
|
||||
return 0, fmt.Errorf("service %v: container health check %s (%s) is not healthy", cr.input.NetworkAliases, cr.id, resp.Config.Image)
|
||||
default:
|
||||
return 0, fmt.Errorf("service %v: unexpected health status %s (%s) %v", cr.input.NetworkAliases, cr.id, resp.Config.Image, resp.State.Health.Status)
|
||||
}
|
||||
}
|
||||
|
||||
func (cr *containerReference) ReplaceLogWriter(stdout, stderr io.Writer) (io.Writer, io.Writer) {
|
||||
out := cr.input.Stdout
|
||||
err := cr.input.Stderr
|
||||
|
|
@ -454,11 +412,6 @@ func (cr *containerReference) mergeJobOptions(ctx context.Context, config *conta
|
|||
|
||||
logger := common.Logger(ctx)
|
||||
|
||||
if jobConfig.Config.Healthcheck != nil && len(jobConfig.Config.Healthcheck.Test) > 0 {
|
||||
logger.Debugf("--health-* options %+v", jobConfig.Config.Healthcheck)
|
||||
config.Healthcheck = jobConfig.Config.Healthcheck
|
||||
}
|
||||
|
||||
if len(jobConfig.Config.Volumes) > 0 {
|
||||
logger.Debugf("--volume options (except bind) %v", jobConfig.Config.Volumes)
|
||||
err = mergo.Merge(&config.Volumes, jobConfig.Config.Volumes, mergo.WithOverride, mergo.WithAppendSlice)
|
||||
|
|
@ -483,14 +436,6 @@ func (cr *containerReference) mergeJobOptions(ctx context.Context, config *conta
|
|||
}
|
||||
}
|
||||
|
||||
if jobConfig.HostConfig.Memory > 0 {
|
||||
logger.Debugf("--memory %v", jobConfig.HostConfig.Memory)
|
||||
if hostConfig.Memory > 0 && jobConfig.HostConfig.Memory > hostConfig.Memory {
|
||||
return nil, nil, fmt.Errorf("the --memory %v option found in the workflow cannot be greater than the --memory %v option from the runner configuration file", jobConfig.HostConfig.Memory, hostConfig.Memory)
|
||||
}
|
||||
hostConfig.Memory = jobConfig.HostConfig.Memory
|
||||
}
|
||||
|
||||
if len(jobConfig.Config.Hostname) > 0 {
|
||||
logger.Debugf("--hostname %v", jobConfig.Config.Hostname)
|
||||
config.Hostname = jobConfig.Config.Hostname
|
||||
|
|
@ -585,6 +530,7 @@ func (cr *containerReference) create(capAdd, capDrop []string) common.Executor {
|
|||
Privileged: input.Privileged,
|
||||
UsernsMode: container.UsernsMode(input.UsernsMode),
|
||||
PortBindings: input.PortBindings,
|
||||
AutoRemove: input.AutoRemove,
|
||||
}
|
||||
logger.Debugf("Common container.HostConfig ==> %+v", hostConfig)
|
||||
|
||||
|
|
@ -842,7 +788,7 @@ func (cr *containerReference) CopyTarStream(ctx context.Context, destPath string
|
|||
// Copy Content
|
||||
err = cr.cli.CopyToContainer(ctx, cr.id, destPath, tarStream, container.CopyToContainerOptions{})
|
||||
if err != nil {
|
||||
return fmt.Errorf("copyTarStream: failed to copy content to container: %w", err)
|
||||
return fmt.Errorf("failed to copy content to container: %w", err)
|
||||
}
|
||||
// If this fails, then folders have wrong permissions on non root container
|
||||
if cr.UID != 0 || cr.GID != 0 {
|
||||
|
|
@ -918,7 +864,7 @@ func (cr *containerReference) copyDir(dstPath, srcPath string, useGitIgnore bool
|
|||
}
|
||||
err = cr.cli.CopyToContainer(ctx, cr.id, "/", tarFile, container.CopyToContainerOptions{})
|
||||
if err != nil {
|
||||
return fmt.Errorf("copyDir: failed to copy content to container: %w", err)
|
||||
return fmt.Errorf("failed to copy content to container: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
@ -952,7 +898,7 @@ func (cr *containerReference) copyContent(dstPath string, files ...*FileEntry) c
|
|||
logger.Debugf("Extracting content to '%s'", dstPath)
|
||||
err := cr.cli.CopyToContainer(ctx, cr.id, dstPath, &buf, container.CopyToContainerOptions{})
|
||||
if err != nil {
|
||||
return fmt.Errorf("copyContent: failed to copy content to container: %w", err)
|
||||
return fmt.Errorf("failed to copy content to container: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ import (
|
|||
"testing"
|
||||
"time"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
|
||||
"github.com/docker/docker/api/types"
|
||||
"github.com/docker/docker/api/types/container"
|
||||
|
|
@ -26,7 +26,7 @@ func TestDocker(t *testing.T) {
|
|||
if testing.Short() {
|
||||
t.Skip("skipping integration test")
|
||||
}
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
client, err := GetDockerClient(ctx)
|
||||
assert.NoError(t, err)
|
||||
defer client.Close()
|
||||
|
|
@ -152,7 +152,7 @@ func TestDockerExecAbort(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDockerExecFailure(t *testing.T) {
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
conn := &mockConn{}
|
||||
|
||||
|
|
@ -183,7 +183,7 @@ func TestDockerExecFailure(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDockerCopyTarStream(t *testing.T) {
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
conn := &mockConn{}
|
||||
|
||||
|
|
@ -205,7 +205,7 @@ func TestDockerCopyTarStream(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDockerCopyTarStreamErrorInCopyFiles(t *testing.T) {
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
conn := &mockConn{}
|
||||
|
||||
|
|
@ -230,7 +230,7 @@ func TestDockerCopyTarStreamErrorInCopyFiles(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDockerCopyTarStreamErrorInMkdir(t *testing.T) {
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
conn := &mockConn{}
|
||||
|
||||
|
|
@ -318,7 +318,7 @@ func TestCheckVolumes(t *testing.T) {
|
|||
for _, tc := range testCases {
|
||||
t.Run(tc.desc, func(t *testing.T) {
|
||||
logger, _ := test.NewNullLogger()
|
||||
ctx := common.WithLogger(t.Context(), logger)
|
||||
ctx := common.WithLogger(context.Background(), logger)
|
||||
cr := &containerReference{
|
||||
input: &NewContainerInput{
|
||||
ValidVolumes: tc.validVolumes,
|
||||
|
|
@ -338,18 +338,11 @@ func TestMergeJobOptions(t *testing.T) {
|
|||
hostConfig *container.HostConfig
|
||||
}{
|
||||
{
|
||||
name: "Ok",
|
||||
options: `--volume /frob:/nitz --volume somevolume --tmpfs /tmp:exec,noatime --hostname alternatehost --health-cmd "healthz one" --health-interval 10s --health-timeout 5s --health-retries 3 --health-start-period 30s`,
|
||||
name: "ok",
|
||||
options: "--volume /frob:/nitz --volume somevolume --tmpfs /tmp:exec,noatime --hostname alternatehost",
|
||||
config: &container.Config{
|
||||
Volumes: map[string]struct{}{"somevolume": {}},
|
||||
Hostname: "alternatehost",
|
||||
Healthcheck: &container.HealthConfig{
|
||||
Test: []string{"CMD-SHELL", "healthz one"},
|
||||
Interval: 10 * time.Second,
|
||||
Timeout: 5 * time.Second,
|
||||
StartPeriod: 30 * time.Second,
|
||||
Retries: 3,
|
||||
},
|
||||
},
|
||||
hostConfig: &container.HostConfig{
|
||||
Binds: []string{"/frob:/nitz"},
|
||||
|
|
@ -357,17 +350,7 @@ func TestMergeJobOptions(t *testing.T) {
|
|||
},
|
||||
},
|
||||
{
|
||||
name: "DisableHealthCheck",
|
||||
options: `--no-healthcheck`,
|
||||
config: &container.Config{
|
||||
Healthcheck: &container.HealthConfig{
|
||||
Test: []string{"NONE"},
|
||||
},
|
||||
},
|
||||
hostConfig: &container.HostConfig{},
|
||||
},
|
||||
{
|
||||
name: "Ignore",
|
||||
name: "ignore",
|
||||
options: "--pid=host --device=/dev/sda",
|
||||
config: &container.Config{},
|
||||
hostConfig: &container.HostConfig{},
|
||||
|
|
@ -379,86 +362,10 @@ func TestMergeJobOptions(t *testing.T) {
|
|||
JobOptions: testCase.options,
|
||||
},
|
||||
}
|
||||
config, hostConfig, err := cr.mergeJobOptions(t.Context(), &container.Config{}, &container.HostConfig{})
|
||||
config, hostConfig, err := cr.mergeJobOptions(context.Background(), &container.Config{}, &container.HostConfig{})
|
||||
require.NoError(t, err)
|
||||
assert.EqualValues(t, testCase.config, config)
|
||||
assert.EqualValues(t, testCase.hostConfig, hostConfig)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDockerRun_isHealthy(t *testing.T) {
|
||||
cr := containerReference{
|
||||
id: "containerid",
|
||||
input: &NewContainerInput{
|
||||
NetworkAliases: []string{"servicename"},
|
||||
},
|
||||
}
|
||||
ctx := t.Context()
|
||||
makeInspectResponse := func(interval time.Duration, status container.HealthStatus, test []string) container.InspectResponse {
|
||||
return container.InspectResponse{
|
||||
Config: &container.Config{
|
||||
Image: "example.com/some/image",
|
||||
Healthcheck: &container.HealthConfig{
|
||||
Interval: interval,
|
||||
Test: test,
|
||||
},
|
||||
},
|
||||
ContainerJSONBase: &container.ContainerJSONBase{
|
||||
State: &container.State{
|
||||
Health: &container.Health{
|
||||
Status: status,
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("IncompleteResponseOrNoHealthCheck", func(t *testing.T) {
|
||||
wait, err := cr.isHealthy(ctx, container.InspectResponse{})
|
||||
assert.Zero(t, wait)
|
||||
assert.NoError(t, err)
|
||||
|
||||
// --no-healthcheck translates into a NONE test command
|
||||
resp := makeInspectResponse(0, container.NoHealthcheck, []string{"NONE"})
|
||||
wait, err = cr.isHealthy(ctx, resp)
|
||||
assert.Zero(t, wait)
|
||||
assert.NoError(t, err)
|
||||
})
|
||||
|
||||
t.Run("StartingUndefinedIntervalIsNotZero", func(t *testing.T) {
|
||||
resp := makeInspectResponse(0, container.Starting, nil)
|
||||
wait, err := cr.isHealthy(ctx, resp)
|
||||
assert.NotZero(t, wait)
|
||||
assert.NoError(t, err)
|
||||
})
|
||||
|
||||
t.Run("StartingWithInterval", func(t *testing.T) {
|
||||
expectedWait := time.Duration(42)
|
||||
resp := makeInspectResponse(expectedWait, container.Starting, nil)
|
||||
actualWait, err := cr.isHealthy(ctx, resp)
|
||||
assert.Equal(t, expectedWait, actualWait)
|
||||
assert.NoError(t, err)
|
||||
})
|
||||
|
||||
t.Run("Unhealthy", func(t *testing.T) {
|
||||
resp := makeInspectResponse(0, container.Unhealthy, nil)
|
||||
wait, err := cr.isHealthy(ctx, resp)
|
||||
assert.Zero(t, wait)
|
||||
assert.ErrorContains(t, err, "is not healthy")
|
||||
})
|
||||
|
||||
t.Run("Healthy", func(t *testing.T) {
|
||||
resp := makeInspectResponse(0, container.Healthy, nil)
|
||||
wait, err := cr.isHealthy(ctx, resp)
|
||||
assert.Zero(t, wait)
|
||||
assert.NoError(t, err)
|
||||
})
|
||||
|
||||
t.Run("UnknownStatus", func(t *testing.T) {
|
||||
resp := makeInspectResponse(0, container.NoHealthcheck, nil)
|
||||
wait, err := cr.isHealthy(ctx, resp)
|
||||
assert.Zero(t, wait)
|
||||
assert.ErrorContains(t, err, "unexpected")
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,15 +1,15 @@
|
|||
//go:build WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd)
|
||||
//go:build WITHOUT_DOCKER || !(linux || darwin || windows || netbsd)
|
||||
|
||||
package container
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"runtime"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"github.com/docker/docker/api/types/network"
|
||||
"github.com/docker/docker/api/types/system"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
// ImageExistsLocally returns a boolean indicating if an image with the
|
||||
|
|
|
|||
|
|
@ -1,17 +1,16 @@
|
|||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd || freebsd))
|
||||
//go:build !(WITHOUT_DOCKER || !(linux || darwin || windows || netbsd))
|
||||
|
||||
package container
|
||||
|
||||
import (
|
||||
"context"
|
||||
"slices"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"github.com/docker/docker/api/types/filters"
|
||||
"github.com/docker/docker/api/types/volume"
|
||||
)
|
||||
|
||||
func NewDockerVolumesRemoveExecutor(volumeNames []string) common.Executor {
|
||||
func NewDockerVolumeRemoveExecutor(volumeName string, force bool) common.Executor {
|
||||
return func(ctx context.Context) error {
|
||||
cli, err := GetDockerClient(ctx)
|
||||
if err != nil {
|
||||
|
|
@ -25,18 +24,17 @@ func NewDockerVolumesRemoveExecutor(volumeNames []string) common.Executor {
|
|||
}
|
||||
|
||||
for _, vol := range list.Volumes {
|
||||
if slices.Contains(volumeNames, vol.Name) {
|
||||
if err := removeExecutor(vol.Name)(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
if vol.Name == volumeName {
|
||||
return removeExecutor(volumeName, force)(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
// Volume not found - do nothing
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func removeExecutor(volume string) common.Executor {
|
||||
func removeExecutor(volume string, force bool) common.Executor {
|
||||
return func(ctx context.Context) error {
|
||||
logger := common.Logger(ctx)
|
||||
logger.Debugf("%sdocker volume rm %s", logPrefix, volume)
|
||||
|
|
@ -51,7 +49,6 @@ func removeExecutor(volume string) common.Executor {
|
|||
}
|
||||
defer cli.Close()
|
||||
|
||||
force := false
|
||||
return cli.VolumeRemove(ctx, volume, force)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ type ExecutionsEnvironment interface {
|
|||
GetPathVariableName() string
|
||||
DefaultPathVariable() string
|
||||
JoinPathVariable(...string) string
|
||||
GetRunnerContext(ctx context.Context) map[string]any
|
||||
GetRunnerContext(ctx context.Context) map[string]interface{}
|
||||
// On windows PATH and Path are the same key
|
||||
IsEnvironmentCaseInsensitive() bool
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@ import (
|
|||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/go-git/go-billy/v5/helper/polyfill"
|
||||
|
|
@ -21,9 +20,9 @@ import (
|
|||
"github.com/go-git/go-git/v5/plumbing/format/gitignore"
|
||||
"golang.org/x/term"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/filecollector"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/lookpath"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/filecollector"
|
||||
"code.forgejo.org/forgejo/runner/act/lookpath"
|
||||
)
|
||||
|
||||
type HostEnvironment struct {
|
||||
|
|
@ -34,6 +33,7 @@ type HostEnvironment struct {
|
|||
Workdir string
|
||||
ActPath string
|
||||
Root string
|
||||
CleanUp func()
|
||||
StdOut io.Writer
|
||||
LXC bool
|
||||
}
|
||||
|
|
@ -191,12 +191,12 @@ func (e *HostEnvironment) Start(_ bool) common.Executor {
|
|||
|
||||
type ptyWriter struct {
|
||||
Out io.Writer
|
||||
AutoStop atomic.Bool
|
||||
AutoStop bool
|
||||
dirtyLine bool
|
||||
}
|
||||
|
||||
func (w *ptyWriter) Write(buf []byte) (int, error) {
|
||||
if w.AutoStop.Load() && len(buf) > 0 && buf[len(buf)-1] == 4 {
|
||||
if w.AutoStop && len(buf) > 0 && buf[len(buf)-1] == 4 {
|
||||
n, err := w.Out.Write(buf[:len(buf)-1])
|
||||
if err != nil {
|
||||
return n, err
|
||||
|
|
@ -365,7 +365,7 @@ func (e *HostEnvironment) exec(ctx context.Context, commandparam []string, cmdli
|
|||
return fmt.Errorf("RUN %w", err)
|
||||
}
|
||||
if tty != nil {
|
||||
writer.AutoStop.Store(true)
|
||||
writer.AutoStop = true
|
||||
if _, err := tty.Write([]byte("\x04")); err != nil {
|
||||
common.Logger(ctx).Debug("Failed to write EOT")
|
||||
}
|
||||
|
|
@ -388,7 +388,7 @@ func (e *HostEnvironment) ExecWithCmdLine(command []string, cmdline string, env
|
|||
if err := e.exec(ctx, command, cmdline, env, user, workdir); err != nil {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return fmt.Errorf("this step has been cancelled: ctx: %w, exec: %w", ctx.Err(), err)
|
||||
return fmt.Errorf("this step has been cancelled: %w", err)
|
||||
default:
|
||||
return err
|
||||
}
|
||||
|
|
@ -403,12 +403,10 @@ func (e *HostEnvironment) UpdateFromEnv(srcPath string, env *map[string]string)
|
|||
|
||||
func (e *HostEnvironment) Remove() common.Executor {
|
||||
return func(ctx context.Context) error {
|
||||
if e.GetLXC() {
|
||||
// there may be files owned by root: removal
|
||||
// is the responsibility of the LXC backend
|
||||
return nil
|
||||
if e.CleanUp != nil {
|
||||
e.CleanUp()
|
||||
}
|
||||
return os.RemoveAll(e.Root)
|
||||
return os.RemoveAll(e.Path)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -464,7 +462,6 @@ func (*HostEnvironment) JoinPathVariable(paths ...string) string {
|
|||
// https://docs.github.com/en/actions/learn-github-actions/contexts#runner-context
|
||||
func goArchToActionArch(arch string) string {
|
||||
archMapper := map[string]string{
|
||||
"amd64": "X64",
|
||||
"x86_64": "X64",
|
||||
"386": "X86",
|
||||
"aarch64": "ARM64",
|
||||
|
|
@ -487,8 +484,8 @@ func goOsToActionOs(os string) string {
|
|||
return os
|
||||
}
|
||||
|
||||
func (e *HostEnvironment) GetRunnerContext(_ context.Context) map[string]any {
|
||||
return map[string]any{
|
||||
func (e *HostEnvironment) GetRunnerContext(_ context.Context) map[string]interface{} {
|
||||
return map[string]interface{}{
|
||||
"os": goOsToActionOs(runtime.GOOS),
|
||||
"arch": goArchToActionArch(runtime.GOARCH),
|
||||
"temp": e.TmpDir,
|
||||
|
|
@ -496,10 +493,6 @@ func (e *HostEnvironment) GetRunnerContext(_ context.Context) map[string]any {
|
|||
}
|
||||
}
|
||||
|
||||
func (e *HostEnvironment) IsHealthy(ctx context.Context) (time.Duration, error) {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
func (e *HostEnvironment) ReplaceLogWriter(stdout, _ io.Writer) (io.Writer, io.Writer) {
|
||||
org := e.StdOut
|
||||
e.StdOut = stdout
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ package container
|
|||
|
||||
import (
|
||||
"archive/tar"
|
||||
"context"
|
||||
"io"
|
||||
"os"
|
||||
"path"
|
||||
|
|
@ -15,8 +16,10 @@ import (
|
|||
var _ ExecutionsEnvironment = &HostEnvironment{}
|
||||
|
||||
func TestCopyDir(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
ctx := t.Context()
|
||||
dir, err := os.MkdirTemp("", "test-host-env-*")
|
||||
assert.NoError(t, err)
|
||||
defer os.RemoveAll(dir)
|
||||
ctx := context.Background()
|
||||
e := &HostEnvironment{
|
||||
Path: filepath.Join(dir, "path"),
|
||||
TmpDir: filepath.Join(dir, "tmp"),
|
||||
|
|
@ -29,13 +32,15 @@ func TestCopyDir(t *testing.T) {
|
|||
_ = os.MkdirAll(e.TmpDir, 0o700)
|
||||
_ = os.MkdirAll(e.ToolCache, 0o700)
|
||||
_ = os.MkdirAll(e.ActPath, 0o700)
|
||||
err := e.CopyDir(e.Workdir, e.Path, true)(ctx)
|
||||
err = e.CopyDir(e.Workdir, e.Path, true)(ctx)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestGetContainerArchive(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
ctx := t.Context()
|
||||
dir, err := os.MkdirTemp("", "test-host-env-*")
|
||||
assert.NoError(t, err)
|
||||
defer os.RemoveAll(dir)
|
||||
ctx := context.Background()
|
||||
e := &HostEnvironment{
|
||||
Path: filepath.Join(dir, "path"),
|
||||
TmpDir: filepath.Join(dir, "tmp"),
|
||||
|
|
@ -49,7 +54,7 @@ func TestGetContainerArchive(t *testing.T) {
|
|||
_ = os.MkdirAll(e.ToolCache, 0o700)
|
||||
_ = os.MkdirAll(e.ActPath, 0o700)
|
||||
expectedContent := []byte("sdde/7sh")
|
||||
err := os.WriteFile(filepath.Join(e.Path, "action.yml"), expectedContent, 0o600)
|
||||
err = os.WriteFile(filepath.Join(e.Path, "action.yml"), expectedContent, 0o600)
|
||||
assert.NoError(t, err)
|
||||
archive, err := e.GetContainerArchive(ctx, e.Path)
|
||||
assert.NoError(t, err)
|
||||
|
|
|
|||
|
|
@ -76,8 +76,8 @@ func (*LinuxContainerEnvironmentExtensions) JoinPathVariable(paths ...string) st
|
|||
return strings.Join(paths, ":")
|
||||
}
|
||||
|
||||
func (l *LinuxContainerEnvironmentExtensions) GetRunnerContext(ctx context.Context) map[string]any {
|
||||
return map[string]any{
|
||||
func (l *LinuxContainerEnvironmentExtensions) GetRunnerContext(ctx context.Context) map[string]interface{} {
|
||||
return map[string]interface{}{
|
||||
"os": "Linux",
|
||||
"arch": RunnerArch(ctx),
|
||||
"temp": "/tmp",
|
||||
|
|
|
|||
|
|
@ -35,13 +35,18 @@ func TestContainerPath(t *testing.T) {
|
|||
{fmt.Sprintf("/mnt/%v/act", rootDriveLetter), "act", fmt.Sprintf("%s\\", rootDrive)},
|
||||
} {
|
||||
if v.workDir != "" {
|
||||
t.Chdir(v.workDir)
|
||||
if err := os.Chdir(v.workDir); err != nil {
|
||||
log.Error(err)
|
||||
t.Fail()
|
||||
}
|
||||
}
|
||||
|
||||
assert.Equal(t, v.destinationPath, linuxcontainerext.ToContainerPath(v.sourcePath))
|
||||
}
|
||||
|
||||
t.Chdir(cwd)
|
||||
if err := os.Chdir(cwd); err != nil {
|
||||
log.Error(err)
|
||||
}
|
||||
} else {
|
||||
cwd, err := os.Getwd()
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ import (
|
|||
"io"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
func parseEnvFile(e Container, srcPath string, env *map[string]string) common.Executor {
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ import (
|
|||
|
||||
"github.com/go-git/go-git/v5/plumbing/format/gitignore"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"github.com/rhysd/actionlint"
|
||||
)
|
||||
|
||||
|
|
@ -165,12 +165,12 @@ func (impl *interperterImpl) toJSON(value reflect.Value) (string, error) {
|
|||
return string(json), nil
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) fromJSON(value reflect.Value) (any, error) {
|
||||
func (impl *interperterImpl) fromJSON(value reflect.Value) (interface{}, error) {
|
||||
if value.Kind() != reflect.String {
|
||||
return nil, fmt.Errorf("Cannot parse non-string type %v as JSON", value.Kind())
|
||||
}
|
||||
|
||||
var data any
|
||||
var data interface{}
|
||||
|
||||
err := json.Unmarshal([]byte(value.String()), &data)
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -4,14 +4,14 @@ import (
|
|||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestFunctionContains(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"contains('search', 'item') }}", false, "contains-str-str"},
|
||||
|
|
@ -31,13 +31,6 @@ func TestFunctionContains(t *testing.T) {
|
|||
{`contains(fromJSON('[3.14,"second"]'), 3.14) }}`, true, "contains-item-number-number"},
|
||||
{`contains(fromJSON('["","second"]'), fromJSON('[]')) }}`, false, "contains-item-str-arr"},
|
||||
{`contains(fromJSON('["","second"]'), fromJSON('{}')) }}`, false, "contains-item-str-obj"},
|
||||
{`contains(fromJSON('[{ "first": { "result": "success" }},{ "second": { "result": "success" }}]').first.result, 'success') }}`, true, "multiple-contains-item"},
|
||||
{`contains(fromJSON('[{ "result": "success" },{ "result": "failure" }]').*.result, 'failure') }}`, true, "multiple-contains-dereferenced-failure-item"},
|
||||
{`contains(fromJSON('[{ "result": "failure" },{ "result": "success" }]').*.result, 'success') }}`, true, "multiple-contains-dereferenced-success-item"},
|
||||
{`contains(fromJSON('[{ "result": "failure" },{ "result": "success" }]').*.result, 'notthere') }}`, false, "multiple-contains-dereferenced-missing-item"},
|
||||
{`contains(fromJSON('[{ "result": "failure", "outputs": { "key": "val1" } },{ "result": "success", "outputs": { "key": "val2" } }]').*.outputs.key, 'val1') }}`, true, "multiple-contains-dereferenced-output-item"},
|
||||
{`contains(fromJSON('[{ "result": "failure", "outputs": { "key": "val1" } },{ "result": "success", "outputs": { "key": "val2" } }]').*.outputs.key, 'val2') }}`, true, "multiple-contains-dereferenced-output-item-2"},
|
||||
{`contains(fromJSON('[{ "result": "failure", "outputs": { "key": "val1" } },{ "result": "success", "outputs": { "key": "val2" } }]').*.outputs.key, 'missing') }}`, false, "multiple-contains-dereferenced-output-misssing-item"},
|
||||
}
|
||||
|
||||
env := &EvaluationEnvironment{}
|
||||
|
|
@ -58,7 +51,7 @@ func TestFunctionContains(t *testing.T) {
|
|||
func TestFunctionStartsWith(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"startsWith('search', 'se') }}", true, "startswith-string"},
|
||||
|
|
@ -90,7 +83,7 @@ func TestFunctionStartsWith(t *testing.T) {
|
|||
func TestFunctionEndsWith(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"endsWith('search', 'ch') }}", true, "endsWith-string"},
|
||||
|
|
@ -122,7 +115,7 @@ func TestFunctionEndsWith(t *testing.T) {
|
|||
func TestFunctionJoin(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"join(fromJSON('[\"a\", \"b\"]'), ',')", "a,b", "join-arr"},
|
||||
|
|
@ -152,7 +145,7 @@ func TestFunctionJoin(t *testing.T) {
|
|||
func TestFunctionToJSON(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"toJSON(env) }}", "{\n \"key\": \"value\"\n}", "toJSON"},
|
||||
|
|
@ -181,10 +174,10 @@ func TestFunctionToJSON(t *testing.T) {
|
|||
func TestFunctionFromJSON(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"fromJSON('{\"foo\":\"bar\"}') }}", map[string]any{
|
||||
{"fromJSON('{\"foo\":\"bar\"}') }}", map[string]interface{}{
|
||||
"foo": "bar",
|
||||
}, "fromJSON"},
|
||||
}
|
||||
|
|
@ -207,7 +200,7 @@ func TestFunctionFromJSON(t *testing.T) {
|
|||
func TestFunctionHashFiles(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"hashFiles('**/non-extant-files') }}", "", "hash-non-existing-file"},
|
||||
|
|
@ -237,8 +230,8 @@ func TestFunctionHashFiles(t *testing.T) {
|
|||
func TestFunctionFormat(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
error any
|
||||
expected interface{}
|
||||
error interface{}
|
||||
name string
|
||||
}{
|
||||
{"format('text')", "text", nil, "format-plain-string"},
|
||||
|
|
@ -277,23 +270,3 @@ func TestFunctionFormat(t *testing.T) {
|
|||
_, err := NewInterpeter(env, Config{}).Evaluate("format()", DefaultStatusCheckNone)
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestMapContains(t *testing.T) {
|
||||
env := &EvaluationEnvironment{
|
||||
Needs: map[string]Needs{
|
||||
"first-job": {
|
||||
Outputs: map[string]string{},
|
||||
Result: "success",
|
||||
},
|
||||
"second-job": {
|
||||
Outputs: map[string]string{},
|
||||
Result: "failure",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
output, err := NewInterpeter(env, Config{}).Evaluate("contains(needs.*.result, 'failure')", DefaultStatusCheckNone)
|
||||
assert.NoError(t, err)
|
||||
|
||||
assert.Equal(t, true, output)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import (
|
|||
"reflect"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"github.com/rhysd/actionlint"
|
||||
)
|
||||
|
||||
|
|
@ -17,14 +17,14 @@ type EvaluationEnvironment struct {
|
|||
Job *model.JobContext
|
||||
Jobs *map[string]*model.WorkflowCallResult
|
||||
Steps map[string]*model.StepResult
|
||||
Runner map[string]any
|
||||
Runner map[string]interface{}
|
||||
Secrets map[string]string
|
||||
Vars map[string]string
|
||||
Strategy map[string]any
|
||||
Matrix map[string]any
|
||||
Strategy map[string]interface{}
|
||||
Matrix map[string]interface{}
|
||||
Needs map[string]Needs
|
||||
Inputs map[string]any
|
||||
HashFiles func([]reflect.Value) (any, error)
|
||||
Inputs map[string]interface{}
|
||||
HashFiles func([]reflect.Value) (interface{}, error)
|
||||
}
|
||||
|
||||
type Needs struct {
|
||||
|
|
@ -63,7 +63,7 @@ func (dsc DefaultStatusCheck) String() string {
|
|||
}
|
||||
|
||||
type Interpreter interface {
|
||||
Evaluate(input string, defaultStatusCheck DefaultStatusCheck) (any, error)
|
||||
Evaluate(input string, defaultStatusCheck DefaultStatusCheck) (interface{}, error)
|
||||
}
|
||||
|
||||
type interperterImpl struct {
|
||||
|
|
@ -78,7 +78,7 @@ func NewInterpeter(env *EvaluationEnvironment, config Config) Interpreter {
|
|||
}
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) Evaluate(input string, defaultStatusCheck DefaultStatusCheck) (any, error) {
|
||||
func (impl *interperterImpl) Evaluate(input string, defaultStatusCheck DefaultStatusCheck) (interface{}, error) {
|
||||
input = strings.TrimPrefix(input, "${{")
|
||||
if defaultStatusCheck != DefaultStatusCheckNone && input == "" {
|
||||
input = "success()"
|
||||
|
|
@ -117,7 +117,7 @@ func (impl *interperterImpl) Evaluate(input string, defaultStatusCheck DefaultSt
|
|||
return result, err2
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateNode(exprNode actionlint.ExprNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateNode(exprNode actionlint.ExprNode) (interface{}, error) {
|
||||
switch node := exprNode.(type) {
|
||||
case *actionlint.VariableNode:
|
||||
return impl.evaluateVariable(node)
|
||||
|
|
@ -150,7 +150,7 @@ func (impl *interperterImpl) evaluateNode(exprNode actionlint.ExprNode) (any, er
|
|||
}
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateVariable(variableNode *actionlint.VariableNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateVariable(variableNode *actionlint.VariableNode) (interface{}, error) {
|
||||
switch strings.ToLower(variableNode.Name) {
|
||||
case "github":
|
||||
return impl.env.Github, nil
|
||||
|
|
@ -158,8 +158,6 @@ func (impl *interperterImpl) evaluateVariable(variableNode *actionlint.VariableN
|
|||
return impl.env.Github, nil
|
||||
case "forge":
|
||||
return impl.env.Github, nil
|
||||
case "forgejo":
|
||||
return impl.env.Github, nil
|
||||
case "env":
|
||||
return impl.env.Env, nil
|
||||
case "job":
|
||||
|
|
@ -194,7 +192,7 @@ func (impl *interperterImpl) evaluateVariable(variableNode *actionlint.VariableN
|
|||
}
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateIndexAccess(indexAccessNode *actionlint.IndexAccessNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateIndexAccess(indexAccessNode *actionlint.IndexAccessNode) (interface{}, error) {
|
||||
left, err := impl.evaluateNode(indexAccessNode.Operand)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -229,20 +227,16 @@ func (impl *interperterImpl) evaluateIndexAccess(indexAccessNode *actionlint.Ind
|
|||
}
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateObjectDeref(objectDerefNode *actionlint.ObjectDerefNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateObjectDeref(objectDerefNode *actionlint.ObjectDerefNode) (interface{}, error) {
|
||||
left, err := impl.evaluateNode(objectDerefNode.Receiver)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
_, receiverIsDeref := objectDerefNode.Receiver.(*actionlint.ArrayDerefNode)
|
||||
if receiverIsDeref {
|
||||
return impl.getPropertyValueDereferenced(reflect.ValueOf(left), objectDerefNode.Property)
|
||||
}
|
||||
return impl.getPropertyValue(reflect.ValueOf(left), objectDerefNode.Property)
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateArrayDeref(arrayDerefNode *actionlint.ArrayDerefNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateArrayDeref(arrayDerefNode *actionlint.ArrayDerefNode) (interface{}, error) {
|
||||
left, err := impl.evaluateNode(arrayDerefNode.Receiver)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -251,7 +245,7 @@ func (impl *interperterImpl) evaluateArrayDeref(arrayDerefNode *actionlint.Array
|
|||
return impl.getSafeValue(reflect.ValueOf(left)), nil
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) getPropertyValue(left reflect.Value, property string) (value any, err error) {
|
||||
func (impl *interperterImpl) getPropertyValue(left reflect.Value, property string) (value interface{}, err error) {
|
||||
switch left.Kind() {
|
||||
case reflect.Ptr:
|
||||
return impl.getPropertyValue(left.Elem(), property)
|
||||
|
|
@ -305,7 +299,7 @@ func (impl *interperterImpl) getPropertyValue(left reflect.Value, property strin
|
|||
return nil, nil
|
||||
|
||||
case reflect.Slice:
|
||||
var values []any
|
||||
var values []interface{}
|
||||
|
||||
for i := 0; i < left.Len(); i++ {
|
||||
value, err := impl.getPropertyValue(left.Index(i).Elem(), property)
|
||||
|
|
@ -322,30 +316,7 @@ func (impl *interperterImpl) getPropertyValue(left reflect.Value, property strin
|
|||
return nil, nil
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) getPropertyValueDereferenced(left reflect.Value, property string) (value any, err error) {
|
||||
switch left.Kind() {
|
||||
case reflect.Map:
|
||||
iter := left.MapRange()
|
||||
|
||||
var values []any
|
||||
for iter.Next() {
|
||||
value, err := impl.getPropertyValue(iter.Value(), property)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
values = append(values, value)
|
||||
}
|
||||
|
||||
return values, nil
|
||||
case reflect.Ptr, reflect.Struct, reflect.Slice:
|
||||
return impl.getPropertyValue(left, property)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) getMapValue(value reflect.Value) (any, error) {
|
||||
func (impl *interperterImpl) getMapValue(value reflect.Value) (interface{}, error) {
|
||||
if value.Kind() == reflect.Ptr {
|
||||
return impl.getMapValue(value.Elem())
|
||||
}
|
||||
|
|
@ -353,7 +324,7 @@ func (impl *interperterImpl) getMapValue(value reflect.Value) (any, error) {
|
|||
return value.Interface(), nil
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateNot(notNode *actionlint.NotOpNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateNot(notNode *actionlint.NotOpNode) (interface{}, error) {
|
||||
operand, err := impl.evaluateNode(notNode.Operand)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -362,7 +333,7 @@ func (impl *interperterImpl) evaluateNot(notNode *actionlint.NotOpNode) (any, er
|
|||
return !IsTruthy(operand), nil
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateCompare(compareNode *actionlint.CompareOpNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateCompare(compareNode *actionlint.CompareOpNode) (interface{}, error) {
|
||||
left, err := impl.evaluateNode(compareNode.Left)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -379,7 +350,7 @@ func (impl *interperterImpl) evaluateCompare(compareNode *actionlint.CompareOpNo
|
|||
return impl.compareValues(leftValue, rightValue, compareNode.Kind)
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) compareValues(leftValue, rightValue reflect.Value, kind actionlint.CompareOpNodeKind) (any, error) {
|
||||
func (impl *interperterImpl) compareValues(leftValue, rightValue reflect.Value, kind actionlint.CompareOpNodeKind) (interface{}, error) {
|
||||
if leftValue.Kind() != rightValue.Kind() {
|
||||
if !impl.isNumber(leftValue) {
|
||||
leftValue = impl.coerceToNumber(leftValue)
|
||||
|
|
@ -529,7 +500,7 @@ func (impl *interperterImpl) compareNumber(left, right float64, kind actionlint.
|
|||
}
|
||||
}
|
||||
|
||||
func IsTruthy(input any) bool {
|
||||
func IsTruthy(input interface{}) bool {
|
||||
value := reflect.ValueOf(input)
|
||||
switch value.Kind() {
|
||||
case reflect.Bool:
|
||||
|
|
@ -565,7 +536,7 @@ func (impl *interperterImpl) isNumber(value reflect.Value) bool {
|
|||
}
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) getSafeValue(value reflect.Value) any {
|
||||
func (impl *interperterImpl) getSafeValue(value reflect.Value) interface{} {
|
||||
switch value.Kind() {
|
||||
case reflect.Invalid:
|
||||
return nil
|
||||
|
|
@ -579,7 +550,7 @@ func (impl *interperterImpl) getSafeValue(value reflect.Value) any {
|
|||
return value.Interface()
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateLogicalCompare(compareNode *actionlint.LogicalOpNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateLogicalCompare(compareNode *actionlint.LogicalOpNode) (interface{}, error) {
|
||||
left, err := impl.evaluateNode(compareNode.Left)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -608,7 +579,7 @@ func (impl *interperterImpl) evaluateLogicalCompare(compareNode *actionlint.Logi
|
|||
return nil, fmt.Errorf("Unable to compare incompatibles types '%s' and '%s'", leftValue.Kind(), rightValue.Kind())
|
||||
}
|
||||
|
||||
func (impl *interperterImpl) evaluateFuncCall(funcCallNode *actionlint.FuncCallNode) (any, error) {
|
||||
func (impl *interperterImpl) evaluateFuncCall(funcCallNode *actionlint.FuncCallNode) (interface{}, error) {
|
||||
args := make([]reflect.Value, 0)
|
||||
|
||||
for _, arg := range funcCallNode.Args {
|
||||
|
|
|
|||
|
|
@ -4,14 +4,14 @@ import (
|
|||
"math"
|
||||
"testing"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestLiterals(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"true", true, "true"},
|
||||
|
|
@ -40,7 +40,7 @@ func TestLiterals(t *testing.T) {
|
|||
func TestOperators(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
error string
|
||||
}{
|
||||
|
|
@ -68,7 +68,7 @@ func TestOperators(t *testing.T) {
|
|||
{`true && false`, false, "and", ""},
|
||||
{`true || false`, true, "or", ""},
|
||||
{`fromJSON('{}') && true`, true, "and-boolean-object", ""},
|
||||
{`fromJSON('{}') || false`, make(map[string]any), "or-boolean-object", ""},
|
||||
{`fromJSON('{}') || false`, make(map[string]interface{}), "or-boolean-object", ""},
|
||||
{"github.event.commits[0].author.username != github.event.commits[1].author.username", true, "property-comparison1", ""},
|
||||
{"github.event.commits[0].author.username1 != github.event.commits[1].author.username", true, "property-comparison2", ""},
|
||||
{"github.event.commits[0].author.username != github.event.commits[1].author.username1", true, "property-comparison3", ""},
|
||||
|
|
@ -79,15 +79,15 @@ func TestOperators(t *testing.T) {
|
|||
env := &EvaluationEnvironment{
|
||||
Github: &model.GithubContext{
|
||||
Action: "push",
|
||||
Event: map[string]any{
|
||||
"commits": []any{
|
||||
map[string]any{
|
||||
"author": map[string]any{
|
||||
Event: map[string]interface{}{
|
||||
"commits": []interface{}{
|
||||
map[string]interface{}{
|
||||
"author": map[string]interface{}{
|
||||
"username": "someone",
|
||||
},
|
||||
},
|
||||
map[string]any{
|
||||
"author": map[string]any{
|
||||
map[string]interface{}{
|
||||
"author": map[string]interface{}{
|
||||
"username": "someone-else",
|
||||
},
|
||||
},
|
||||
|
|
@ -114,7 +114,7 @@ func TestOperators(t *testing.T) {
|
|||
func TestOperatorsCompare(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"!null", true, "not-null"},
|
||||
|
|
@ -162,7 +162,7 @@ func TestOperatorsCompare(t *testing.T) {
|
|||
func TestOperatorsBooleanEvaluation(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
// true &&
|
||||
|
|
@ -529,7 +529,7 @@ func TestOperatorsBooleanEvaluation(t *testing.T) {
|
|||
func TestContexts(t *testing.T) {
|
||||
table := []struct {
|
||||
input string
|
||||
expected any
|
||||
expected interface{}
|
||||
name string
|
||||
}{
|
||||
{"github.action", "push", "github-context"},
|
||||
|
|
@ -562,8 +562,6 @@ func TestContexts(t *testing.T) {
|
|||
{"matrix.os", "Linux", "matrix-context"},
|
||||
{"needs.job-id.outputs.output-name", "value", "needs-context"},
|
||||
{"needs.job-id.result", "success", "needs-context"},
|
||||
{"contains(needs.*.result, 'success')", true, "needs-wildcard-context-contains-success"},
|
||||
{"contains(needs.*.result, 'failure')", false, "needs-wildcard-context-contains-failure"},
|
||||
{"inputs.name", "value", "inputs-context"},
|
||||
}
|
||||
|
||||
|
|
@ -588,7 +586,7 @@ func TestContexts(t *testing.T) {
|
|||
Conclusion: model.StepStatusSkipped,
|
||||
},
|
||||
},
|
||||
Runner: map[string]any{
|
||||
Runner: map[string]interface{}{
|
||||
"os": "Linux",
|
||||
"temp": "/tmp",
|
||||
"tool_cache": "/opt/hostedtoolcache",
|
||||
|
|
@ -599,10 +597,10 @@ func TestContexts(t *testing.T) {
|
|||
Vars: map[string]string{
|
||||
"name": "value",
|
||||
},
|
||||
Strategy: map[string]any{
|
||||
Strategy: map[string]interface{}{
|
||||
"fail-fast": true,
|
||||
},
|
||||
Matrix: map[string]any{
|
||||
Matrix: map[string]interface{}{
|
||||
"os": "Linux",
|
||||
},
|
||||
Needs: map[string]Needs{
|
||||
|
|
@ -612,14 +610,8 @@ func TestContexts(t *testing.T) {
|
|||
},
|
||||
Result: "success",
|
||||
},
|
||||
"another-job-id": {
|
||||
Outputs: map[string]string{
|
||||
"output-name": "value",
|
||||
},
|
||||
Result: "success",
|
||||
},
|
||||
},
|
||||
Inputs: map[string]any{
|
||||
Inputs: map[string]interface{}{
|
||||
"name": "value",
|
||||
},
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ package filecollector
|
|||
|
||||
import (
|
||||
"archive/tar"
|
||||
"context"
|
||||
"io"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
|
@ -26,7 +27,7 @@ func (mfs *memoryFs) walk(root string, fn filepath.WalkFunc) error {
|
|||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for i := range dir {
|
||||
for i := 0; i < len(dir); i++ {
|
||||
filename := filepath.Join(root, dir[i].Name())
|
||||
err = fn(filename, dir[i], nil)
|
||||
if dir[i].IsDir() {
|
||||
|
|
@ -103,7 +104,7 @@ func TestIgnoredTrackedfile(t *testing.T) {
|
|||
TarWriter: tw,
|
||||
},
|
||||
}
|
||||
err := fc.Fs.Walk("mygitrepo", fc.CollectFiles(t.Context(), []string{}))
|
||||
err := fc.Fs.Walk("mygitrepo", fc.CollectFiles(context.Background(), []string{}))
|
||||
assert.NoError(t, err, "successfully collect files")
|
||||
tw.Close()
|
||||
_, _ = tmpTar.Seek(0, io.SeekStart)
|
||||
|
|
@ -152,7 +153,7 @@ func TestSymlinks(t *testing.T) {
|
|||
TarWriter: tw,
|
||||
},
|
||||
}
|
||||
err = fc.Fs.Walk("mygitrepo", fc.CollectFiles(t.Context(), []string{}))
|
||||
err = fc.Fs.Walk("mygitrepo", fc.CollectFiles(context.Background(), []string{}))
|
||||
assert.NoError(t, err, "successfully collect files")
|
||||
tw.Close()
|
||||
_, _ = tmpTar.Seek(0, io.SeekStart)
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ import (
|
|||
"regexp"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/exprparser"
|
||||
"go.yaml.in/yaml/v3"
|
||||
"code.forgejo.org/forgejo/runner/act/exprparser"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// ExpressionEvaluator is copied from runner.expressionEvaluator,
|
||||
|
|
@ -19,7 +19,7 @@ func NewExpressionEvaluator(interpreter exprparser.Interpreter) *ExpressionEvalu
|
|||
return &ExpressionEvaluator{interpreter: interpreter}
|
||||
}
|
||||
|
||||
func (ee ExpressionEvaluator) evaluate(in string, defaultStatusCheck exprparser.DefaultStatusCheck) (any, error) {
|
||||
func (ee ExpressionEvaluator) evaluate(in string, defaultStatusCheck exprparser.DefaultStatusCheck) (interface{}, error) {
|
||||
evaluated, err := ee.interpreter.Evaluate(in, defaultStatusCheck)
|
||||
|
||||
return evaluated, err
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
package jobparser
|
||||
|
||||
import (
|
||||
"code.forgejo.org/forgejo/runner/v11/act/exprparser"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"go.yaml.in/yaml/v3"
|
||||
"code.forgejo.org/forgejo/runner/act/exprparser"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// NewInterpeter returns an interpeter used in the server,
|
||||
|
|
@ -12,13 +12,12 @@ import (
|
|||
func NewInterpeter(
|
||||
jobID string,
|
||||
job *model.Job,
|
||||
matrix map[string]any,
|
||||
matrix map[string]interface{},
|
||||
gitCtx *model.GithubContext,
|
||||
results map[string]*JobResult,
|
||||
vars map[string]string,
|
||||
inputs map[string]any,
|
||||
) exprparser.Interpreter {
|
||||
strategy := make(map[string]any)
|
||||
strategy := make(map[string]interface{})
|
||||
if job.Strategy != nil {
|
||||
strategy["fail-fast"] = job.Strategy.FailFast
|
||||
strategy["max-parallel"] = job.Strategy.MaxParallel
|
||||
|
|
@ -63,7 +62,7 @@ func NewInterpeter(
|
|||
Strategy: strategy,
|
||||
Matrix: matrix,
|
||||
Needs: using,
|
||||
Inputs: inputs,
|
||||
Inputs: nil, // not supported yet
|
||||
Vars: vars,
|
||||
}
|
||||
|
||||
|
|
@ -76,36 +75,6 @@ func NewInterpeter(
|
|||
return exprparser.NewInterpeter(ee, config)
|
||||
}
|
||||
|
||||
// Returns an interpeter used in the server in the context of workflow-level templates. Needs github, inputs, and vars
|
||||
// context only.
|
||||
func NewWorkflowInterpeter(
|
||||
gitCtx *model.GithubContext,
|
||||
vars map[string]string,
|
||||
inputs map[string]any,
|
||||
) exprparser.Interpreter {
|
||||
ee := &exprparser.EvaluationEnvironment{
|
||||
Github: gitCtx,
|
||||
Env: nil, // no need
|
||||
Job: nil, // no need
|
||||
Steps: nil, // no need
|
||||
Runner: nil, // no need
|
||||
Secrets: nil, // no need
|
||||
Strategy: nil, // no need
|
||||
Matrix: nil, // no need
|
||||
Needs: nil, // no need
|
||||
Inputs: inputs,
|
||||
Vars: vars,
|
||||
}
|
||||
|
||||
config := exprparser.Config{
|
||||
Run: nil,
|
||||
WorkingDir: "", // WorkingDir is used for the function hashFiles, but it's not needed in the server
|
||||
Context: "workflow",
|
||||
}
|
||||
|
||||
return exprparser.NewInterpeter(ee, config)
|
||||
}
|
||||
|
||||
// JobResult is the minimum requirement of job results for Interpeter
|
||||
type JobResult struct {
|
||||
Needs []string
|
||||
|
|
|
|||
|
|
@ -6,9 +6,9 @@ import (
|
|||
"sort"
|
||||
"strings"
|
||||
|
||||
"go.yaml.in/yaml/v3"
|
||||
"gopkg.in/yaml.v3"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
)
|
||||
|
||||
func Parse(content []byte, validate bool, options ...ParseOption) ([]*SingleWorkflow, error) {
|
||||
|
|
@ -48,7 +48,7 @@ func Parse(content []byte, validate bool, options ...ParseOption) ([]*SingleWork
|
|||
}
|
||||
for _, matrix := range matricxes {
|
||||
job := job.Clone()
|
||||
evaluator := NewExpressionEvaluator(NewInterpeter(id, origin.GetJob(id), matrix, pc.gitContext, results, pc.vars, nil))
|
||||
evaluator := NewExpressionEvaluator(NewInterpeter(id, origin.GetJob(id), matrix, pc.gitContext, results, pc.vars))
|
||||
if job.Name == "" {
|
||||
job.Name = nameWithMatrix(id, matrix)
|
||||
} else {
|
||||
|
|
@ -103,7 +103,7 @@ type parseContext struct {
|
|||
|
||||
type ParseOption func(c *parseContext)
|
||||
|
||||
func getMatrixes(job *model.Job) ([]map[string]any, error) {
|
||||
func getMatrixes(job *model.Job) ([]map[string]interface{}, error) {
|
||||
ret, err := job.GetMatrixes()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("GetMatrixes: %w", err)
|
||||
|
|
@ -114,13 +114,13 @@ func getMatrixes(job *model.Job) ([]map[string]any, error) {
|
|||
return ret, nil
|
||||
}
|
||||
|
||||
func encodeMatrix(matrix map[string]any) yaml.Node {
|
||||
func encodeMatrix(matrix map[string]interface{}) yaml.Node {
|
||||
if len(matrix) == 0 {
|
||||
return yaml.Node{}
|
||||
}
|
||||
value := map[string][]any{}
|
||||
value := map[string][]interface{}{}
|
||||
for k, v := range matrix {
|
||||
value[k] = []any{v}
|
||||
value[k] = []interface{}{v}
|
||||
}
|
||||
node := yaml.Node{}
|
||||
_ = node.Encode(value)
|
||||
|
|
@ -137,7 +137,7 @@ func encodeRunsOn(runsOn []string) yaml.Node {
|
|||
return node
|
||||
}
|
||||
|
||||
func nameWithMatrix(name string, m map[string]any) string {
|
||||
func nameWithMatrix(name string, m map[string]interface{}) string {
|
||||
if len(m) == 0 {
|
||||
return name
|
||||
}
|
||||
|
|
@ -145,7 +145,7 @@ func nameWithMatrix(name string, m map[string]any) string {
|
|||
return name + " " + matrixName(m)
|
||||
}
|
||||
|
||||
func matrixName(m map[string]any) string {
|
||||
func matrixName(m map[string]interface{}) string {
|
||||
ks := make([]string, 0, len(m))
|
||||
for k := range m {
|
||||
ks = append(ks, k)
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ import (
|
|||
|
||||
"github.com/stretchr/testify/require"
|
||||
|
||||
"go.yaml.in/yaml/v3"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
func TestParse(t *testing.T) {
|
||||
|
|
@ -42,16 +42,6 @@ func TestParse(t *testing.T) {
|
|||
options: nil,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "job_concurrency",
|
||||
options: nil,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "job_concurrency_eval",
|
||||
options: nil,
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
|
|
|
|||
|
|
@ -2,10 +2,9 @@ package jobparser
|
|||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"go.yaml.in/yaml/v3"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// SingleWorkflow is a workflow with single job and single matrix
|
||||
|
|
@ -81,9 +80,8 @@ type Job struct {
|
|||
Defaults Defaults `yaml:"defaults,omitempty"`
|
||||
Outputs map[string]string `yaml:"outputs,omitempty"`
|
||||
Uses string `yaml:"uses,omitempty"`
|
||||
With map[string]any `yaml:"with,omitempty"`
|
||||
With map[string]interface{} `yaml:"with,omitempty"`
|
||||
RawSecrets yaml.Node `yaml:"secrets,omitempty"`
|
||||
RawConcurrency *model.RawConcurrency `yaml:"concurrency,omitempty"`
|
||||
}
|
||||
|
||||
func (j *Job) Clone() *Job {
|
||||
|
|
@ -106,7 +104,6 @@ func (j *Job) Clone() *Job {
|
|||
Uses: j.Uses,
|
||||
With: j.With,
|
||||
RawSecrets: j.RawSecrets,
|
||||
RawConcurrency: j.RawConcurrency,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -193,63 +190,35 @@ func (evt *Event) Schedules() []map[string]string {
|
|||
return evt.schedules
|
||||
}
|
||||
|
||||
// Convert the raw YAML from the `concurrency` block on a workflow into the evaluated concurrency group and
|
||||
// cancel-in-progress value. This implementation only supports workflow-level concurrency definition, where we expect
|
||||
// expressions to be able to access only the github, inputs and vars contexts. If RawConcurrency is empty, then the
|
||||
// returned concurrency group will be "" and cancel-in-progress will be nil -- this can be used to distinguish from an
|
||||
// explicit cancel-in-progress choice even if a group isn't specified.
|
||||
func EvaluateWorkflowConcurrency(rc *model.RawConcurrency, gitCtx *model.GithubContext, vars map[string]string, inputs map[string]any) (string, *bool, error) {
|
||||
evaluator := NewExpressionEvaluator(NewWorkflowInterpeter(gitCtx, vars, inputs))
|
||||
var node yaml.Node
|
||||
if err := node.Encode(rc); err != nil {
|
||||
return "", nil, fmt.Errorf("failed to encode concurrency: %w", err)
|
||||
}
|
||||
if err := evaluator.EvaluateYamlNode(&node); err != nil {
|
||||
return "", nil, fmt.Errorf("failed to evaluate concurrency: %w", err)
|
||||
}
|
||||
var evaluated model.RawConcurrency
|
||||
if err := node.Decode(&evaluated); err != nil {
|
||||
return "", nil, fmt.Errorf("failed to unmarshal evaluated concurrency: %w", err)
|
||||
}
|
||||
if evaluated.RawExpression != "" {
|
||||
return evaluated.RawExpression, nil, nil
|
||||
}
|
||||
if evaluated.CancelInProgress == "" {
|
||||
return evaluated.Group, nil, nil
|
||||
}
|
||||
cancelInProgress := evaluated.CancelInProgress == "true"
|
||||
return evaluated.Group, &cancelInProgress, nil
|
||||
}
|
||||
|
||||
func ParseRawOn(rawOn *yaml.Node) ([]*Event, error) {
|
||||
switch rawOn.Kind {
|
||||
case yaml.ScalarNode:
|
||||
var val string
|
||||
err := rawOn.Decode(&val)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unable to interpret scalar value into a string: %w", err)
|
||||
return nil, err
|
||||
}
|
||||
return []*Event{
|
||||
{Name: val},
|
||||
}, nil
|
||||
case yaml.SequenceNode:
|
||||
var val []any
|
||||
var val []interface{}
|
||||
err := rawOn.Decode(&val)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
res := make([]*Event, 0, len(val))
|
||||
for i, v := range val {
|
||||
for _, v := range val {
|
||||
switch t := v.(type) {
|
||||
case string:
|
||||
res = append(res, &Event{Name: t})
|
||||
default:
|
||||
return nil, fmt.Errorf("value at index %d was unexpected type %[2]T; must be a string but was %#[2]v", i, v)
|
||||
return nil, fmt.Errorf("invalid type %T", t)
|
||||
}
|
||||
}
|
||||
return res, nil
|
||||
case yaml.MappingNode:
|
||||
events, triggers, err := parseMappingNode[any](rawOn)
|
||||
events, triggers, err := parseMappingNode[interface{}](rawOn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -264,7 +233,17 @@ func ParseRawOn(rawOn *yaml.Node) ([]*Event, error) {
|
|||
continue
|
||||
}
|
||||
switch t := v.(type) {
|
||||
case map[string]any:
|
||||
case string:
|
||||
res = append(res, &Event{
|
||||
Name: k,
|
||||
acts: map[string][]string{},
|
||||
})
|
||||
case []string:
|
||||
res = append(res, &Event{
|
||||
Name: k,
|
||||
acts: map[string][]string{},
|
||||
})
|
||||
case map[string]interface{}:
|
||||
acts := make(map[string][]string, len(t))
|
||||
for act, branches := range t {
|
||||
switch b := branches.(type) {
|
||||
|
|
@ -272,20 +251,20 @@ func ParseRawOn(rawOn *yaml.Node) ([]*Event, error) {
|
|||
acts[act] = []string{b}
|
||||
case []string:
|
||||
acts[act] = b
|
||||
case []any:
|
||||
case []interface{}:
|
||||
acts[act] = make([]string, len(b))
|
||||
for i, v := range b {
|
||||
var ok bool
|
||||
if acts[act][i], ok = v.(string); !ok {
|
||||
return nil, fmt.Errorf("key %q.%q index %d had unexpected type %[4]T; a string was expected but was %#[4]v", k, act, i, v)
|
||||
return nil, fmt.Errorf("unknown on type: %#v", branches)
|
||||
}
|
||||
}
|
||||
case map[string]any:
|
||||
if err := isInvalidOnType(k, act); err != nil {
|
||||
return nil, fmt.Errorf("invalid value on key %q: %w", k, err)
|
||||
case map[string]interface{}:
|
||||
if isInvalidOnType(k, act) {
|
||||
return nil, fmt.Errorf("unknown on type: %#v", v)
|
||||
}
|
||||
default:
|
||||
return nil, fmt.Errorf("key %q.%q had unexpected type %T; was %#v", k, act, branches, branches)
|
||||
return nil, fmt.Errorf("unknown on type: %#v", branches)
|
||||
}
|
||||
}
|
||||
if k == "workflow_dispatch" || k == "workflow_call" {
|
||||
|
|
@ -295,24 +274,21 @@ func ParseRawOn(rawOn *yaml.Node) ([]*Event, error) {
|
|||
Name: k,
|
||||
acts: acts,
|
||||
})
|
||||
case []any:
|
||||
case []interface{}:
|
||||
if k != "schedule" {
|
||||
return nil, fmt.Errorf("key %q had an type %T; only the 'schedule' key is expected with this type", k, v)
|
||||
return nil, fmt.Errorf("unknown on type: %#v", v)
|
||||
}
|
||||
schedules := make([]map[string]string, len(t))
|
||||
for i, tt := range t {
|
||||
vv, ok := tt.(map[string]any)
|
||||
vv, ok := tt.(map[string]interface{})
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("key %q[%d] had unexpected type %[3]T; a map with a key \"cron\" was expected, but value was %#[3]v", k, i, tt)
|
||||
return nil, fmt.Errorf("unknown on type: %#v", v)
|
||||
}
|
||||
schedules[i] = make(map[string]string, len(vv))
|
||||
for kk, vvv := range vv {
|
||||
if strings.ToLower(kk) != "cron" {
|
||||
return nil, fmt.Errorf("key %q[%d] had unexpected key %q; \"cron\" was expected", k, i, kk)
|
||||
}
|
||||
for k, vvv := range vv {
|
||||
var ok bool
|
||||
if schedules[i][kk], ok = vvv.(string); !ok {
|
||||
return nil, fmt.Errorf("key %q[%d].%q had unexpected type %[4]T; a string was expected by was %#[4]v", k, i, kk, vvv)
|
||||
if schedules[i][k], ok = vvv.(string); !ok {
|
||||
return nil, fmt.Errorf("unknown on type: %#v", v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -321,29 +297,23 @@ func ParseRawOn(rawOn *yaml.Node) ([]*Event, error) {
|
|||
schedules: schedules,
|
||||
})
|
||||
default:
|
||||
return nil, fmt.Errorf("key %q had unexpected type %[2]T; expected a map or array but was %#[2]v", k, v)
|
||||
return nil, fmt.Errorf("unknown on type: %#v", v)
|
||||
}
|
||||
}
|
||||
return res, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("unexpected yaml node in `on`: %v", rawOn.Kind)
|
||||
return nil, fmt.Errorf("unknown on type: %v", rawOn.Kind)
|
||||
}
|
||||
}
|
||||
|
||||
func isInvalidOnType(onType, subKey string) error {
|
||||
if onType == "workflow_dispatch" {
|
||||
if subKey == "inputs" {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("workflow_dispatch only supports key \"inputs\", but key %q was found", subKey)
|
||||
func isInvalidOnType(onType, subKey string) bool {
|
||||
if onType == "workflow_dispatch" && subKey == "inputs" {
|
||||
return false
|
||||
}
|
||||
if onType == "workflow_call" {
|
||||
if subKey == "inputs" || subKey == "outputs" {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("workflow_call only supports keys \"inputs\" and \"outputs\", but key %q was found", subKey)
|
||||
if onType == "workflow_call" && (subKey == "inputs" || subKey == "outputs") {
|
||||
return false
|
||||
}
|
||||
return fmt.Errorf("unexpected key %q.%q", onType, subKey)
|
||||
return true
|
||||
}
|
||||
|
||||
// parseMappingNode parse a mapping node and preserve order.
|
||||
|
|
|
|||
|
|
@ -5,18 +5,17 @@ import (
|
|||
"strings"
|
||||
"testing"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"go.yaml.in/yaml/v3"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
func TestParseRawOn(t *testing.T) {
|
||||
kases := []struct {
|
||||
input string
|
||||
result []*Event
|
||||
err string
|
||||
}{
|
||||
{
|
||||
input: "on: issue_comment",
|
||||
|
|
@ -34,10 +33,7 @@ func TestParseRawOn(t *testing.T) {
|
|||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on: [123]",
|
||||
err: "value at index 0 was unexpected type int; must be a string but was 123",
|
||||
},
|
||||
|
||||
{
|
||||
input: "on:\n - push\n - pull_request",
|
||||
result: []*Event{
|
||||
|
|
@ -49,19 +45,6 @@ func TestParseRawOn(t *testing.T) {
|
|||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on: { push: null }",
|
||||
result: []*Event{
|
||||
{
|
||||
Name: "push",
|
||||
acts: map[string][]string{},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on: { push: 'abc' }",
|
||||
err: "key \"push\" had unexpected type string; expected a map or array but was \"abc\"",
|
||||
},
|
||||
{
|
||||
input: "on:\n push:\n branches:\n - master",
|
||||
result: []*Event{
|
||||
|
|
@ -89,10 +72,6 @@ func TestParseRawOn(t *testing.T) {
|
|||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on:\n branch_protection_rule:\n types: [123, deleted]",
|
||||
err: "key \"branch_protection_rule\".\"types\" index 0 had unexpected type int; a string was expected but was 123",
|
||||
},
|
||||
{
|
||||
input: "on:\n project:\n types: [created, deleted]\n milestone:\n types: [opened, deleted]",
|
||||
result: []*Event{
|
||||
|
|
@ -210,22 +189,6 @@ func TestParseRawOn(t *testing.T) {
|
|||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on:\n schedule2:\n - cron: '20 6 * * *'",
|
||||
err: "key \"schedule2\" had an type []interface {}; only the 'schedule' key is expected with this type",
|
||||
},
|
||||
{
|
||||
input: "on:\n schedule:\n - 123",
|
||||
err: "key \"schedule\"[0] had unexpected type int; a map with a key \"cron\" was expected, but value was 123",
|
||||
},
|
||||
{
|
||||
input: "on:\n schedule:\n - corn: '20 6 * * *'",
|
||||
err: "key \"schedule\"[0] had unexpected key \"corn\"; \"cron\" was expected",
|
||||
},
|
||||
{
|
||||
input: "on:\n schedule:\n - cron: 123",
|
||||
err: "key \"schedule\"[0].\"cron\" had unexpected type int; a string was expected by was 123",
|
||||
},
|
||||
{
|
||||
input: `
|
||||
on:
|
||||
|
|
@ -259,37 +222,15 @@ on:
|
|||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: `
|
||||
on:
|
||||
workflow_call:
|
||||
mistake:
|
||||
access-token:
|
||||
description: 'A token passed from the caller workflow'
|
||||
required: false
|
||||
`,
|
||||
err: "invalid value on key \"workflow_call\": workflow_call only supports keys \"inputs\" and \"outputs\", but key \"mistake\" was found",
|
||||
},
|
||||
{
|
||||
input: `
|
||||
on:
|
||||
workflow_call: { map: 123 }
|
||||
`,
|
||||
err: "key \"workflow_call\".\"map\" had unexpected type int; was 123",
|
||||
},
|
||||
}
|
||||
for _, kase := range kases {
|
||||
t.Run(kase.input, func(t *testing.T) {
|
||||
origin, err := model.ReadWorkflow(strings.NewReader(kase.input), false)
|
||||
require.NoError(t, err)
|
||||
assert.NoError(t, err)
|
||||
|
||||
events, err := ParseRawOn(&origin.RawOn)
|
||||
if kase.err != "" {
|
||||
assert.ErrorContains(t, err, kase.err)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, kase.result, events, fmt.Sprintf("%#v", events))
|
||||
}
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, kase.result, events, fmt.Sprintf("%#v", events))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -320,66 +261,66 @@ func TestParseMappingNode(t *testing.T) {
|
|||
tests := []struct {
|
||||
input string
|
||||
scalars []string
|
||||
datas []any
|
||||
datas []interface{}
|
||||
}{
|
||||
{
|
||||
input: "on:\n push:\n branches:\n - master",
|
||||
scalars: []string{"push"},
|
||||
datas: []any{
|
||||
map[string]any{
|
||||
"branches": []any{"master"},
|
||||
datas: []interface{}{
|
||||
map[string]interface{}{
|
||||
"branches": []interface{}{"master"},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on:\n branch_protection_rule:\n types: [created, deleted]",
|
||||
scalars: []string{"branch_protection_rule"},
|
||||
datas: []any{
|
||||
map[string]any{
|
||||
"types": []any{"created", "deleted"},
|
||||
datas: []interface{}{
|
||||
map[string]interface{}{
|
||||
"types": []interface{}{"created", "deleted"},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on:\n project:\n types: [created, deleted]\n milestone:\n types: [opened, deleted]",
|
||||
scalars: []string{"project", "milestone"},
|
||||
datas: []any{
|
||||
map[string]any{
|
||||
"types": []any{"created", "deleted"},
|
||||
datas: []interface{}{
|
||||
map[string]interface{}{
|
||||
"types": []interface{}{"created", "deleted"},
|
||||
},
|
||||
map[string]any{
|
||||
"types": []any{"opened", "deleted"},
|
||||
map[string]interface{}{
|
||||
"types": []interface{}{"opened", "deleted"},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on:\n pull_request:\n types:\n - opened\n branches:\n - 'releases/**'",
|
||||
scalars: []string{"pull_request"},
|
||||
datas: []any{
|
||||
map[string]any{
|
||||
"types": []any{"opened"},
|
||||
"branches": []any{"releases/**"},
|
||||
datas: []interface{}{
|
||||
map[string]interface{}{
|
||||
"types": []interface{}{"opened"},
|
||||
"branches": []interface{}{"releases/**"},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on:\n push:\n branches:\n - main\n pull_request:\n types:\n - opened\n branches:\n - '**'",
|
||||
scalars: []string{"push", "pull_request"},
|
||||
datas: []any{
|
||||
map[string]any{
|
||||
"branches": []any{"main"},
|
||||
datas: []interface{}{
|
||||
map[string]interface{}{
|
||||
"branches": []interface{}{"main"},
|
||||
},
|
||||
map[string]any{
|
||||
"types": []any{"opened"},
|
||||
"branches": []any{"**"},
|
||||
map[string]interface{}{
|
||||
"types": []interface{}{"opened"},
|
||||
"branches": []interface{}{"**"},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: "on:\n schedule:\n - cron: '20 6 * * *'",
|
||||
scalars: []string{"schedule"},
|
||||
datas: []any{
|
||||
[]any{map[string]any{
|
||||
datas: []interface{}{
|
||||
[]interface{}{map[string]interface{}{
|
||||
"cron": "20 6 * * *",
|
||||
}},
|
||||
},
|
||||
|
|
@ -391,137 +332,10 @@ func TestParseMappingNode(t *testing.T) {
|
|||
workflow, err := model.ReadWorkflow(strings.NewReader(test.input), false)
|
||||
assert.NoError(t, err)
|
||||
|
||||
scalars, datas, err := parseMappingNode[any](&workflow.RawOn)
|
||||
scalars, datas, err := parseMappingNode[interface{}](&workflow.RawOn)
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, test.scalars, scalars, fmt.Sprintf("%#v", scalars))
|
||||
assert.EqualValues(t, test.datas, datas, fmt.Sprintf("%#v", datas))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEvaluateConcurrency(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
input model.RawConcurrency
|
||||
group string
|
||||
cancelInProgressNil bool
|
||||
cancelInProgress bool
|
||||
}{
|
||||
{
|
||||
name: "basic",
|
||||
input: model.RawConcurrency{
|
||||
Group: "group-name",
|
||||
CancelInProgress: "true",
|
||||
},
|
||||
group: "group-name",
|
||||
cancelInProgress: true,
|
||||
},
|
||||
{
|
||||
name: "undefined",
|
||||
input: model.RawConcurrency{},
|
||||
group: "",
|
||||
cancelInProgressNil: true,
|
||||
},
|
||||
{
|
||||
name: "group-evaluation",
|
||||
input: model.RawConcurrency{
|
||||
Group: "${{ github.workflow }}-${{ github.ref }}",
|
||||
},
|
||||
group: "test_workflow-main",
|
||||
cancelInProgressNil: true,
|
||||
},
|
||||
{
|
||||
name: "cancel-evaluation-true",
|
||||
input: model.RawConcurrency{
|
||||
Group: "group-name",
|
||||
CancelInProgress: "${{ !contains(github.ref, 'release/')}}",
|
||||
},
|
||||
group: "group-name",
|
||||
cancelInProgress: true,
|
||||
},
|
||||
{
|
||||
name: "cancel-evaluation-false",
|
||||
input: model.RawConcurrency{
|
||||
Group: "group-name",
|
||||
CancelInProgress: "${{ contains(github.ref, 'release/')}}",
|
||||
},
|
||||
group: "group-name",
|
||||
cancelInProgress: false,
|
||||
},
|
||||
{
|
||||
name: "event-evaluation",
|
||||
input: model.RawConcurrency{
|
||||
Group: "user-${{ github.event.commits[0].author.username }}",
|
||||
},
|
||||
group: "user-someone",
|
||||
cancelInProgressNil: true,
|
||||
},
|
||||
{
|
||||
name: "arbitrary-var",
|
||||
input: model.RawConcurrency{
|
||||
Group: "${{ vars.eval_arbitrary_var }}",
|
||||
},
|
||||
group: "123",
|
||||
cancelInProgressNil: true,
|
||||
},
|
||||
{
|
||||
name: "arbitrary-input",
|
||||
input: model.RawConcurrency{
|
||||
Group: "${{ inputs.eval_arbitrary_input }}",
|
||||
},
|
||||
group: "456",
|
||||
cancelInProgressNil: true,
|
||||
},
|
||||
{
|
||||
name: "cancel-in-progress-only",
|
||||
input: model.RawConcurrency{
|
||||
CancelInProgress: "true",
|
||||
},
|
||||
group: "",
|
||||
cancelInProgress: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
group, cancelInProgress, err := EvaluateWorkflowConcurrency(
|
||||
&test.input,
|
||||
// gitCtx
|
||||
&model.GithubContext{
|
||||
Workflow: "test_workflow",
|
||||
Ref: "main",
|
||||
Event: map[string]any{
|
||||
"commits": []any{
|
||||
map[string]any{
|
||||
"author": map[string]any{
|
||||
"username": "someone",
|
||||
},
|
||||
},
|
||||
map[string]any{
|
||||
"author": map[string]any{
|
||||
"username": "someone-else",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
// vars
|
||||
map[string]string{
|
||||
"eval_arbitrary_var": "123",
|
||||
},
|
||||
// inputs
|
||||
map[string]any{
|
||||
"eval_arbitrary_input": "456",
|
||||
},
|
||||
)
|
||||
assert.NoError(t, err)
|
||||
assert.EqualValues(t, test.group, group)
|
||||
if test.cancelInProgressNil {
|
||||
assert.Nil(t, cancelInProgress)
|
||||
} else {
|
||||
require.NotNil(t, cancelInProgress)
|
||||
assert.EqualValues(t, test.cancelInProgress, *cancelInProgress)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +0,0 @@
|
|||
name: test
|
||||
jobs:
|
||||
job1:
|
||||
runs-on: linux
|
||||
concurrency:
|
||||
group: major-tests
|
||||
cancel-in-progress: true
|
||||
steps:
|
||||
- run: uname -a
|
||||
10
act/jobparser/testdata/job_concurrency.out.yaml
vendored
10
act/jobparser/testdata/job_concurrency.out.yaml
vendored
|
|
@ -1,10 +0,0 @@
|
|||
name: test
|
||||
jobs:
|
||||
job1:
|
||||
name: job1
|
||||
runs-on: linux
|
||||
steps:
|
||||
- run: uname -a
|
||||
concurrency:
|
||||
group: major-tests
|
||||
cancel-in-progress: "true"
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
name: test
|
||||
jobs:
|
||||
job1:
|
||||
runs-on: linux
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}
|
||||
cancel-in-progress: ${{ !contains(github.ref, 'release/')}}
|
||||
steps:
|
||||
- run: uname -a
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
name: test
|
||||
jobs:
|
||||
job1:
|
||||
name: job1
|
||||
runs-on: linux
|
||||
steps:
|
||||
- run: uname -a
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}
|
||||
cancel-in-progress: ${{ !contains(github.ref, 'release/')}}
|
||||
|
|
@ -6,7 +6,7 @@ import (
|
|||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
|
|
|||
|
|
@ -5,14 +5,14 @@ import (
|
|||
"io"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/schema"
|
||||
"go.yaml.in/yaml/v3"
|
||||
"code.forgejo.org/forgejo/runner/act/schema"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// ActionRunsUsing is the type of runner for the action
|
||||
type ActionRunsUsing string
|
||||
|
||||
func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(any) error) error {
|
||||
func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var using string
|
||||
if err := unmarshal(&using); err != nil {
|
||||
return err
|
||||
|
|
@ -21,7 +21,7 @@ func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(any) error) error {
|
|||
// Force input to lowercase for case insensitive comparison
|
||||
format := ActionRunsUsing(strings.ToLower(using))
|
||||
switch format {
|
||||
case ActionRunsUsingNode24, ActionRunsUsingNode20, ActionRunsUsingNode16, ActionRunsUsingNode12, ActionRunsUsingDocker, ActionRunsUsingComposite, ActionRunsUsingGo, ActionRunsUsingSh:
|
||||
case ActionRunsUsingNode20, ActionRunsUsingNode16, ActionRunsUsingNode12, ActionRunsUsingDocker, ActionRunsUsingComposite, ActionRunsUsingGo, ActionRunsUsingSh:
|
||||
*a = format
|
||||
default:
|
||||
return fmt.Errorf("The runs.using key in action.yml must be one of: %v, got %s", []string{
|
||||
|
|
@ -30,7 +30,6 @@ func (a *ActionRunsUsing) UnmarshalYAML(unmarshal func(any) error) error {
|
|||
ActionRunsUsingNode12,
|
||||
ActionRunsUsingNode16,
|
||||
ActionRunsUsingNode20,
|
||||
ActionRunsUsingNode24,
|
||||
ActionRunsUsingGo,
|
||||
ActionRunsUsingSh,
|
||||
}, format)
|
||||
|
|
@ -45,8 +44,6 @@ const (
|
|||
ActionRunsUsingNode16 = "node16"
|
||||
// ActionRunsUsingNode20 for running with node20
|
||||
ActionRunsUsingNode20 = "node20"
|
||||
// ActionRunsUsingNode24 for running with node24
|
||||
ActionRunsUsingNode24 = "node24"
|
||||
// ActionRunsUsingDocker for running with docker
|
||||
ActionRunsUsingDocker = "docker"
|
||||
// ActionRunsUsingComposite for running composite
|
||||
|
|
@ -72,22 +69,6 @@ type ActionRuns struct {
|
|||
Steps []Step `yaml:"steps"`
|
||||
}
|
||||
|
||||
func (actionRuns *ActionRuns) UnmarshalYAML(value *yaml.Node) error {
|
||||
type ActionRunsDefault ActionRuns
|
||||
if err := value.Decode((*ActionRunsDefault)(actionRuns)); err != nil {
|
||||
return err
|
||||
}
|
||||
for i := range actionRuns.Steps {
|
||||
step := &actionRuns.Steps[i]
|
||||
// Set `Number` and `ID` on each step based upon their position in the steps array:
|
||||
if step.ID == "" {
|
||||
step.ID = fmt.Sprintf("%d", i)
|
||||
}
|
||||
step.Number = i
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Action describes a metadata file for GitHub actions. The metadata filename must be either action.yml or action.yaml. The data in the metadata file defines the inputs, outputs and main entrypoint for your action.
|
||||
type Action struct {
|
||||
Name string `yaml:"name"`
|
||||
|
|
|
|||
|
|
@ -5,44 +5,43 @@ import (
|
|||
"fmt"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common/git"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common/git"
|
||||
)
|
||||
|
||||
type GithubContext struct {
|
||||
Event map[string]any `json:"event"`
|
||||
EventPath string `json:"event_path"`
|
||||
Workflow string `json:"workflow"`
|
||||
RunAttempt string `json:"run_attempt"`
|
||||
RunID string `json:"run_id"`
|
||||
RunNumber string `json:"run_number"`
|
||||
Actor string `json:"actor"`
|
||||
Repository string `json:"repository"`
|
||||
EventName string `json:"event_name"`
|
||||
Sha string `json:"sha"`
|
||||
Ref string `json:"ref"`
|
||||
RefName string `json:"ref_name"`
|
||||
RefType string `json:"ref_type"`
|
||||
HeadRef string `json:"head_ref"`
|
||||
BaseRef string `json:"base_ref"`
|
||||
Token string `json:"token"`
|
||||
Workspace string `json:"workspace"`
|
||||
Action string `json:"action"`
|
||||
ActionPath string `json:"action_path"`
|
||||
ActionRef string `json:"action_ref"`
|
||||
ActionRepository string `json:"action_repository"`
|
||||
Job string `json:"job"`
|
||||
JobName string `json:"job_name"`
|
||||
RepositoryOwner string `json:"repository_owner"`
|
||||
RetentionDays string `json:"retention_days"`
|
||||
RunnerPerflog string `json:"runner_perflog"`
|
||||
RunnerTrackingID string `json:"runner_tracking_id"`
|
||||
ServerURL string `json:"server_url"`
|
||||
APIURL string `json:"api_url"`
|
||||
GraphQLURL string `json:"graphql_url"`
|
||||
Event map[string]interface{} `json:"event"`
|
||||
EventPath string `json:"event_path"`
|
||||
Workflow string `json:"workflow"`
|
||||
RunID string `json:"run_id"`
|
||||
RunNumber string `json:"run_number"`
|
||||
Actor string `json:"actor"`
|
||||
Repository string `json:"repository"`
|
||||
EventName string `json:"event_name"`
|
||||
Sha string `json:"sha"`
|
||||
Ref string `json:"ref"`
|
||||
RefName string `json:"ref_name"`
|
||||
RefType string `json:"ref_type"`
|
||||
HeadRef string `json:"head_ref"`
|
||||
BaseRef string `json:"base_ref"`
|
||||
Token string `json:"token"`
|
||||
Workspace string `json:"workspace"`
|
||||
Action string `json:"action"`
|
||||
ActionPath string `json:"action_path"`
|
||||
ActionRef string `json:"action_ref"`
|
||||
ActionRepository string `json:"action_repository"`
|
||||
Job string `json:"job"`
|
||||
JobName string `json:"job_name"`
|
||||
RepositoryOwner string `json:"repository_owner"`
|
||||
RetentionDays string `json:"retention_days"`
|
||||
RunnerPerflog string `json:"runner_perflog"`
|
||||
RunnerTrackingID string `json:"runner_tracking_id"`
|
||||
ServerURL string `json:"server_url"`
|
||||
APIURL string `json:"api_url"`
|
||||
GraphQLURL string `json:"graphql_url"`
|
||||
}
|
||||
|
||||
func asString(v any) string {
|
||||
func asString(v interface{}) string {
|
||||
if v == nil {
|
||||
return ""
|
||||
} else if s, ok := v.(string); ok {
|
||||
|
|
@ -51,7 +50,7 @@ func asString(v any) string {
|
|||
return ""
|
||||
}
|
||||
|
||||
func nestedMapLookup(m map[string]any, ks ...string) (rval any) {
|
||||
func nestedMapLookup(m map[string]interface{}, ks ...string) (rval interface{}) {
|
||||
var ok bool
|
||||
|
||||
if len(ks) == 0 { // degenerate input
|
||||
|
|
@ -61,20 +60,20 @@ func nestedMapLookup(m map[string]any, ks ...string) (rval any) {
|
|||
return nil
|
||||
} else if len(ks) == 1 { // we've reached the final key
|
||||
return rval
|
||||
} else if m, ok = rval.(map[string]any); !ok {
|
||||
} else if m, ok = rval.(map[string]interface{}); !ok {
|
||||
return nil
|
||||
}
|
||||
// 1+ more keys
|
||||
return nestedMapLookup(m, ks[1:]...)
|
||||
}
|
||||
|
||||
func withDefaultBranch(ctx context.Context, b string, event map[string]any) map[string]any {
|
||||
func withDefaultBranch(ctx context.Context, b string, event map[string]interface{}) map[string]interface{} {
|
||||
repoI, ok := event["repository"]
|
||||
if !ok {
|
||||
repoI = make(map[string]any)
|
||||
repoI = make(map[string]interface{})
|
||||
}
|
||||
|
||||
repo, ok := repoI.(map[string]any)
|
||||
repo, ok := repoI.(map[string]interface{})
|
||||
if !ok {
|
||||
common.Logger(ctx).Warnf("unable to set default branch to %v", b)
|
||||
return event
|
||||
|
|
@ -171,7 +170,7 @@ func (ghc *GithubContext) SetRepositoryAndOwner(ctx context.Context, githubInsta
|
|||
if ghc.Repository == "" {
|
||||
repo, err := git.FindGithubRepo(ctx, repoPath, githubInstance, remoteName)
|
||||
if err != nil {
|
||||
common.Logger(ctx).Debugf("unable to get git repo (githubInstance: %v; remoteName: %v, repoPath: %v): %v", githubInstance, remoteName, repoPath, err)
|
||||
common.Logger(ctx).Warningf("unable to get git repo (githubInstance: %v; remoteName: %v, repoPath: %v): %v", githubInstance, remoteName, repoPath, err)
|
||||
return
|
||||
}
|
||||
ghc.Repository = repo
|
||||
|
|
|
|||
|
|
@ -27,19 +27,19 @@ func TestSetRef(t *testing.T) {
|
|||
|
||||
tables := []struct {
|
||||
eventName string
|
||||
event map[string]any
|
||||
event map[string]interface{}
|
||||
ref string
|
||||
refName string
|
||||
}{
|
||||
{
|
||||
eventName: "pull_request_target",
|
||||
event: map[string]any{},
|
||||
event: map[string]interface{}{},
|
||||
ref: "refs/heads/master",
|
||||
refName: "master",
|
||||
},
|
||||
{
|
||||
eventName: "pull_request",
|
||||
event: map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"number": 1234.,
|
||||
},
|
||||
ref: "refs/pull/1234/merge",
|
||||
|
|
@ -47,8 +47,8 @@ func TestSetRef(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "deployment",
|
||||
event: map[string]any{
|
||||
"deployment": map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"deployment": map[string]interface{}{
|
||||
"ref": "refs/heads/somebranch",
|
||||
},
|
||||
},
|
||||
|
|
@ -57,8 +57,8 @@ func TestSetRef(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "release",
|
||||
event: map[string]any{
|
||||
"release": map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"release": map[string]interface{}{
|
||||
"tag_name": "v1.0.0",
|
||||
},
|
||||
},
|
||||
|
|
@ -67,7 +67,7 @@ func TestSetRef(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "push",
|
||||
event: map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"ref": "refs/heads/somebranch",
|
||||
},
|
||||
ref: "refs/heads/somebranch",
|
||||
|
|
@ -75,8 +75,8 @@ func TestSetRef(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "unknown",
|
||||
event: map[string]any{
|
||||
"repository": map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"repository": map[string]interface{}{
|
||||
"default_branch": "main",
|
||||
},
|
||||
},
|
||||
|
|
@ -85,7 +85,7 @@ func TestSetRef(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "no-event",
|
||||
event: map[string]any{},
|
||||
event: map[string]interface{}{},
|
||||
ref: "refs/heads/master",
|
||||
refName: "master",
|
||||
},
|
||||
|
|
@ -99,7 +99,7 @@ func TestSetRef(t *testing.T) {
|
|||
Event: table.event,
|
||||
}
|
||||
|
||||
ghc.SetRef(t.Context(), "main", "/some/dir")
|
||||
ghc.SetRef(context.Background(), "main", "/some/dir")
|
||||
ghc.SetRefTypeAndName()
|
||||
|
||||
assert.Equal(t, table.ref, ghc.Ref)
|
||||
|
|
@ -114,10 +114,10 @@ func TestSetRef(t *testing.T) {
|
|||
|
||||
ghc := &GithubContext{
|
||||
EventName: "no-default-branch",
|
||||
Event: map[string]any{},
|
||||
Event: map[string]interface{}{},
|
||||
}
|
||||
|
||||
ghc.SetRef(t.Context(), "", "/some/dir")
|
||||
ghc.SetRef(context.Background(), "", "/some/dir")
|
||||
|
||||
assert.Equal(t, "refs/heads/master", ghc.Ref)
|
||||
})
|
||||
|
|
@ -141,14 +141,14 @@ func TestSetSha(t *testing.T) {
|
|||
|
||||
tables := []struct {
|
||||
eventName string
|
||||
event map[string]any
|
||||
event map[string]interface{}
|
||||
sha string
|
||||
}{
|
||||
{
|
||||
eventName: "pull_request_target",
|
||||
event: map[string]any{
|
||||
"pull_request": map[string]any{
|
||||
"base": map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"pull_request": map[string]interface{}{
|
||||
"base": map[string]interface{}{
|
||||
"sha": "pr-base-sha",
|
||||
},
|
||||
},
|
||||
|
|
@ -157,15 +157,15 @@ func TestSetSha(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "pull_request",
|
||||
event: map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"number": 1234.,
|
||||
},
|
||||
sha: "1234fakesha",
|
||||
},
|
||||
{
|
||||
eventName: "deployment",
|
||||
event: map[string]any{
|
||||
"deployment": map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"deployment": map[string]interface{}{
|
||||
"sha": "deployment-sha",
|
||||
},
|
||||
},
|
||||
|
|
@ -173,12 +173,12 @@ func TestSetSha(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "release",
|
||||
event: map[string]any{},
|
||||
event: map[string]interface{}{},
|
||||
sha: "1234fakesha",
|
||||
},
|
||||
{
|
||||
eventName: "push",
|
||||
event: map[string]any{
|
||||
event: map[string]interface{}{
|
||||
"after": "push-sha",
|
||||
"deleted": false,
|
||||
},
|
||||
|
|
@ -186,12 +186,12 @@ func TestSetSha(t *testing.T) {
|
|||
},
|
||||
{
|
||||
eventName: "unknown",
|
||||
event: map[string]any{},
|
||||
event: map[string]interface{}{},
|
||||
sha: "1234fakesha",
|
||||
},
|
||||
{
|
||||
eventName: "no-event",
|
||||
event: map[string]any{},
|
||||
event: map[string]interface{}{},
|
||||
sha: "1234fakesha",
|
||||
},
|
||||
}
|
||||
|
|
@ -204,7 +204,7 @@ func TestSetSha(t *testing.T) {
|
|||
Event: table.event,
|
||||
}
|
||||
|
||||
ghc.SetSha(t.Context(), "/some/dir")
|
||||
ghc.SetSha(context.Background(), "/some/dir")
|
||||
|
||||
assert.Equal(t, table.sha, ghc.Sha)
|
||||
})
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ import (
|
|||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"slices"
|
||||
"sort"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
|
@ -286,8 +286,11 @@ func (wp *workflowPlanner) GetEvents() []string {
|
|||
for _, w := range wp.workflows {
|
||||
found := false
|
||||
for _, e := range events {
|
||||
if slices.Contains(w.On(), e) {
|
||||
found = true
|
||||
for _, we := range w.On() {
|
||||
if e == we {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if found {
|
||||
break
|
||||
|
|
@ -300,7 +303,9 @@ func (wp *workflowPlanner) GetEvents() []string {
|
|||
}
|
||||
|
||||
// sort the list based on depth of dependencies
|
||||
slices.Sort(events)
|
||||
sort.Slice(events, func(i, j int) bool {
|
||||
return events[i] < events[j]
|
||||
})
|
||||
|
||||
return events
|
||||
}
|
||||
|
|
@ -331,7 +336,7 @@ func (s *Stage) GetJobIDs() []string {
|
|||
// Merge stages with existing stages in plan
|
||||
func (p *Plan) mergeStages(stages []*Stage) {
|
||||
newStages := make([]*Stage, int(math.Max(float64(len(p.Stages)), float64(len(stages)))))
|
||||
for i := range newStages {
|
||||
for i := 0; i < len(newStages); i++ {
|
||||
newStages[i] = new(Stage)
|
||||
if i >= len(p.Stages) {
|
||||
newStages[i].Runs = append(newStages[i].Runs, stages[i].Runs...)
|
||||
|
|
|
|||
|
|
@ -4,19 +4,16 @@ import (
|
|||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"maps"
|
||||
"path/filepath"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"slices"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/schema"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/schema"
|
||||
log "github.com/sirupsen/logrus"
|
||||
"go.yaml.in/yaml/v3"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// Workflow is the structure of the files in .github/workflows
|
||||
|
|
@ -28,8 +25,7 @@ type Workflow struct {
|
|||
Jobs map[string]*Job `yaml:"jobs"`
|
||||
Defaults Defaults `yaml:"defaults"`
|
||||
|
||||
RawNotifications yaml.Node `yaml:"enable-email-notifications"`
|
||||
RawConcurrency *RawConcurrency `yaml:"concurrency"` // For Gitea
|
||||
RawNotifications yaml.Node `yaml:"enable-email-notifications"`
|
||||
}
|
||||
|
||||
// On events for the workflow
|
||||
|
|
@ -50,7 +46,7 @@ func (w *Workflow) On() []string {
|
|||
}
|
||||
return val
|
||||
case yaml.MappingNode:
|
||||
var val map[string]any
|
||||
var val map[string]interface{}
|
||||
err := w.RawOn.Decode(&val)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
|
|
@ -64,9 +60,9 @@ func (w *Workflow) On() []string {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (w *Workflow) OnEvent(event string) any {
|
||||
func (w *Workflow) OnEvent(event string) interface{} {
|
||||
if w.RawOn.Kind == yaml.MappingNode {
|
||||
var val map[string]any
|
||||
var val map[string]interface{}
|
||||
if !decodeNode(w.RawOn, &val) {
|
||||
return nil
|
||||
}
|
||||
|
|
@ -82,10 +78,10 @@ func (w *Workflow) OnSchedule() []string {
|
|||
}
|
||||
|
||||
switch val := schedules.(type) {
|
||||
case []any:
|
||||
case []interface{}:
|
||||
allSchedules := []string{}
|
||||
for _, v := range val {
|
||||
for k, cron := range v.(map[string]any) {
|
||||
for k, cron := range v.(map[string]interface{}) {
|
||||
if k != "cron" {
|
||||
continue
|
||||
}
|
||||
|
|
@ -140,8 +136,10 @@ func (w *Workflow) WorkflowDispatchConfig() *WorkflowDispatch {
|
|||
if !decodeNode(w.RawOn, &val) {
|
||||
return nil
|
||||
}
|
||||
if slices.Contains(val, "workflow_dispatch") {
|
||||
return &WorkflowDispatch{}
|
||||
for _, v := range val {
|
||||
if v == "workflow_dispatch" {
|
||||
return &WorkflowDispatch{}
|
||||
}
|
||||
}
|
||||
case yaml.MappingNode:
|
||||
var val map[string]yaml.Node
|
||||
|
|
@ -161,10 +159,10 @@ func (w *Workflow) WorkflowDispatchConfig() *WorkflowDispatch {
|
|||
}
|
||||
|
||||
type WorkflowCallInput struct {
|
||||
Description string `yaml:"description"`
|
||||
Required bool `yaml:"required"`
|
||||
Default yaml.Node `yaml:"default"`
|
||||
Type string `yaml:"type"`
|
||||
Description string `yaml:"description"`
|
||||
Required bool `yaml:"required"`
|
||||
Default string `yaml:"default"`
|
||||
Type string `yaml:"type"`
|
||||
}
|
||||
|
||||
type WorkflowCallOutput struct {
|
||||
|
|
@ -207,7 +205,7 @@ type Job struct {
|
|||
RawNeeds yaml.Node `yaml:"needs"`
|
||||
RawRunsOn yaml.Node `yaml:"runs-on"`
|
||||
Env yaml.Node `yaml:"env"`
|
||||
RawIf yaml.Node `yaml:"if"`
|
||||
If yaml.Node `yaml:"if"`
|
||||
Steps []*Step `yaml:"steps"`
|
||||
TimeoutMinutes string `yaml:"timeout-minutes"`
|
||||
Services map[string]*ContainerSpec `yaml:"services"`
|
||||
|
|
@ -216,11 +214,9 @@ type Job struct {
|
|||
Defaults Defaults `yaml:"defaults"`
|
||||
Outputs map[string]string `yaml:"outputs"`
|
||||
Uses string `yaml:"uses"`
|
||||
With map[string]any `yaml:"with"`
|
||||
With map[string]interface{} `yaml:"with"`
|
||||
RawSecrets yaml.Node `yaml:"secrets"`
|
||||
|
||||
Result string
|
||||
ResultMutex sync.Mutex
|
||||
Result string
|
||||
}
|
||||
|
||||
// Strategy for the job
|
||||
|
|
@ -339,21 +335,14 @@ func (j *Job) Needs() []string {
|
|||
|
||||
// RunsOn list for Job
|
||||
func (j *Job) RunsOn() []string {
|
||||
return FlattenRunsOnNode(j.RawRunsOn)
|
||||
}
|
||||
|
||||
// Given an already expression-evaluated `runs-on` yaml node from a job, compute all the labels that will be run for a
|
||||
// job. Can be a single string label, an array of labels, or an object { group: "...", labels: [...] };
|
||||
// FlattenRunsOnNode will flatten all the options down to a []string.
|
||||
func FlattenRunsOnNode(runsOn yaml.Node) []string {
|
||||
switch runsOn.Kind {
|
||||
switch j.RawRunsOn.Kind {
|
||||
case yaml.MappingNode:
|
||||
var val struct {
|
||||
Group string
|
||||
Labels yaml.Node
|
||||
}
|
||||
|
||||
if !decodeNode(runsOn, &val) {
|
||||
if !decodeNode(j.RawRunsOn, &val) {
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -365,17 +354,10 @@ func FlattenRunsOnNode(runsOn yaml.Node) []string {
|
|||
|
||||
return labels
|
||||
default:
|
||||
return nodeAsStringSlice(runsOn)
|
||||
return nodeAsStringSlice(j.RawRunsOn)
|
||||
}
|
||||
}
|
||||
|
||||
func (j *Job) IfClause() string {
|
||||
if j.RawIf.Value == "" {
|
||||
return "success()"
|
||||
}
|
||||
return j.RawIf.Value
|
||||
}
|
||||
|
||||
func nodeAsStringSlice(node yaml.Node) []string {
|
||||
switch node.Kind {
|
||||
case yaml.ScalarNode:
|
||||
|
|
@ -410,9 +392,9 @@ func (j *Job) Environment() map[string]string {
|
|||
}
|
||||
|
||||
// Matrix decodes RawMatrix YAML node
|
||||
func (j *Job) Matrix() map[string][]any {
|
||||
func (j *Job) Matrix() map[string][]interface{} {
|
||||
if j.Strategy.RawMatrix.Kind == yaml.MappingNode {
|
||||
var val map[string][]any
|
||||
var val map[string][]interface{}
|
||||
if !decodeNode(j.Strategy.RawMatrix, &val) {
|
||||
return nil
|
||||
}
|
||||
|
|
@ -423,20 +405,20 @@ func (j *Job) Matrix() map[string][]any {
|
|||
|
||||
// GetMatrixes returns the matrix cross product
|
||||
// It skips includes and hard fails excludes for non-existing keys
|
||||
func (j *Job) GetMatrixes() ([]map[string]any, error) {
|
||||
matrixes := make([]map[string]any, 0)
|
||||
func (j *Job) GetMatrixes() ([]map[string]interface{}, error) {
|
||||
matrixes := make([]map[string]interface{}, 0)
|
||||
if j.Strategy != nil {
|
||||
j.Strategy.FailFast = j.Strategy.GetFailFast()
|
||||
j.Strategy.MaxParallel = j.Strategy.GetMaxParallel()
|
||||
|
||||
if m := j.Matrix(); m != nil {
|
||||
includes := make([]map[string]any, 0)
|
||||
extraIncludes := make([]map[string]any, 0)
|
||||
includes := make([]map[string]interface{}, 0)
|
||||
extraIncludes := make([]map[string]interface{}, 0)
|
||||
for _, v := range m["include"] {
|
||||
switch t := v.(type) {
|
||||
case []any:
|
||||
case []interface{}:
|
||||
for _, i := range t {
|
||||
i := i.(map[string]any)
|
||||
i := i.(map[string]interface{})
|
||||
extraInclude := true
|
||||
for k := range i {
|
||||
if _, ok := m[k]; ok {
|
||||
|
|
@ -449,8 +431,8 @@ func (j *Job) GetMatrixes() ([]map[string]any, error) {
|
|||
extraIncludes = append(extraIncludes, i)
|
||||
}
|
||||
}
|
||||
case any:
|
||||
v := v.(map[string]any)
|
||||
case interface{}:
|
||||
v := v.(map[string]interface{})
|
||||
extraInclude := true
|
||||
for k := range v {
|
||||
if _, ok := m[k]; ok {
|
||||
|
|
@ -466,9 +448,9 @@ func (j *Job) GetMatrixes() ([]map[string]any, error) {
|
|||
}
|
||||
delete(m, "include")
|
||||
|
||||
excludes := make([]map[string]any, 0)
|
||||
excludes := make([]map[string]interface{}, 0)
|
||||
for _, e := range m["exclude"] {
|
||||
e := e.(map[string]any)
|
||||
e := e.(map[string]interface{})
|
||||
for k := range e {
|
||||
if _, ok := m[k]; ok {
|
||||
excludes = append(excludes, e)
|
||||
|
|
@ -497,7 +479,9 @@ func (j *Job) GetMatrixes() ([]map[string]any, error) {
|
|||
if commonKeysMatch2(matrix, include, m) {
|
||||
matched = true
|
||||
log.Debugf("Adding include values '%v' to existing entry", include)
|
||||
maps.Copy(matrix, include)
|
||||
for k, v := range include {
|
||||
matrix[k] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
if !matched {
|
||||
|
|
@ -509,19 +493,19 @@ func (j *Job) GetMatrixes() ([]map[string]any, error) {
|
|||
matrixes = append(matrixes, include)
|
||||
}
|
||||
if len(matrixes) == 0 {
|
||||
matrixes = append(matrixes, make(map[string]any))
|
||||
matrixes = append(matrixes, make(map[string]interface{}))
|
||||
}
|
||||
} else {
|
||||
matrixes = append(matrixes, make(map[string]any))
|
||||
matrixes = append(matrixes, make(map[string]interface{}))
|
||||
}
|
||||
} else {
|
||||
matrixes = append(matrixes, make(map[string]any))
|
||||
matrixes = append(matrixes, make(map[string]interface{}))
|
||||
log.Debugf("Empty Strategy, matrixes=%v", matrixes)
|
||||
}
|
||||
return matrixes, nil
|
||||
}
|
||||
|
||||
func commonKeysMatch(a, b map[string]any) bool {
|
||||
func commonKeysMatch(a, b map[string]interface{}) bool {
|
||||
for aKey, aVal := range a {
|
||||
if bVal, ok := b[aKey]; ok && !reflect.DeepEqual(aVal, bVal) {
|
||||
return false
|
||||
|
|
@ -530,7 +514,7 @@ func commonKeysMatch(a, b map[string]any) bool {
|
|||
return true
|
||||
}
|
||||
|
||||
func commonKeysMatch2(a, b map[string]any, m map[string][]any) bool {
|
||||
func commonKeysMatch2(a, b map[string]interface{}, m map[string][]interface{}) bool {
|
||||
for aKey, aVal := range a {
|
||||
_, useKey := m[aKey]
|
||||
if bVal, ok := b[aKey]; useKey && ok && !reflect.DeepEqual(aVal, bVal) {
|
||||
|
|
@ -594,24 +578,6 @@ func (j *Job) Type() (JobType, error) {
|
|||
return JobTypeDefault, nil
|
||||
}
|
||||
|
||||
func (j *Job) UnmarshalYAML(value *yaml.Node) error {
|
||||
type JobDefault Job
|
||||
if err := value.Decode((*JobDefault)(j)); err != nil {
|
||||
return err
|
||||
}
|
||||
for i, step := range j.Steps {
|
||||
if step == nil {
|
||||
continue
|
||||
}
|
||||
// Set `Number` and `ID` on each step based upon their position in the steps array:
|
||||
if step.ID == "" {
|
||||
step.ID = fmt.Sprintf("%d", i)
|
||||
}
|
||||
step.Number = i
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ContainerSpec is the specification of the container to use for the job
|
||||
type ContainerSpec struct {
|
||||
Image string `yaml:"image"`
|
||||
|
|
@ -638,7 +604,7 @@ type Step struct {
|
|||
Uses string `yaml:"uses"`
|
||||
Run string `yaml:"run"`
|
||||
WorkingDirectory string `yaml:"working-directory"`
|
||||
RawShell string `yaml:"shell"`
|
||||
Shell string `yaml:"shell"`
|
||||
Env yaml.Node `yaml:"env"`
|
||||
With map[string]string `yaml:"with"`
|
||||
RawContinueOnError string `yaml:"continue-on-error"`
|
||||
|
|
@ -674,6 +640,32 @@ func (s *Step) GetEnv() map[string]string {
|
|||
return env
|
||||
}
|
||||
|
||||
// ShellCommand returns the command for the shell
|
||||
func (s *Step) ShellCommand() string {
|
||||
var shellCommand string
|
||||
|
||||
// Reference: https://github.com/actions/runner/blob/8109c962f09d9acc473d92c595ff43afceddb347/src/Runner.Worker/Handlers/ScriptHandlerHelpers.cs#L9-L17
|
||||
switch s.Shell {
|
||||
case "", "bash":
|
||||
shellCommand = "bash --noprofile --norc -e -o pipefail {0}"
|
||||
case "pwsh":
|
||||
shellCommand = "pwsh -command . '{0}'"
|
||||
case "python":
|
||||
shellCommand = "python {0}"
|
||||
case "sh":
|
||||
shellCommand = "sh -e {0}"
|
||||
case "cmd":
|
||||
shellCommand = "cmd /D /E:ON /V:OFF /S /C \"CALL \"{0}\"\""
|
||||
case "powershell":
|
||||
shellCommand = "powershell -command . '{0}'"
|
||||
case "node":
|
||||
shellCommand = "node {0}"
|
||||
default:
|
||||
shellCommand = s.Shell
|
||||
}
|
||||
return shellCommand
|
||||
}
|
||||
|
||||
// StepType describes what type of step we are about to run
|
||||
type StepType int
|
||||
|
||||
|
|
@ -767,6 +759,9 @@ func (w *Workflow) GetJob(jobID string) *Job {
|
|||
if j.Name == "" {
|
||||
j.Name = id
|
||||
}
|
||||
if j.If.Value == "" {
|
||||
j.If.Value = "success()"
|
||||
}
|
||||
return j
|
||||
}
|
||||
}
|
||||
|
|
@ -782,11 +777,11 @@ func (w *Workflow) GetJobIDs() []string {
|
|||
return ids
|
||||
}
|
||||
|
||||
var OnDecodeNodeError = func(node yaml.Node, out any, err error) {
|
||||
var OnDecodeNodeError = func(node yaml.Node, out interface{}, err error) {
|
||||
log.Errorf("Failed to decode node %v into %T: %v", node, out, err)
|
||||
}
|
||||
|
||||
func decodeNode(node yaml.Node, out any) bool {
|
||||
func decodeNode(node yaml.Node, out interface{}) bool {
|
||||
if err := node.Decode(out); err != nil {
|
||||
if OnDecodeNodeError != nil {
|
||||
OnDecodeNodeError(node, out, err)
|
||||
|
|
@ -811,28 +806,3 @@ func (w *Workflow) Notifications() (bool, error) {
|
|||
return false, fmt.Errorf("enable-email-notifications: unknown type: %v", w.RawNotifications.Kind)
|
||||
}
|
||||
}
|
||||
|
||||
// For Gitea
|
||||
// RawConcurrency represents a workflow concurrency or a job concurrency with uninterpolated options
|
||||
type RawConcurrency struct {
|
||||
Group string `yaml:"group,omitempty"`
|
||||
CancelInProgress string `yaml:"cancel-in-progress,omitempty"`
|
||||
RawExpression string `yaml:"-,omitempty"`
|
||||
}
|
||||
|
||||
type objectConcurrency RawConcurrency
|
||||
|
||||
func (r *RawConcurrency) UnmarshalYAML(n *yaml.Node) error {
|
||||
if err := n.Decode(&r.RawExpression); err == nil {
|
||||
return nil
|
||||
}
|
||||
return n.Decode((*objectConcurrency)(r))
|
||||
}
|
||||
|
||||
func (r *RawConcurrency) MarshalYAML() (any, error) {
|
||||
if r.RawExpression != "" {
|
||||
return r.RawExpression, nil
|
||||
}
|
||||
|
||||
return (*objectConcurrency)(r), nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -493,24 +493,24 @@ func TestReadWorkflow_Strategy(t *testing.T) {
|
|||
job := wf.Jobs["strategy-only-max-parallel"]
|
||||
matrixes, err := job.GetMatrixes()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, matrixes, []map[string]any{{}})
|
||||
assert.Equal(t, job.Matrix(), map[string][]any(nil))
|
||||
assert.Equal(t, matrixes, []map[string]interface{}{{}})
|
||||
assert.Equal(t, job.Matrix(), map[string][]interface{}(nil))
|
||||
assert.Equal(t, job.Strategy.MaxParallel, 2)
|
||||
assert.Equal(t, job.Strategy.FailFast, true)
|
||||
|
||||
job = wf.Jobs["strategy-only-fail-fast"]
|
||||
matrixes, err = job.GetMatrixes()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, matrixes, []map[string]any{{}})
|
||||
assert.Equal(t, job.Matrix(), map[string][]any(nil))
|
||||
assert.Equal(t, matrixes, []map[string]interface{}{{}})
|
||||
assert.Equal(t, job.Matrix(), map[string][]interface{}(nil))
|
||||
assert.Equal(t, job.Strategy.MaxParallel, 4)
|
||||
assert.Equal(t, job.Strategy.FailFast, false)
|
||||
|
||||
job = wf.Jobs["strategy-no-matrix"]
|
||||
matrixes, err = job.GetMatrixes()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, matrixes, []map[string]any{{}})
|
||||
assert.Equal(t, job.Matrix(), map[string][]any(nil))
|
||||
assert.Equal(t, matrixes, []map[string]interface{}{{}})
|
||||
assert.Equal(t, job.Matrix(), map[string][]interface{}(nil))
|
||||
assert.Equal(t, job.Strategy.MaxParallel, 2)
|
||||
assert.Equal(t, job.Strategy.FailFast, false)
|
||||
|
||||
|
|
@ -518,7 +518,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
|
|||
matrixes, err = job.GetMatrixes()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, matrixes,
|
||||
[]map[string]any{
|
||||
[]map[string]interface{}{
|
||||
{"datacenter": "site-c", "node-version": "14.x", "site": "staging"},
|
||||
{"datacenter": "site-c", "node-version": "16.x", "site": "staging"},
|
||||
{"datacenter": "site-d", "node-version": "16.x", "site": "staging"},
|
||||
|
|
@ -528,15 +528,15 @@ func TestReadWorkflow_Strategy(t *testing.T) {
|
|||
},
|
||||
)
|
||||
assert.Equal(t, job.Matrix(),
|
||||
map[string][]any{
|
||||
map[string][]interface{}{
|
||||
"datacenter": {"site-c", "site-d"},
|
||||
"exclude": {
|
||||
map[string]any{"datacenter": "site-d", "node-version": "14.x", "site": "staging"},
|
||||
map[string]interface{}{"datacenter": "site-d", "node-version": "14.x", "site": "staging"},
|
||||
},
|
||||
"include": {
|
||||
map[string]any{"php-version": 5.4},
|
||||
map[string]any{"datacenter": "site-a", "node-version": "10.x", "site": "prod"},
|
||||
map[string]any{"datacenter": "site-b", "node-version": "12.x", "site": "dev"},
|
||||
map[string]interface{}{"php-version": 5.4},
|
||||
map[string]interface{}{"datacenter": "site-a", "node-version": "10.x", "site": "prod"},
|
||||
map[string]interface{}{"datacenter": "site-b", "node-version": "12.x", "site": "dev"},
|
||||
},
|
||||
"node-version": {"14.x", "16.x"},
|
||||
"site": {"staging"},
|
||||
|
|
@ -546,6 +546,25 @@ func TestReadWorkflow_Strategy(t *testing.T) {
|
|||
assert.Equal(t, job.Strategy.FailFast, false)
|
||||
}
|
||||
|
||||
func TestStep_ShellCommand(t *testing.T) {
|
||||
tests := []struct {
|
||||
shell string
|
||||
want string
|
||||
}{
|
||||
{"pwsh -v '. {0}'", "pwsh -v '. {0}'"},
|
||||
{"pwsh", "pwsh -command . '{0}'"},
|
||||
{"powershell", "powershell -command . '{0}'"},
|
||||
{"node", "node {0}"},
|
||||
{"python", "python {0}"},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.shell, func(t *testing.T) {
|
||||
got := (&Step{Shell: tt.shell}).ShellCommand()
|
||||
assert.Equal(t, got, tt.want)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
|
||||
yaml := `
|
||||
name: local-action-docker-url
|
||||
|
|
@ -683,48 +702,3 @@ func TestStepUsesHash(t *testing.T) {
|
|||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadWorkflow_Concurrency(t *testing.T) {
|
||||
for _, testCase := range []struct {
|
||||
expected *RawConcurrency
|
||||
err string
|
||||
snippet string
|
||||
}{
|
||||
{
|
||||
expected: nil,
|
||||
snippet: "# nothing",
|
||||
},
|
||||
{
|
||||
expected: &RawConcurrency{Group: "${{ github.workflow }}-${{ github.ref }}", CancelInProgress: ""},
|
||||
snippet: "concurrency: { group: \"${{ github.workflow }}-${{ github.ref }}\" }",
|
||||
},
|
||||
{
|
||||
expected: &RawConcurrency{Group: "example-group", CancelInProgress: "true"},
|
||||
snippet: "concurrency: { group: example-group, cancel-in-progress: true }",
|
||||
},
|
||||
} {
|
||||
t.Run(testCase.snippet, func(t *testing.T) {
|
||||
yaml := fmt.Sprintf(`
|
||||
name: name-455
|
||||
on: push
|
||||
%s
|
||||
jobs:
|
||||
valid-JOB-Name-455:
|
||||
runs-on: docker
|
||||
steps:
|
||||
- run: echo hi
|
||||
`, testCase.snippet)
|
||||
|
||||
workflow, err := ReadWorkflow(strings.NewReader(yaml), true)
|
||||
if testCase.err != "" {
|
||||
assert.ErrorContains(t, err, testCase.err)
|
||||
} else {
|
||||
assert.NoError(t, err, "read workflow should succeed")
|
||||
|
||||
concurrency := workflow.RawConcurrency
|
||||
// assert.NoError(t, err)
|
||||
assert.Equal(t, testCase.expected, concurrency)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ import (
|
|||
|
||||
"github.com/kballard/go-shellquote"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/container"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/container"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
)
|
||||
|
||||
type actionStep interface {
|
||||
|
|
@ -45,7 +45,7 @@ func readActionImpl(ctx context.Context, step *model.Step, actionDir, actionPath
|
|||
allErrors := []error{}
|
||||
addError := func(fileName string, err error) {
|
||||
if err != nil {
|
||||
allErrors = append(allErrors, fmt.Errorf("failed to read '%s' from action '%s' with path '%s': %w", fileName, step.String(), actionPath, err))
|
||||
allErrors = append(allErrors, fmt.Errorf("failed to read '%s' from action '%s' with path '%s' of step %w", fileName, step.String(), actionPath, err))
|
||||
} else {
|
||||
// One successful read, clear error state
|
||||
allErrors = nil
|
||||
|
|
@ -112,9 +112,6 @@ func readActionImpl(ctx context.Context, step *model.Step, actionDir, actionPath
|
|||
defer closer.Close()
|
||||
|
||||
action, err := model.ReadAction(reader)
|
||||
if err != nil {
|
||||
err = fmt.Errorf("failed to validate action.y*ml from action '%s' with path '%s': %v", step.String(), actionPath, err)
|
||||
}
|
||||
logger.Debugf("Read action %v from '%s'", action, "Unknown")
|
||||
return action, err
|
||||
}
|
||||
|
|
@ -182,7 +179,7 @@ func runActionImpl(step actionStep, actionDir string, remoteAction *remoteAction
|
|||
logger.Debugf("type=%v actionDir=%s actionPath=%s workdir=%s actionCacheDir=%s actionName=%s containerActionDir=%s", stepModel.Type(), actionDir, actionPath, rc.Config.Workdir, rc.ActionCacheDir(), actionName, containerActionDir)
|
||||
|
||||
switch action.Runs.Using {
|
||||
case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20, model.ActionRunsUsingNode24:
|
||||
case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20:
|
||||
if err := maybeCopyToActionDir(ctx, step, actionDir, actionPath, containerActionDir); err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -237,7 +234,6 @@ func runActionImpl(step actionStep, actionDir string, remoteAction *remoteAction
|
|||
model.ActionRunsUsingNode12,
|
||||
model.ActionRunsUsingNode16,
|
||||
model.ActionRunsUsingNode20,
|
||||
model.ActionRunsUsingNode24,
|
||||
model.ActionRunsUsingComposite,
|
||||
model.ActionRunsUsingGo,
|
||||
model.ActionRunsUsingSh,
|
||||
|
|
@ -277,6 +273,7 @@ func removeGitIgnore(ctx context.Context, directory string) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
// TODO: break out parts of function to reduce complexicity
|
||||
func execAsDocker(ctx context.Context, step actionStep, actionName, basedir string, localAction bool) error {
|
||||
logger := common.Logger(ctx)
|
||||
rc := step.getRunContext()
|
||||
|
|
@ -285,16 +282,15 @@ func execAsDocker(ctx context.Context, step actionStep, actionName, basedir stri
|
|||
var prepImage common.Executor
|
||||
var image string
|
||||
forcePull := false
|
||||
if after, ok := strings.CutPrefix(action.Runs.Image, "docker://"); ok {
|
||||
image = after
|
||||
if strings.HasPrefix(action.Runs.Image, "docker://") {
|
||||
image = strings.TrimPrefix(action.Runs.Image, "docker://")
|
||||
// Apply forcePull only for prebuild docker images
|
||||
forcePull = rc.Config.ForcePull
|
||||
} else {
|
||||
if localAction {
|
||||
image = fmt.Sprintf("runner-local-docker-action-%s:latest", common.MustRandName(16))
|
||||
} else {
|
||||
image = fmt.Sprintf("runner-remote-docker-action-%s:latest", common.Sha256(step.getStepModel().Uses))
|
||||
}
|
||||
// "-dockeraction" enshures that "./", "./test " won't get converted to "act-:latest", "act-test-:latest" which are invalid docker image names
|
||||
image = fmt.Sprintf("%s-dockeraction:%s", regexp.MustCompile("[^a-zA-Z0-9]").ReplaceAllString(actionName, "-"), "latest")
|
||||
image = fmt.Sprintf("act-%s", strings.TrimLeft(image, "-"))
|
||||
image = strings.ToLower(image)
|
||||
contextDir, fileName := filepath.Split(filepath.Join(basedir, action.Runs.Image))
|
||||
|
||||
anyArchExists, err := container.ImageExistsLocally(ctx, image, "any")
|
||||
|
|
@ -428,7 +424,7 @@ func newStepContainer(ctx context.Context, step step, image string, cmd, entrypo
|
|||
envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_ARCH", container.RunnerArch(ctx)))
|
||||
envList = append(envList, fmt.Sprintf("%s=%s", "RUNNER_TEMP", "/tmp"))
|
||||
|
||||
binds, mounts, validVolumes := rc.GetBindsAndMounts(ctx)
|
||||
binds, mounts := rc.GetBindsAndMounts()
|
||||
networkMode := fmt.Sprintf("container:%s", rc.jobContainerName())
|
||||
if rc.IsHostEnv(ctx) {
|
||||
networkMode = "default"
|
||||
|
|
@ -451,7 +447,8 @@ func newStepContainer(ctx context.Context, step step, image string, cmd, entrypo
|
|||
Privileged: rc.Config.Privileged,
|
||||
UsernsMode: rc.Config.UsernsMode,
|
||||
Platform: rc.Config.ContainerArchitecture,
|
||||
ValidVolumes: validVolumes,
|
||||
AutoRemove: rc.Config.AutoRemove,
|
||||
ValidVolumes: rc.Config.ValidVolumes,
|
||||
|
||||
ConfigOptions: rc.Config.ContainerOptions,
|
||||
})
|
||||
|
|
@ -530,7 +527,6 @@ func hasPreStep(step actionStep) common.Conditional {
|
|||
((action.Runs.Using == model.ActionRunsUsingNode12 ||
|
||||
action.Runs.Using == model.ActionRunsUsingNode16 ||
|
||||
action.Runs.Using == model.ActionRunsUsingNode20 ||
|
||||
action.Runs.Using == model.ActionRunsUsingNode24 ||
|
||||
action.Runs.Using == model.ActionRunsUsingGo ||
|
||||
action.Runs.Using == model.ActionRunsUsingSh) &&
|
||||
action.Runs.Pre != "")
|
||||
|
|
@ -547,7 +543,7 @@ func runPreStep(step actionStep) common.Executor {
|
|||
action := step.getActionModel()
|
||||
|
||||
switch action.Runs.Using {
|
||||
case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20, model.ActionRunsUsingNode24, model.ActionRunsUsingSh:
|
||||
case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20, model.ActionRunsUsingSh:
|
||||
// defaults in pre steps were missing, however provided inputs are available
|
||||
populateEnvsFromInput(ctx, step.getEnv(), action, rc)
|
||||
// todo: refactor into step
|
||||
|
|
@ -673,7 +669,6 @@ func hasPostStep(step actionStep) common.Conditional {
|
|||
((action.Runs.Using == model.ActionRunsUsingNode12 ||
|
||||
action.Runs.Using == model.ActionRunsUsingNode16 ||
|
||||
action.Runs.Using == model.ActionRunsUsingNode20 ||
|
||||
action.Runs.Using == model.ActionRunsUsingNode24 ||
|
||||
action.Runs.Using == model.ActionRunsUsingGo ||
|
||||
action.Runs.Using == model.ActionRunsUsingSh) &&
|
||||
action.Runs.Post != "")
|
||||
|
|
@ -710,10 +705,9 @@ func runPostStep(step actionStep) common.Executor {
|
|||
_, containerActionDir := getContainerActionPaths(stepModel, actionLocation, rc)
|
||||
|
||||
switch action.Runs.Using {
|
||||
case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20, model.ActionRunsUsingNode24:
|
||||
case model.ActionRunsUsingNode12, model.ActionRunsUsingNode16, model.ActionRunsUsingNode20:
|
||||
|
||||
populateEnvsFromSavedState(step.getEnv(), step, rc)
|
||||
populateEnvsFromInput(ctx, step.getEnv(), step.getActionModel(), rc)
|
||||
|
||||
containerArgs := []string{"node", path.Join(containerActionDir, action.Runs.Post)}
|
||||
logger.Debugf("executing remote job container: %s", containerArgs)
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ import (
|
|||
"github.com/go-git/go-git/v5/plumbing/transport"
|
||||
"github.com/go-git/go-git/v5/plumbing/transport/http"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
type ActionCache interface {
|
||||
|
|
@ -39,7 +39,10 @@ func (c GoGitActionCache) Fetch(ctx context.Context, cacheDir, url, ref, token s
|
|||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
branchName := common.MustRandName(12)
|
||||
branchName, err := common.RandName(12)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
var auth transport.AuthMethod
|
||||
if token != "" {
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package runner
|
|||
import (
|
||||
"archive/tar"
|
||||
"bytes"
|
||||
"context"
|
||||
"io"
|
||||
"os"
|
||||
"testing"
|
||||
|
|
@ -16,7 +17,7 @@ func TestActionCache(t *testing.T) {
|
|||
cache := &GoGitActionCache{
|
||||
Path: os.TempDir(),
|
||||
}
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
cacheDir := "nektos/act-test-actions"
|
||||
repo := "https://code.forgejo.org/forgejo/act-test-actions"
|
||||
refs := []struct {
|
||||
|
|
@ -57,10 +58,9 @@ func TestActionCache(t *testing.T) {
|
|||
return
|
||||
}
|
||||
atar, err := cache.GetTarArchive(ctx, c.CacheDir, sha, "js")
|
||||
if !a.NoError(err) {
|
||||
if !a.NoError(err) || !a.NotEmpty(atar) {
|
||||
return
|
||||
}
|
||||
defer atar.Close()
|
||||
mytar := tar.NewReader(atar)
|
||||
th, err := mytar.Next()
|
||||
if !a.NoError(err) || !a.NotEqual(0, th.Size) {
|
||||
|
|
|
|||
|
|
@ -6,8 +6,8 @@ import (
|
|||
"regexp"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
)
|
||||
|
||||
func evaluateCompositeInputAndEnv(ctx context.Context, parent *RunContext, step actionStep) map[string]string {
|
||||
|
|
@ -136,16 +136,17 @@ func (rc *RunContext) compositeExecutor(action *model.Action) *compositeSteps {
|
|||
|
||||
sf := &stepFactoryImpl{}
|
||||
|
||||
for i, stepModel := range action.Runs.Steps {
|
||||
if stepModel.Number != i {
|
||||
return &compositeSteps{
|
||||
pre: func(ctx context.Context) error { return nil },
|
||||
main: common.NewErrorExecutor(fmt.Errorf("internal error: invalid Step: Number expected %v, was actually %v", i, stepModel.Number)),
|
||||
post: func(ctx context.Context) error { return nil },
|
||||
}
|
||||
for i, step := range action.Runs.Steps {
|
||||
if step.ID == "" {
|
||||
step.ID = fmt.Sprintf("%d", i)
|
||||
}
|
||||
step.Number = i
|
||||
|
||||
step, err := sf.newStep(&stepModel, rc)
|
||||
// create a copy of the step, since this composite action could
|
||||
// run multiple times and we might modify the instance
|
||||
stepcopy := step
|
||||
|
||||
step, err := sf.newStep(&stepcopy, rc)
|
||||
if err != nil {
|
||||
return &compositeSteps{
|
||||
main: common.NewErrorExecutor(err),
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import (
|
|||
"strings"
|
||||
"testing"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
|
@ -130,7 +130,7 @@ runs:
|
|||
closerMock.On("Close")
|
||||
}
|
||||
|
||||
action, err := readActionImpl(t.Context(), tt.step, "actionDir", "actionPath", readFile, writeFile)
|
||||
action, err := readActionImpl(context.Background(), tt.step, "actionDir", "actionPath", readFile, writeFile)
|
||||
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, tt.expected, action)
|
||||
|
|
@ -222,7 +222,7 @@ func TestActionRunner(t *testing.T) {
|
|||
|
||||
for _, tt := range table {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
cm := &containerMock{}
|
||||
cm.On("CopyDir", "/var/run/act/actions/dir/", "dir/", false).Return(func(ctx context.Context) error { return nil })
|
||||
|
|
|
|||
|
|
@ -5,9 +5,7 @@ import (
|
|||
"regexp"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
|
||||
"github.com/sirupsen/logrus"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
)
|
||||
|
||||
var (
|
||||
|
|
@ -45,12 +43,11 @@ func (rc *RunContext) commandHandler(ctx context.Context) common.LineHandler {
|
|||
}
|
||||
|
||||
if resumeCommand != "" && command != resumeCommand {
|
||||
logger.WithFields(logrus.Fields{"command": "ignored", "raw": line}).Infof(" \U00002699 %s", line)
|
||||
logger.Infof(" \U00002699 %s", line)
|
||||
return false
|
||||
}
|
||||
arg = unescapeCommandData(arg)
|
||||
kvPairs = unescapeKvPairs(kvPairs)
|
||||
defCommandLogger := logger.WithFields(logrus.Fields{"command": command, "kvPairs": kvPairs, "arg": arg, "raw": line})
|
||||
switch command {
|
||||
case "set-env":
|
||||
rc.setEnv(ctx, kvPairs, arg)
|
||||
|
|
@ -59,27 +56,27 @@ func (rc *RunContext) commandHandler(ctx context.Context) common.LineHandler {
|
|||
case "add-path":
|
||||
rc.addPath(ctx, arg)
|
||||
case "debug":
|
||||
defCommandLogger.Debugf(" \U0001F4AC %s", line)
|
||||
logger.Infof(" \U0001F4AC %s", line)
|
||||
case "warning":
|
||||
defCommandLogger.Warnf(" \U0001F6A7 %s", line)
|
||||
logger.Infof(" \U0001F6A7 %s", line)
|
||||
case "error":
|
||||
defCommandLogger.Errorf(" \U00002757 %s", line)
|
||||
logger.Infof(" \U00002757 %s", line)
|
||||
case "add-mask":
|
||||
rc.AddMask(arg)
|
||||
defCommandLogger.Infof(" \U00002699 %s", "***")
|
||||
logger.Infof(" \U00002699 %s", "***")
|
||||
case "stop-commands":
|
||||
resumeCommand = arg
|
||||
defCommandLogger.Infof(" \U00002699 %s", line)
|
||||
logger.Infof(" \U00002699 %s", line)
|
||||
case resumeCommand:
|
||||
resumeCommand = ""
|
||||
defCommandLogger.Infof(" \U00002699 %s", line)
|
||||
logger.Infof(" \U00002699 %s", line)
|
||||
case "save-state":
|
||||
defCommandLogger.Infof(" \U0001f4be %s", line)
|
||||
logger.Infof(" \U0001f4be %s", line)
|
||||
rc.saveState(ctx, kvPairs, arg)
|
||||
case "add-matcher":
|
||||
defCommandLogger.Infof(" \U00002753 add-matcher %s", arg)
|
||||
logger.Infof(" \U00002753 add-matcher %s", arg)
|
||||
default:
|
||||
defCommandLogger.Infof(" \U00002753 %s", line)
|
||||
logger.Infof(" \U00002753 %s", line)
|
||||
}
|
||||
|
||||
// return true to let gitea's logger handle these special outputs also
|
||||
|
|
@ -89,7 +86,7 @@ func (rc *RunContext) commandHandler(ctx context.Context) common.LineHandler {
|
|||
|
||||
func (rc *RunContext) setEnv(ctx context.Context, kvPairs map[string]string, arg string) {
|
||||
name := kvPairs["name"]
|
||||
common.Logger(ctx).WithFields(logrus.Fields{"command": "set-env", "name": name, "arg": arg}).Infof(" \U00002699 ::set-env:: %s=%s", name, arg)
|
||||
common.Logger(ctx).Infof(" \U00002699 ::set-env:: %s=%s", name, arg)
|
||||
if rc.Env == nil {
|
||||
rc.Env = make(map[string]string)
|
||||
}
|
||||
|
|
@ -122,12 +119,12 @@ func (rc *RunContext) setOutput(ctx context.Context, kvPairs map[string]string,
|
|||
return
|
||||
}
|
||||
|
||||
logger.WithFields(logrus.Fields{"command": "set-output", "name": outputName, "arg": arg}).Infof(" \U00002699 ::set-output:: %s=%s", outputName, arg)
|
||||
logger.Infof(" \U00002699 ::set-output:: %s=%s", outputName, arg)
|
||||
result.Outputs[outputName] = arg
|
||||
}
|
||||
|
||||
func (rc *RunContext) addPath(ctx context.Context, arg string) {
|
||||
common.Logger(ctx).WithFields(logrus.Fields{"command": "add-path", "arg": arg}).Infof(" \U00002699 ::add-path:: %s", arg)
|
||||
common.Logger(ctx).Infof(" \U00002699 ::add-path:: %s", arg)
|
||||
extraPath := []string{arg}
|
||||
for _, v := range rc.ExtraPath {
|
||||
if v != arg {
|
||||
|
|
@ -139,8 +136,8 @@ func (rc *RunContext) addPath(ctx context.Context, arg string) {
|
|||
|
||||
func parseKeyValuePairs(kvPairs, separator string) map[string]string {
|
||||
rtn := make(map[string]string)
|
||||
kvPairList := strings.SplitSeq(kvPairs, separator)
|
||||
for kvPair := range kvPairList {
|
||||
kvPairList := strings.Split(kvPairs, separator)
|
||||
for _, kvPair := range kvPairList {
|
||||
kv := strings.Split(kvPair, "=")
|
||||
if len(kv) == 2 {
|
||||
rtn[kv[0]] = kv[1]
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ package runner
|
|||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"io"
|
||||
"os"
|
||||
"testing"
|
||||
|
|
@ -9,13 +10,13 @@ import (
|
|||
"github.com/sirupsen/logrus/hooks/test"
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
)
|
||||
|
||||
func TestCommandSetEnv(t *testing.T) {
|
||||
a := assert.New(t)
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
rc := new(RunContext)
|
||||
handler := rc.commandHandler(ctx)
|
||||
|
||||
|
|
@ -25,7 +26,7 @@ func TestCommandSetEnv(t *testing.T) {
|
|||
|
||||
func TestCommandSetOutput(t *testing.T) {
|
||||
a := assert.New(t)
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
rc := new(RunContext)
|
||||
rc.StepResults = make(map[string]*model.StepResult)
|
||||
handler := rc.commandHandler(ctx)
|
||||
|
|
@ -55,7 +56,7 @@ func TestCommandSetOutput(t *testing.T) {
|
|||
|
||||
func TestCommandAddpath(t *testing.T) {
|
||||
a := assert.New(t)
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
rc := new(RunContext)
|
||||
handler := rc.commandHandler(ctx)
|
||||
|
||||
|
|
@ -70,7 +71,7 @@ func TestCommandStopCommands(t *testing.T) {
|
|||
logger, hook := test.NewNullLogger()
|
||||
|
||||
a := assert.New(t)
|
||||
ctx := common.WithLogger(t.Context(), logger)
|
||||
ctx := common.WithLogger(context.Background(), logger)
|
||||
rc := new(RunContext)
|
||||
handler := rc.commandHandler(ctx)
|
||||
|
||||
|
|
@ -93,7 +94,7 @@ func TestCommandStopCommands(t *testing.T) {
|
|||
|
||||
func TestCommandAddpathADO(t *testing.T) {
|
||||
a := assert.New(t)
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
rc := new(RunContext)
|
||||
handler := rc.commandHandler(ctx)
|
||||
|
||||
|
|
@ -108,7 +109,7 @@ func TestCommandAddmask(t *testing.T) {
|
|||
logger, hook := test.NewNullLogger()
|
||||
|
||||
a := assert.New(t)
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
loggerCtx := common.WithLogger(ctx, logger)
|
||||
|
||||
rc := new(RunContext)
|
||||
|
|
@ -162,8 +163,8 @@ func TestCommandAddmaskUsemask(t *testing.T) {
|
|||
}
|
||||
|
||||
re := captureOutput(t, func() {
|
||||
ctx := t.Context()
|
||||
ctx = WithJobLogger(ctx, "0", "testjob", config, &rc.Masks, map[string]any{})
|
||||
ctx := context.Background()
|
||||
ctx = WithJobLogger(ctx, "0", "testjob", config, &rc.Masks, map[string]interface{}{})
|
||||
|
||||
handler := rc.commandHandler(ctx)
|
||||
handler("::add-mask::secret\n")
|
||||
|
|
@ -179,7 +180,7 @@ func TestCommandSaveState(t *testing.T) {
|
|||
StepResults: map[string]*model.StepResult{},
|
||||
}
|
||||
|
||||
ctx := t.Context()
|
||||
ctx := context.Background()
|
||||
|
||||
handler := rc.commandHandler(ctx)
|
||||
handler("::save-state name=state-name::state-value\n")
|
||||
|
|
|
|||
|
|
@ -4,8 +4,8 @@ import (
|
|||
"context"
|
||||
"io"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/container"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/container"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ import (
|
|||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"maps"
|
||||
"path"
|
||||
"reflect"
|
||||
"regexp"
|
||||
|
|
@ -13,16 +12,16 @@ import (
|
|||
|
||||
_ "embed"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/container"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/exprparser"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"go.yaml.in/yaml/v3"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/container"
|
||||
"code.forgejo.org/forgejo/runner/act/exprparser"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// ExpressionEvaluator is the interface for evaluating expressions
|
||||
type ExpressionEvaluator interface {
|
||||
evaluate(context.Context, string, exprparser.DefaultStatusCheck) (any, error)
|
||||
evaluate(context.Context, string, exprparser.DefaultStatusCheck) (interface{}, error)
|
||||
EvaluateYamlNode(context.Context, *yaml.Node) error
|
||||
Interpolate(context.Context, string) string
|
||||
}
|
||||
|
|
@ -37,7 +36,7 @@ func (rc *RunContext) NewExpressionEvaluatorWithEnv(ctx context.Context, env map
|
|||
|
||||
// todo: cleanup EvaluationEnvironment creation
|
||||
using := make(map[string]exprparser.Needs)
|
||||
strategy := make(map[string]any)
|
||||
strategy := make(map[string]interface{})
|
||||
if rc.Run != nil {
|
||||
job := rc.Run.Job()
|
||||
if job != nil && job.Strategy != nil {
|
||||
|
|
@ -65,7 +64,9 @@ func (rc *RunContext) NewExpressionEvaluatorWithEnv(ctx context.Context, env map
|
|||
result := model.WorkflowCallResult{
|
||||
Outputs: map[string]string{},
|
||||
}
|
||||
maps.Copy(result.Outputs, job.Outputs)
|
||||
for k, v := range job.Outputs {
|
||||
result.Outputs[k] = v
|
||||
}
|
||||
workflowCallResult[jobName] = &result
|
||||
}
|
||||
}
|
||||
|
|
@ -107,22 +108,9 @@ var hashfiles string
|
|||
|
||||
// NewStepExpressionEvaluator creates a new evaluator
|
||||
func (rc *RunContext) NewStepExpressionEvaluator(ctx context.Context, step step) ExpressionEvaluator {
|
||||
return rc.NewStepExpressionEvaluatorExt(ctx, step, false)
|
||||
}
|
||||
|
||||
// NewStepExpressionEvaluatorExt creates a new evaluator
|
||||
func (rc *RunContext) NewStepExpressionEvaluatorExt(ctx context.Context, step step, rcInputs bool) ExpressionEvaluator {
|
||||
ghc := rc.getGithubContext(ctx)
|
||||
if rcInputs {
|
||||
return rc.newStepExpressionEvaluator(ctx, step, ghc, getEvaluatorInputs(ctx, rc, nil, ghc))
|
||||
}
|
||||
return rc.newStepExpressionEvaluator(ctx, step, ghc, getEvaluatorInputs(ctx, rc, step, ghc))
|
||||
}
|
||||
|
||||
func (rc *RunContext) newStepExpressionEvaluator(ctx context.Context, step step, ghc *model.GithubContext, inputs map[string]any) ExpressionEvaluator {
|
||||
// todo: cleanup EvaluationEnvironment creation
|
||||
job := rc.Run.Job()
|
||||
strategy := make(map[string]any)
|
||||
strategy := make(map[string]interface{})
|
||||
if job.Strategy != nil {
|
||||
strategy["fail-fast"] = job.Strategy.FailFast
|
||||
strategy["max-parallel"] = job.Strategy.MaxParallel
|
||||
|
|
@ -139,6 +127,9 @@ func (rc *RunContext) newStepExpressionEvaluator(ctx context.Context, step step,
|
|||
}
|
||||
}
|
||||
|
||||
ghc := rc.getGithubContext(ctx)
|
||||
inputs := getEvaluatorInputs(ctx, rc, step, ghc)
|
||||
|
||||
ee := &exprparser.EvaluationEnvironment{
|
||||
Github: step.getGithubContext(ctx),
|
||||
Env: *step.getEnv(),
|
||||
|
|
@ -166,8 +157,8 @@ func (rc *RunContext) newStepExpressionEvaluator(ctx context.Context, step step,
|
|||
}
|
||||
}
|
||||
|
||||
func getHashFilesFunction(ctx context.Context, rc *RunContext) func(v []reflect.Value) (any, error) {
|
||||
hashFiles := func(v []reflect.Value) (any, error) {
|
||||
func getHashFilesFunction(ctx context.Context, rc *RunContext) func(v []reflect.Value) (interface{}, error) {
|
||||
hashFiles := func(v []reflect.Value) (interface{}, error) {
|
||||
if rc.JobContainer != nil {
|
||||
timeed, cancel := context.WithTimeout(ctx, time.Minute)
|
||||
defer cancel()
|
||||
|
|
@ -191,7 +182,9 @@ func getHashFilesFunction(ctx context.Context, rc *RunContext) func(v []reflect.
|
|||
patterns = append(patterns, s)
|
||||
}
|
||||
env := map[string]string{}
|
||||
maps.Copy(env, rc.Env)
|
||||
for k, v := range rc.Env {
|
||||
env[k] = v
|
||||
}
|
||||
env["patterns"] = strings.Join(patterns, "\n")
|
||||
if followSymlink {
|
||||
env["followSymbolicLinks"] = "true"
|
||||
|
|
@ -229,7 +222,7 @@ type expressionEvaluator struct {
|
|||
interpreter exprparser.Interpreter
|
||||
}
|
||||
|
||||
func (ee expressionEvaluator) evaluate(ctx context.Context, in string, defaultStatusCheck exprparser.DefaultStatusCheck) (any, error) {
|
||||
func (ee expressionEvaluator) evaluate(ctx context.Context, in string, defaultStatusCheck exprparser.DefaultStatusCheck) (interface{}, error) {
|
||||
logger := common.Logger(ctx)
|
||||
logger.Debugf("evaluating expression '%s'", in)
|
||||
evaluated, err := ee.interpreter.Evaluate(in, defaultStatusCheck)
|
||||
|
|
@ -476,8 +469,10 @@ func rewriteSubExpression(ctx context.Context, in string, forceFormat bool) (str
|
|||
return out, nil
|
||||
}
|
||||
|
||||
func getEvaluatorInputs(ctx context.Context, rc *RunContext, step step, ghc *model.GithubContext) map[string]any {
|
||||
inputs := map[string]any{}
|
||||
func getEvaluatorInputs(ctx context.Context, rc *RunContext, step step, ghc *model.GithubContext) map[string]interface{} {
|
||||
inputs := map[string]interface{}{}
|
||||
|
||||
setupWorkflowInputs(ctx, &inputs, rc)
|
||||
|
||||
var env map[string]string
|
||||
if step != nil {
|
||||
|
|
@ -487,14 +482,12 @@ func getEvaluatorInputs(ctx context.Context, rc *RunContext, step step, ghc *mod
|
|||
}
|
||||
|
||||
for k, v := range env {
|
||||
if after, ok := strings.CutPrefix(k, "INPUT_"); ok {
|
||||
inputs[strings.ToLower(after)] = v
|
||||
if strings.HasPrefix(k, "INPUT_") {
|
||||
inputs[strings.ToLower(strings.TrimPrefix(k, "INPUT_"))] = v
|
||||
}
|
||||
}
|
||||
|
||||
setupWorkflowInputs(ctx, &inputs, rc)
|
||||
|
||||
if rc.caller == nil && ghc.EventName == "workflow_dispatch" {
|
||||
if ghc.EventName == "workflow_dispatch" {
|
||||
config := rc.Run.Workflow.WorkflowDispatchConfig()
|
||||
if config != nil && config.Inputs != nil {
|
||||
for k, v := range config.Inputs {
|
||||
|
|
@ -517,7 +510,7 @@ func getEvaluatorInputs(ctx context.Context, rc *RunContext, step step, ghc *mod
|
|||
for k, v := range config.Inputs {
|
||||
value := nestedMapLookup(ghc.Event, "inputs", k)
|
||||
if value == nil {
|
||||
_ = v.Default.Decode(&value)
|
||||
value = v.Default
|
||||
}
|
||||
if v.Type == "boolean" {
|
||||
inputs[k] = value == "true"
|
||||
|
|
@ -530,30 +523,27 @@ func getEvaluatorInputs(ctx context.Context, rc *RunContext, step step, ghc *mod
|
|||
return inputs
|
||||
}
|
||||
|
||||
func setupWorkflowInputs(ctx context.Context, inputs *map[string]any, rc *RunContext) {
|
||||
func setupWorkflowInputs(ctx context.Context, inputs *map[string]interface{}, rc *RunContext) {
|
||||
if rc.caller != nil {
|
||||
config := rc.Run.Workflow.WorkflowCallConfig()
|
||||
|
||||
for name, input := range config.Inputs {
|
||||
value := rc.caller.runContext.Run.Job().With[name]
|
||||
|
||||
if value != nil {
|
||||
node := yaml.Node{}
|
||||
_ = node.Encode(value)
|
||||
if rc.caller.runContext.ExprEval != nil {
|
||||
if str, ok := value.(string); ok {
|
||||
// evaluate using the calling RunContext (outside)
|
||||
_ = rc.caller.runContext.ExprEval.EvaluateYamlNode(ctx, &node)
|
||||
value = rc.caller.runContext.ExprEval.Interpolate(ctx, str)
|
||||
}
|
||||
_ = node.Decode(&value)
|
||||
}
|
||||
|
||||
if value == nil && config != nil && config.Inputs != nil {
|
||||
def := input.Default
|
||||
value = input.Default
|
||||
if rc.ExprEval != nil {
|
||||
// evaluate using the called RunContext (inside)
|
||||
_ = rc.ExprEval.EvaluateYamlNode(ctx, &def)
|
||||
if str, ok := value.(string); ok {
|
||||
// evaluate using the called RunContext (inside)
|
||||
value = rc.ExprEval.Interpolate(ctx, str)
|
||||
}
|
||||
}
|
||||
_ = def.Decode(&value)
|
||||
}
|
||||
|
||||
(*inputs)[name] = value
|
||||
|
|
@ -564,21 +554,21 @@ func setupWorkflowInputs(ctx context.Context, inputs *map[string]any, rc *RunCon
|
|||
func getWorkflowSecrets(ctx context.Context, rc *RunContext) map[string]string {
|
||||
if rc.caller != nil {
|
||||
job := rc.caller.runContext.Run.Job()
|
||||
rawSecrets := job.Secrets()
|
||||
secrets := job.Secrets()
|
||||
|
||||
if rawSecrets == nil && job.InheritSecrets() {
|
||||
rawSecrets = rc.caller.runContext.Config.Secrets
|
||||
if secrets == nil && job.InheritSecrets() {
|
||||
secrets = rc.caller.runContext.Config.Secrets
|
||||
}
|
||||
|
||||
if rawSecrets == nil {
|
||||
return map[string]string{}
|
||||
if secrets == nil {
|
||||
secrets = map[string]string{}
|
||||
}
|
||||
|
||||
interpolatedSecrets := make(map[string]string, len(rawSecrets))
|
||||
for k, v := range rawSecrets {
|
||||
interpolatedSecrets[k] = rc.caller.runContext.ExprEval.Interpolate(ctx, v)
|
||||
for k, v := range secrets {
|
||||
secrets[k] = rc.caller.runContext.ExprEval.Interpolate(ctx, v)
|
||||
}
|
||||
return interpolatedSecrets
|
||||
|
||||
return secrets
|
||||
}
|
||||
|
||||
return rc.Config.Secrets
|
||||
|
|
|
|||
|
|
@ -1,17 +1,18 @@
|
|||
package runner
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/exprparser"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/act/exprparser"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
assert "github.com/stretchr/testify/assert"
|
||||
yaml "go.yaml.in/yaml/v3"
|
||||
yaml "gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
func createRunContext(t *testing.T) *RunContext {
|
||||
var yml yaml.Node
|
||||
err := yml.Encode(map[string][]any{
|
||||
err := yml.Encode(map[string][]interface{}{
|
||||
"os": {"Linux", "Windows"},
|
||||
"foo": {"bar", "baz"},
|
||||
})
|
||||
|
|
@ -43,7 +44,7 @@ func createRunContext(t *testing.T) *RunContext {
|
|||
},
|
||||
},
|
||||
},
|
||||
Matrix: map[string]any{
|
||||
Matrix: map[string]interface{}{
|
||||
"os": "Linux",
|
||||
"foo": "bar",
|
||||
},
|
||||
|
|
@ -75,11 +76,11 @@ func createRunContext(t *testing.T) *RunContext {
|
|||
|
||||
func TestExpressionEvaluateRunContext(t *testing.T) {
|
||||
rc := createRunContext(t)
|
||||
ee := rc.NewExpressionEvaluator(t.Context())
|
||||
ee := rc.NewExpressionEvaluator(context.Background())
|
||||
|
||||
tables := []struct {
|
||||
in string
|
||||
out any
|
||||
out interface{}
|
||||
errMesg string
|
||||
}{
|
||||
{" 1 ", 1, ""},
|
||||
|
|
@ -133,9 +134,10 @@ func TestExpressionEvaluateRunContext(t *testing.T) {
|
|||
}
|
||||
|
||||
for _, table := range tables {
|
||||
table := table
|
||||
t.Run(table.in, func(t *testing.T) {
|
||||
assertObject := assert.New(t)
|
||||
out, err := ee.evaluate(t.Context(), table.in, exprparser.DefaultStatusCheckNone)
|
||||
out, err := ee.evaluate(context.Background(), table.in, exprparser.DefaultStatusCheckNone)
|
||||
if table.errMesg == "" {
|
||||
assertObject.NoError(err, table.in)
|
||||
assertObject.Equal(table.out, out, table.in)
|
||||
|
|
@ -153,11 +155,11 @@ func TestExpressionEvaluateStep(t *testing.T) {
|
|||
RunContext: rc,
|
||||
}
|
||||
|
||||
ee := rc.NewStepExpressionEvaluator(t.Context(), step)
|
||||
ee := rc.NewStepExpressionEvaluator(context.Background(), step)
|
||||
|
||||
tables := []struct {
|
||||
in string
|
||||
out any
|
||||
out interface{}
|
||||
errMesg string
|
||||
}{
|
||||
{"steps.idwithnothing.conclusion", model.StepStatusSuccess.String(), ""},
|
||||
|
|
@ -172,9 +174,10 @@ func TestExpressionEvaluateStep(t *testing.T) {
|
|||
}
|
||||
|
||||
for _, table := range tables {
|
||||
table := table
|
||||
t.Run(table.in, func(t *testing.T) {
|
||||
assertObject := assert.New(t)
|
||||
out, err := ee.evaluate(t.Context(), table.in, exprparser.DefaultStatusCheckNone)
|
||||
out, err := ee.evaluate(context.Background(), table.in, exprparser.DefaultStatusCheckNone)
|
||||
if table.errMesg == "" {
|
||||
assertObject.NoError(err, table.in)
|
||||
assertObject.Equal(table.out, out, table.in)
|
||||
|
|
@ -214,7 +217,7 @@ func TestExpressionInterpolate(t *testing.T) {
|
|||
},
|
||||
},
|
||||
}
|
||||
ee := rc.NewExpressionEvaluator(t.Context())
|
||||
ee := rc.NewExpressionEvaluator(context.Background())
|
||||
tables := []struct {
|
||||
in string
|
||||
out string
|
||||
|
|
@ -254,9 +257,10 @@ func TestExpressionInterpolate(t *testing.T) {
|
|||
}
|
||||
|
||||
for _, table := range tables {
|
||||
table := table
|
||||
t.Run("interpolate", func(t *testing.T) {
|
||||
assertObject := assert.New(t)
|
||||
out := ee.Interpolate(t.Context(), table.in)
|
||||
out := ee.Interpolate(context.Background(), table.in)
|
||||
assertObject.Equal(table.out, out, table.in)
|
||||
})
|
||||
}
|
||||
|
|
@ -283,7 +287,7 @@ func TestExpressionRewriteSubExpression(t *testing.T) {
|
|||
for _, table := range table {
|
||||
t.Run("TestRewriteSubExpression", func(t *testing.T) {
|
||||
assertObject := assert.New(t)
|
||||
out, err := rewriteSubExpression(t.Context(), table.in, false)
|
||||
out, err := rewriteSubExpression(context.Background(), table.in, false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
|
@ -307,7 +311,7 @@ func TestExpressionRewriteSubExpressionForceFormat(t *testing.T) {
|
|||
for _, table := range table {
|
||||
t.Run("TestRewriteSubExpressionForceFormat", func(t *testing.T) {
|
||||
assertObject := assert.New(t)
|
||||
out, err := rewriteSubExpression(t.Context(), table.in, true)
|
||||
out, err := rewriteSubExpression(context.Background(), table.in, true)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,14 +5,13 @@ import (
|
|||
"fmt"
|
||||
"time"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/container"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"github.com/sirupsen/logrus"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/container"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
)
|
||||
|
||||
type jobInfo interface {
|
||||
matrix() map[string]any
|
||||
matrix() map[string]interface{}
|
||||
steps() []*model.Step
|
||||
startContainer() common.Executor
|
||||
stopContainer() common.Executor
|
||||
|
|
@ -21,8 +20,6 @@ type jobInfo interface {
|
|||
result(result string)
|
||||
}
|
||||
|
||||
const cleanupTimeout = 30 * time.Minute
|
||||
|
||||
func newJobExecutor(info jobInfo, sf stepFactory, rc *RunContext) common.Executor {
|
||||
steps := make([]common.Executor, 0)
|
||||
preSteps := make([]common.Executor, 0)
|
||||
|
|
@ -57,11 +54,16 @@ func newJobExecutor(info jobInfo, sf stepFactory, rc *RunContext) common.Executo
|
|||
})
|
||||
|
||||
for i, stepModel := range infoSteps {
|
||||
stepModel := stepModel
|
||||
if stepModel == nil {
|
||||
return common.NewErrorExecutor(fmt.Errorf("invalid Step %v: missing run or uses key", i))
|
||||
} else if stepModel.Number != i {
|
||||
return common.NewErrorExecutor(fmt.Errorf("internal error: invalid Step: Number expected %v, was actually %v", i, stepModel.Number))
|
||||
return func(ctx context.Context) error {
|
||||
return fmt.Errorf("invalid Step %v: missing run or uses key", i)
|
||||
}
|
||||
}
|
||||
if stepModel.ID == "" {
|
||||
stepModel.ID = fmt.Sprintf("%d", i)
|
||||
}
|
||||
stepModel.Number = i
|
||||
|
||||
step, err := sf.newStep(stepModel, rc)
|
||||
if err != nil {
|
||||
|
|
@ -105,40 +107,37 @@ func newJobExecutor(info jobInfo, sf stepFactory, rc *RunContext) common.Executo
|
|||
}
|
||||
}
|
||||
|
||||
setJobResults := func(ctx context.Context) error {
|
||||
postExecutor = postExecutor.Finally(func(ctx context.Context) error {
|
||||
jobError := common.JobError(ctx)
|
||||
|
||||
// Fresh context to ensure job result output works even if prev. context was a cancelled job
|
||||
ctx, cancel := context.WithTimeout(common.WithLogger(context.Background(), common.Logger(ctx)), time.Minute)
|
||||
defer cancel()
|
||||
setJobResult(ctx, info, rc, jobError == nil)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
cleanupJob := func(_ context.Context) error {
|
||||
var err error
|
||||
if rc.Config.AutoRemove || jobError == nil {
|
||||
// always allow 1 min for stopping and removing the runner, even if we were cancelled
|
||||
ctx, cancel := context.WithTimeout(common.WithLogger(context.Background(), common.Logger(ctx)), time.Minute)
|
||||
defer cancel()
|
||||
|
||||
// Separate timeout for cleanup tasks; logger is cleared so that cleanup logs go to runner, not job
|
||||
ctx, cancel := context.WithTimeout(context.Background(), cleanupTimeout)
|
||||
defer cancel()
|
||||
logger := common.Logger(ctx)
|
||||
logger.Infof("Cleaning up container for job %s", rc.JobName)
|
||||
if err = info.stopContainer()(ctx); err != nil {
|
||||
logger.Errorf("Error while stop job container: %v", err)
|
||||
}
|
||||
|
||||
logger := common.Logger(ctx)
|
||||
logger.Debugf("Cleaning up container for job %s", rc.jobContainerName())
|
||||
if err = info.stopContainer()(ctx); err != nil {
|
||||
logger.Errorf("Error while stop job container %s: %v", rc.jobContainerName(), err)
|
||||
}
|
||||
|
||||
if !rc.IsHostEnv(ctx) && rc.getNetworkCreated(ctx) {
|
||||
networkName := rc.getNetworkName(ctx)
|
||||
logger.Debugf("Cleaning up network %s for job %s", networkName, rc.jobContainerName())
|
||||
if err := container.NewDockerNetworkRemoveExecutor(networkName)(ctx); err != nil {
|
||||
logger.Errorf("Error while cleaning network %s: %v", networkName, err)
|
||||
if !rc.IsHostEnv(ctx) && rc.Config.ContainerNetworkMode == "" {
|
||||
// clean network in docker mode only
|
||||
// if the value of `ContainerNetworkMode` is empty string,
|
||||
// it means that the network to which containers are connecting is created by `act_runner`,
|
||||
// so, we should remove the network at last.
|
||||
networkName, _ := rc.networkName()
|
||||
logger.Infof("Cleaning up network for job %s, and network name is: %s", rc.JobName, networkName)
|
||||
if err := container.NewDockerNetworkRemoveExecutor(networkName)(ctx); err != nil {
|
||||
logger.Errorf("Error while cleaning network: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
setJobResult(ctx, info, rc, jobError == nil)
|
||||
setJobOutputs(ctx, rc)
|
||||
|
||||
return err
|
||||
}
|
||||
})
|
||||
|
||||
pipeline := make([]common.Executor, 0)
|
||||
pipeline = append(pipeline, preSteps...)
|
||||
|
|
@ -150,25 +149,18 @@ func newJobExecutor(info jobInfo, sf stepFactory, rc *RunContext) common.Executo
|
|||
if ctx.Err() == context.Canceled {
|
||||
// in case of an aborted run, we still should execute the
|
||||
// post steps to allow cleanup.
|
||||
ctx, cancel = context.WithTimeout(common.WithLogger(context.Background(), common.Logger(ctx)), cleanupTimeout)
|
||||
ctx, cancel = context.WithTimeout(common.WithLogger(context.Background(), common.Logger(ctx)), 5*time.Minute)
|
||||
defer cancel()
|
||||
}
|
||||
return postExecutor(ctx)
|
||||
}).
|
||||
Finally(info.interpolateOutputs()).
|
||||
Finally(setJobResults).
|
||||
Finally(cleanupJob).
|
||||
Finally(info.closeContainer()))
|
||||
}
|
||||
|
||||
func setJobResult(ctx context.Context, info jobInfo, rc *RunContext, success bool) {
|
||||
logger := common.Logger(ctx)
|
||||
|
||||
// As we're reading the matrix build's status (`rc.Run.Job().Result`), it's possible for it change in another
|
||||
// goroutine running `setJobResult` and invoking `.result(...)`. Prevent concurrent execution of `setJobResult`...
|
||||
rc.Run.Job().ResultMutex.Lock()
|
||||
defer rc.Run.Job().ResultMutex.Unlock()
|
||||
|
||||
jobResult := "success"
|
||||
// we have only one result for a whole matrix build, so we need
|
||||
// to keep an existing result state if we run a matrix
|
||||
|
|
@ -180,42 +172,33 @@ func setJobResult(ctx context.Context, info jobInfo, rc *RunContext, success boo
|
|||
jobResult = "failure"
|
||||
}
|
||||
|
||||
// Set local result on current job (child or parent)
|
||||
info.result(jobResult)
|
||||
|
||||
if rc.caller != nil {
|
||||
// Child reusable workflow:
|
||||
// 1) propagate result to parent job state
|
||||
// set reusable workflow job result
|
||||
rc.caller.runContext.result(jobResult)
|
||||
|
||||
// 2) copy workflow_call outputs from child to parent (as in upstream)
|
||||
jobOutputs := make(map[string]string)
|
||||
ee := rc.NewExpressionEvaluator(ctx)
|
||||
if wfcc := rc.Run.Workflow.WorkflowCallConfig(); wfcc != nil {
|
||||
for k, v := range wfcc.Outputs {
|
||||
jobOutputs[k] = ee.Interpolate(ctx, ee.Interpolate(ctx, v.Value))
|
||||
}
|
||||
}
|
||||
rc.caller.runContext.Run.Job().Outputs = jobOutputs
|
||||
|
||||
// 3) DO NOT print banner in child job (prevents premature token revocation)
|
||||
logger.Debugf("Reusable job result=%s (parent will finalize, no banner)", jobResult)
|
||||
return
|
||||
}
|
||||
|
||||
// Parent job: print the final banner ONCE (job-level)
|
||||
jobResultMessage := "succeeded"
|
||||
if jobResult != "success" {
|
||||
jobResultMessage = "failed"
|
||||
}
|
||||
jobOutputs := rc.Run.Job().Outputs
|
||||
|
||||
logger.
|
||||
WithFields(logrus.Fields{
|
||||
"jobResult": jobResult,
|
||||
"jobOutputs": jobOutputs,
|
||||
}).
|
||||
Infof("\U0001F3C1 Job %s", jobResultMessage)
|
||||
logger.WithField("jobResult", jobResult).Infof("\U0001F3C1 Job %s", jobResultMessage)
|
||||
}
|
||||
|
||||
func setJobOutputs(ctx context.Context, rc *RunContext) {
|
||||
if rc.caller != nil {
|
||||
// map outputs for reusable workflows
|
||||
callerOutputs := make(map[string]string)
|
||||
|
||||
ee := rc.NewExpressionEvaluator(ctx)
|
||||
|
||||
for k, v := range rc.Run.Workflow.WorkflowCallConfig().Outputs {
|
||||
callerOutputs[k] = ee.Interpolate(ctx, ee.Interpolate(ctx, v.Value))
|
||||
}
|
||||
|
||||
rc.caller.runContext.Run.Job().Outputs = callerOutputs
|
||||
}
|
||||
}
|
||||
|
||||
func useStepLogger(rc *RunContext, stepModel *model.Step, stage stepStage, executor common.Executor) common.Executor {
|
||||
|
|
|
|||
|
|
@ -4,36 +4,29 @@ import (
|
|||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"slices"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/container"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/model"
|
||||
"code.forgejo.org/forgejo/runner/v11/act/runner/mocks"
|
||||
"github.com/sirupsen/logrus"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/container"
|
||||
"code.forgejo.org/forgejo/runner/act/model"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
//go:generate mockery --srcpkg=github.com/sirupsen/logrus --name=FieldLogger
|
||||
|
||||
func TestJobExecutor(t *testing.T) {
|
||||
tables := []TestJobFileInfo{
|
||||
{workdir, "uses-and-run-in-one-step", "push", "Invalid run/uses syntax for job:test step:Test", platforms, secrets},
|
||||
{workdir, "uses-github-empty", "push", "job:test step:empty", platforms, secrets},
|
||||
{workdir, "uses-github-empty", "push", "Expected format {org}/{repo}[/path]@ref", platforms, secrets},
|
||||
{workdir, "uses-github-noref", "push", "Expected format {org}/{repo}[/path]@ref", platforms, secrets},
|
||||
{workdir, "uses-github-root", "push", "", platforms, secrets},
|
||||
{workdir, "uses-github-path", "push", "", platforms, secrets},
|
||||
{workdir, "uses-docker-url", "push", "", platforms, secrets},
|
||||
{workdir, "uses-github-full-sha", "push", "", platforms, secrets},
|
||||
{workdir, "uses-github-short-sha", "push", "Please use the full commit SHA", platforms, secrets},
|
||||
{workdir, "uses-github-short-sha", "push", "Unable to resolve action `actions/hello-world-docker-action@b136eb8`, the provided ref `b136eb8` is the shortened version of a commit SHA, which is not supported. Please use the full commit SHA `b136eb8894c5cb1dd5807da824be97ccdf9b5423` instead", platforms, secrets},
|
||||
{workdir, "job-nil-step", "push", "invalid Step 0: missing run or uses key", platforms, secrets},
|
||||
}
|
||||
// These tests are sufficient to only check syntax.
|
||||
ctx := common.WithDryrun(t.Context(), true)
|
||||
ctx := common.WithDryrun(context.Background(), true)
|
||||
for _, table := range tables {
|
||||
t.Run(table.workflowPath, func(t *testing.T) {
|
||||
table.runTest(ctx, t, &Config{})
|
||||
|
|
@ -45,9 +38,9 @@ type jobInfoMock struct {
|
|||
mock.Mock
|
||||
}
|
||||
|
||||
func (jim *jobInfoMock) matrix() map[string]any {
|
||||
func (jim *jobInfoMock) matrix() map[string]interface{} {
|
||||
args := jim.Called()
|
||||
return args.Get(0).(map[string]any)
|
||||
return args.Get(0).(map[string]interface{})
|
||||
}
|
||||
|
||||
func (jim *jobInfoMock) steps() []*model.Step {
|
||||
|
|
@ -131,9 +124,8 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
executedSteps: []string{
|
||||
"startContainer",
|
||||
"step1",
|
||||
"interpolateOutputs",
|
||||
"setJobResults",
|
||||
"stopContainer",
|
||||
"interpolateOutputs",
|
||||
"closeContainer",
|
||||
},
|
||||
result: "success",
|
||||
|
|
@ -150,8 +142,6 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
"startContainer",
|
||||
"step1",
|
||||
"interpolateOutputs",
|
||||
"setJobResults",
|
||||
"stopContainer",
|
||||
"closeContainer",
|
||||
},
|
||||
result: "failure",
|
||||
|
|
@ -168,9 +158,8 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
"startContainer",
|
||||
"pre1",
|
||||
"step1",
|
||||
"interpolateOutputs",
|
||||
"setJobResults",
|
||||
"stopContainer",
|
||||
"interpolateOutputs",
|
||||
"closeContainer",
|
||||
},
|
||||
result: "success",
|
||||
|
|
@ -187,9 +176,8 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
"startContainer",
|
||||
"step1",
|
||||
"post1",
|
||||
"interpolateOutputs",
|
||||
"setJobResults",
|
||||
"stopContainer",
|
||||
"interpolateOutputs",
|
||||
"closeContainer",
|
||||
},
|
||||
result: "success",
|
||||
|
|
@ -207,9 +195,8 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
"pre1",
|
||||
"step1",
|
||||
"post1",
|
||||
"interpolateOutputs",
|
||||
"setJobResults",
|
||||
"stopContainer",
|
||||
"interpolateOutputs",
|
||||
"closeContainer",
|
||||
},
|
||||
result: "success",
|
||||
|
|
@ -218,14 +205,11 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
{
|
||||
name: "stepsWithPreAndPost",
|
||||
steps: []*model.Step{{
|
||||
ID: "1",
|
||||
Number: 0,
|
||||
ID: "1",
|
||||
}, {
|
||||
ID: "2",
|
||||
Number: 1,
|
||||
ID: "2",
|
||||
}, {
|
||||
ID: "3",
|
||||
Number: 2,
|
||||
ID: "3",
|
||||
}},
|
||||
preSteps: []bool{true, false, true},
|
||||
postSteps: []bool{false, true, true},
|
||||
|
|
@ -238,9 +222,8 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
"step3",
|
||||
"post3",
|
||||
"post2",
|
||||
"interpolateOutputs",
|
||||
"setJobResults",
|
||||
"stopContainer",
|
||||
"interpolateOutputs",
|
||||
"closeContainer",
|
||||
},
|
||||
result: "success",
|
||||
|
|
@ -249,34 +232,19 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
}
|
||||
|
||||
contains := func(needle string, haystack []string) bool {
|
||||
return slices.Contains(haystack, needle)
|
||||
for _, item := range haystack {
|
||||
if item == needle {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
for _, tt := range table {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
fmt.Printf("::group::%s\n", tt.name)
|
||||
|
||||
executorOrder := make([]string, 0)
|
||||
|
||||
mockLogger := mocks.NewFieldLogger(t)
|
||||
mockLogger.On("Debugf", mock.Anything, mock.Anything).Return(0).Maybe()
|
||||
mockLogger.On("Warningf", mock.Anything, mock.Anything).Return(0).Maybe()
|
||||
mockLogger.On("WithField", mock.Anything, mock.Anything).Return(&logrus.Entry{Logger: &logrus.Logger{}}).Maybe()
|
||||
// When `WithFields()` is called with jobResult & jobOutputs field, add `setJobResults` to executorOrder.
|
||||
mockLogger.On("WithFields",
|
||||
mock.MatchedBy(func(fields logrus.Fields) bool {
|
||||
_, okJobResult := fields["jobResult"]
|
||||
_, okJobOutput := fields["jobOutputs"]
|
||||
return okJobOutput && okJobResult
|
||||
})).
|
||||
Run(func(args mock.Arguments) {
|
||||
executorOrder = append(executorOrder, "setJobResults")
|
||||
}).
|
||||
Return(&logrus.Entry{Logger: &logrus.Logger{}}).Maybe()
|
||||
|
||||
mockLogger.On("WithFields", mock.Anything).Return(&logrus.Entry{Logger: &logrus.Logger{}}).Maybe()
|
||||
|
||||
ctx := common.WithLogger(common.WithJobErrorContainer(t.Context()), mockLogger)
|
||||
ctx := common.WithJobErrorContainer(context.Background())
|
||||
jim := &jobInfoMock{}
|
||||
sfm := &stepFactoryMock{}
|
||||
rc := &RunContext{
|
||||
|
|
@ -292,6 +260,7 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
Config: &Config{},
|
||||
}
|
||||
rc.ExprEval = rc.NewExpressionEvaluator(ctx)
|
||||
executorOrder := make([]string, 0)
|
||||
|
||||
jim.On("steps").Return(tt.steps)
|
||||
|
||||
|
|
@ -303,6 +272,9 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
}
|
||||
|
||||
for i, stepModel := range tt.steps {
|
||||
i := i
|
||||
stepModel := stepModel
|
||||
|
||||
sm := &stepMock{}
|
||||
|
||||
sfm.On("newStep", stepModel, rc).Return(sm, nil)
|
||||
|
|
@ -333,7 +305,7 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
}
|
||||
|
||||
if len(tt.steps) > 0 {
|
||||
jim.On("matrix").Return(map[string]any{})
|
||||
jim.On("matrix").Return(map[string]interface{}{})
|
||||
|
||||
jim.On("interpolateOutputs").Return(func(ctx context.Context) error {
|
||||
executorOrder = append(executorOrder, "interpolateOutputs")
|
||||
|
|
@ -367,153 +339,3 @@ func TestJobExecutorNewJobExecutor(t *testing.T) {
|
|||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSetJobResultConcurrency(t *testing.T) {
|
||||
jim := &jobInfoMock{}
|
||||
job := model.Job{
|
||||
Result: "success",
|
||||
}
|
||||
// Distinct RunContext objects are used to replicate realistic setJobResult in matrix build
|
||||
rc1 := &RunContext{
|
||||
Run: &model.Run{
|
||||
JobID: "test",
|
||||
Workflow: &model.Workflow{
|
||||
Jobs: map[string]*model.Job{
|
||||
"test": &job,
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
rc2 := &RunContext{
|
||||
Run: &model.Run{
|
||||
JobID: "test",
|
||||
Workflow: &model.Workflow{
|
||||
Jobs: map[string]*model.Job{
|
||||
"test": &job,
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
// Hack: Job() invokes GetJob() which can mutate the job name, this will trip the data race detector if it is
|
||||
// encountered later when `setJobResult()` is being tested. This is a false-positive caused by this test invoking
|
||||
// setJobResult outside of the regular RunContext, so it's invoked here before the goroutines are spawned to prevent
|
||||
// the false positive.
|
||||
rc1.Run.Job()
|
||||
rc2.Run.Job()
|
||||
|
||||
jim.On("matrix").Return(map[string]interface{}{
|
||||
"python": []string{"3.10", "3.11", "3.12"},
|
||||
})
|
||||
|
||||
// Synthesize a race condition in setJobResult where, by reading data from the job matrix earlier and then
|
||||
// performing unsynchronzied writes to the same shared data structure, it can overwrite a failure status.
|
||||
//
|
||||
// Goroutine 1: Start marking job as success
|
||||
// (artificially suspended
|
||||
// by result() mock)
|
||||
// Goroutine 2: Mark job as failure
|
||||
// Goroutine 1: Finish marking job as success
|
||||
//
|
||||
// Correct behavior: Job is marked as a failure
|
||||
// Bug behavior: Job is marked as a success
|
||||
|
||||
var lastResult string
|
||||
jim.On("result", mock.Anything).Run(func(args mock.Arguments) {
|
||||
result := args.String(0)
|
||||
// Artificially suspend the "success" case so that the failure case races past it.
|
||||
if result == "success" {
|
||||
time.Sleep(1 * time.Second)
|
||||
}
|
||||
job.Result = result
|
||||
lastResult = result
|
||||
})
|
||||
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(2)
|
||||
// Goroutine 1, mark as success:
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
setJobResult(t.Context(), jim, rc1, true)
|
||||
}()
|
||||
// Goroutine 2, mark as failure:
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
setJobResult(t.Context(), jim, rc2, false)
|
||||
}()
|
||||
wg.Wait()
|
||||
|
||||
assert.Equal(t, "failure", lastResult)
|
||||
}
|
||||
|
||||
func TestSetJobResult_SkipsBannerInChildReusableWorkflow(t *testing.T) {
|
||||
// Test that child reusable workflow does not print final banner
|
||||
// to prevent premature token revocation
|
||||
|
||||
mockLogger := mocks.NewFieldLogger(t)
|
||||
// Allow all variants of Debugf (git operations can call with 1-3 args)
|
||||
mockLogger.On("Debugf", mock.Anything).Return(0).Maybe()
|
||||
mockLogger.On("Debugf", mock.Anything, mock.Anything).Return(0).Maybe()
|
||||
mockLogger.On("Debugf", mock.Anything, mock.Anything, mock.Anything).Return(0).Maybe()
|
||||
// CRITICAL: In CI, git ref detection may fail and call Warningf
|
||||
mockLogger.On("Warningf", mock.Anything, mock.Anything).Return(0).Maybe()
|
||||
mockLogger.On("WithField", mock.Anything, mock.Anything).Return(&logrus.Entry{Logger: &logrus.Logger{}}).Maybe()
|
||||
mockLogger.On("WithFields", mock.Anything).Return(&logrus.Entry{Logger: &logrus.Logger{}}).Maybe()
|
||||
|
||||
ctx := common.WithLogger(common.WithJobErrorContainer(t.Context()), mockLogger)
|
||||
|
||||
// Setup parent job
|
||||
parentJob := &model.Job{
|
||||
Result: "success",
|
||||
}
|
||||
parentRC := &RunContext{
|
||||
Config: &Config{Env: map[string]string{}}, // Must have Config
|
||||
Run: &model.Run{
|
||||
JobID: "parent",
|
||||
Workflow: &model.Workflow{
|
||||
Jobs: map[string]*model.Job{
|
||||
"parent": parentJob,
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// Setup child job with caller reference
|
||||
childJob := &model.Job{
|
||||
Result: "success",
|
||||
}
|
||||
childRC := &RunContext{
|
||||
Config: &Config{Env: map[string]string{}}, // Must have Config
|
||||
Run: &model.Run{
|
||||
JobID: "child",
|
||||
Workflow: &model.Workflow{
|
||||
Jobs: map[string]*model.Job{
|
||||
"child": childJob,
|
||||
},
|
||||
},
|
||||
},
|
||||
caller: &caller{
|
||||
runContext: parentRC,
|
||||
},
|
||||
}
|
||||
|
||||
jim := &jobInfoMock{}
|
||||
jim.On("matrix").Return(map[string]any{}) // REQUIRED: setJobResult always calls matrix()
|
||||
jim.On("result", "success")
|
||||
|
||||
// Call setJobResult for child workflow
|
||||
setJobResult(ctx, jim, childRC, true)
|
||||
|
||||
// Verify:
|
||||
// 1. Child result is set
|
||||
jim.AssertCalled(t, "result", "success")
|
||||
|
||||
// 2. Parent result is propagated
|
||||
assert.Equal(t, "success", parentJob.Result)
|
||||
|
||||
// 3. Final banner was NOT printed by child (critical for token security)
|
||||
mockLogger.AssertNotCalled(t, "WithFields", mock.MatchedBy(func(fields logrus.Fields) bool {
|
||||
_, okJobResult := fields["jobResult"]
|
||||
_, okJobOutput := fields["jobOutputs"]
|
||||
return okJobOutput && okJobResult
|
||||
}))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ import (
|
|||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/filecollector"
|
||||
"code.forgejo.org/forgejo/runner/act/filecollector"
|
||||
)
|
||||
|
||||
type LocalRepositoryCache struct {
|
||||
|
|
|
|||
|
|
@ -5,12 +5,11 @@ import (
|
|||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"maps"
|
||||
"os"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"code.forgejo.org/forgejo/runner/v11/act/common"
|
||||
"code.forgejo.org/forgejo/runner/act/common"
|
||||
|
||||
"github.com/sirupsen/logrus"
|
||||
"golang.org/x/term"
|
||||
|
|
@ -73,7 +72,7 @@ func WithJobLoggerFactory(ctx context.Context, factory JobLoggerFactory) context
|
|||
}
|
||||
|
||||
// WithJobLogger attaches a new logger to context that is aware of steps
|
||||
func WithJobLogger(ctx context.Context, jobID, jobName string, config *Config, masks *[]string, matrix map[string]any) context.Context {
|
||||
func WithJobLogger(ctx context.Context, jobID, jobName string, config *Config, masks *[]string, matrix map[string]interface{}) context.Context {
|
||||
ctx = WithMasks(ctx, masks)
|
||||
|
||||
var logger *logrus.Logger
|
||||
|
|
@ -146,26 +145,6 @@ func WithCompositeStepLogger(ctx context.Context, stepID string) context.Context
|
|||
}).WithContext(ctx))
|
||||
}
|
||||
|
||||
func GetOuterStepResult(entry *logrus.Entry) any {
|
||||
r, ok := entry.Data["stepResult"]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
|
||||
// composite actions steps log with a list of stepID
|
||||
if s, ok := entry.Data["stepID"]; ok {
|
||||
if stepIDs, ok := s.([]string); ok {
|
||||
if len(stepIDs) > 1 {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return nil
|
||||
}
|
||||
|
||||
return r
|
||||
}
|
||||
|
||||
func withStepLogger(ctx context.Context, stepNumber int, stepID, stepName, stageName string) context.Context {
|
||||
rtn := common.Logger(ctx).WithFields(logrus.Fields{
|
||||
"stepNumber": stepNumber,
|
||||
|
|
@ -179,7 +158,6 @@ func withStepLogger(ctx context.Context, stepNumber int, stepID, stepName, stage
|
|||
type entryProcessor func(entry *logrus.Entry) *logrus.Entry
|
||||
|
||||
func valueMasker(insecureSecrets bool, secrets map[string]string) entryProcessor {
|
||||
secrets = maps.Clone(secrets)
|
||||
return func(entry *logrus.Entry) *logrus.Entry {
|
||||
if insecureSecrets {
|
||||
return entry
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue