mirror of https://github.com/aya-rs/aya
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
620 lines
23 KiB
Plaintext
620 lines
23 KiB
Plaintext
use root/github/actions/third/actions/cache/ref_v4::cache
|
|
use root/github/actions/third/actions/checkout/ref_v5::checkout
|
|
use root/github/actions/third/david_anson/markdownlint_cli2_action/ref_v20::markdownlintCli2Action
|
|
use root/github/actions/third/dtolnay/rust_toolchain/ref_nightly::rustToolchain as RefNightlyrustToolchain
|
|
use root/github/actions/third/dtolnay/rust_toolchain/ref_stable::rustToolchain as RefStablerustToolchain
|
|
use root/github/actions/third/peter_evans/create_pull_request/ref_v7::createPullRequest
|
|
use root/github/actions/third/swatinem/rust_cache/ref_v2::rustCache
|
|
use root/github/actions/third/taiki_e/install_action/ref_cargo_hack::installAction as RefCargoHackinstallAction
|
|
use root/github/actions/third/taiki_e/install_action/ref_v2::installAction as RefV2installAction
|
|
use root/github/actions/third/taiki_e/setup_cross_toolchain_action/ref_v1::setupCrossToolchainAction
|
|
use cicd/services/github::githubJobResult
|
|
use cicd/services/github::includeNeeds
|
|
use cicd/services/github::prepareContexts
|
|
use cicd/services/github::runAction
|
|
use javascript::JavaScriptEngine
|
|
use json/value::|null
|
|
use json::Json
|
|
use log/logger::Logger
|
|
use std/data/string_map::StringMap
|
|
use std/data/string_map::|entry
|
|
use std/data/string_map::|map
|
|
use std/flow/concentrate::Concentrator
|
|
use std/flow/concentrate::concentrateBlock
|
|
use std/flow/concentrate::concentrated
|
|
use std/flow::trigger
|
|
use std/ops/option::|wrap
|
|
|
|
treatment buildTestAyaAll[logger: Logger](
|
|
var github_contexts: string
|
|
)
|
|
input trigger: Block<void>
|
|
output finished: Block<void>
|
|
model finishConcentrator: Concentrator()
|
|
{
|
|
aarch64: buildTestAya[logger=logger](target_arch="aarch64-unknown-linux-gnu", github_contexts=github_contexts)
|
|
armv7: buildTestAya[logger=logger](target_arch="armv7-unknown-linux-gnueabi", github_contexts=github_contexts)
|
|
powerpc64le: buildTestAya[logger=logger](target_arch="powerpc64le-unknown-linux-gnu", github_contexts=github_contexts)
|
|
riscv64gc: buildTestAya[logger=logger](target_arch="riscv64gc-unknown-linux-gnu", github_contexts=github_contexts)
|
|
s390x: buildTestAya[logger=logger](target_arch="s390x-unknown-linux-gnu", github_contexts=github_contexts)
|
|
x86_64: buildTestAya[logger=logger](target_arch="x86_64-unknown-linux-gnu", github_contexts=github_contexts)
|
|
|
|
aarch64Finished: concentrateBlock<void>[concentrator = finishConcentrator]()
|
|
armv7Finished: concentrateBlock<void>[concentrator = finishConcentrator]()
|
|
powerpc64leFinished: concentrateBlock<void>[concentrator = finishConcentrator]()
|
|
riscv64gcFinished: concentrateBlock<void>[concentrator = finishConcentrator]()
|
|
s390xFinished: concentrateBlock<void>[concentrator = finishConcentrator]()
|
|
x86_64Finished: concentrateBlock<void>[concentrator = finishConcentrator]()
|
|
|
|
|
|
Self.trigger -> aarch64.trigger,finished -> aarch64Finished.data
|
|
Self.trigger -> armv7.trigger,finished -> armv7Finished.data
|
|
Self.trigger -> powerpc64le.trigger,finished -> powerpc64leFinished.data
|
|
Self.trigger -> riscv64gc.trigger,finished -> riscv64gcFinished.data
|
|
Self.trigger -> s390x.trigger,finished -> s390xFinished.data
|
|
Self.trigger -> x86_64.trigger,finished -> x86_64Finished.data
|
|
|
|
finish: concentrated<void>[concentrator = finishConcentrator]()
|
|
finishTrigger: trigger<void>()
|
|
|
|
Self.trigger -> finish.trigger,data -> finishTrigger.stream,end -> Self.finished
|
|
}
|
|
|
|
#[job(buildTestAya)]
|
|
#[generated(true)]
|
|
treatment buildTestAya[logger: Logger](
|
|
var github_contexts: string,
|
|
var target_arch: string
|
|
)
|
|
input trigger: Block<void>
|
|
output finished: Block<void>
|
|
output result: Block<Json>
|
|
model contexts: JavaScriptEngine()
|
|
{
|
|
|
|
|
|
jobResult: githubJobResult[contexts = contexts](
|
|
local_context = |null(
|
|
|
|
),
|
|
name = "buildTestAya",
|
|
outputs = |map(
|
|
[]
|
|
)
|
|
)
|
|
prepareContexts[contexts = contexts](
|
|
github_contexts = github_contexts
|
|
)
|
|
step0: checkout[contexts = contexts, logger = logger]()
|
|
step1: RefStablerustToolchain[contexts = contexts, logger = logger](
|
|
targets = target_arch
|
|
)
|
|
step2: rustCache[contexts = contexts, logger = logger]()
|
|
step3: RefCargoHackinstallAction[contexts = contexts, logger = logger]()
|
|
step4: setupCrossToolchainAction[contexts = contexts, logger = logger](
|
|
target = target_arch
|
|
)
|
|
build: runAction[contexts = contexts, logger = logger](
|
|
commands = ${
|
|
set -euxo pipefail
|
|
cargo hack build --all-targets --feature-powerset \
|
|
--exclude aya-ebpf \
|
|
--exclude aya-ebpf-bindings \
|
|
--exclude aya-log-ebpf \
|
|
--exclude integration-ebpf \
|
|
--exclude xtask \
|
|
--workspace
|
|
},
|
|
display_name = "Build",
|
|
name = "build"
|
|
)
|
|
test: runAction[contexts = contexts, logger = logger](
|
|
commands = ${set -euxo pipefail
|
|
cargo hack test --all-targets --feature-powerset \
|
|
--exclude aya-ebpf \
|
|
--exclude aya-ebpf-bindings \
|
|
--exclude aya-log-ebpf \
|
|
--exclude integration-ebpf \
|
|
--exclude integration-test \
|
|
--exclude xtask \
|
|
--workspace
|
|
},
|
|
display_name = "Test",
|
|
env = |wrap<StringMap>(
|
|
|map(
|
|
[|entry(
|
|
"RUST_BACKTRACE",
|
|
"full"
|
|
)]
|
|
)
|
|
),
|
|
name = "test"
|
|
)
|
|
doctests: runAction[contexts = contexts, logger = logger](
|
|
commands = ${
|
|
set -euxo pipefail
|
|
cargo hack test --doc --feature-powerset \
|
|
--exclude aya-ebpf \
|
|
--exclude aya-ebpf-bindings \
|
|
--exclude aya-log-ebpf \
|
|
--exclude init \
|
|
--exclude integration-ebpf \
|
|
--exclude integration-test \
|
|
--exclude xtask \
|
|
--workspace
|
|
},
|
|
display_name = "Doctests",
|
|
env = |wrap<StringMap>(
|
|
|map(
|
|
[|entry(
|
|
"RUST_BACKTRACE",
|
|
"full"
|
|
)]
|
|
)
|
|
),
|
|
name = "doctests"
|
|
)
|
|
|
|
Self.trigger -> prepareContexts.trigger
|
|
prepareContexts.ready -> step0.trigger
|
|
step0.continue -> step1.trigger
|
|
step1.continue -> step2.trigger
|
|
step2.continue -> step3.trigger
|
|
step3.continue -> step4.trigger
|
|
step4.continue -> build.trigger
|
|
build.continue -> test.trigger
|
|
test.continue -> doctests.trigger
|
|
doctests.continue -> jobResult.trigger_release
|
|
jobResult.result -> Self.result
|
|
jobResult.finished -> Self.finished
|
|
jobResult.finished -> step0.post_trigger
|
|
jobResult.finished -> step2.post_trigger
|
|
}
|
|
|
|
#[generated(true)]
|
|
#[job(buildTestAyaEbpf)]
|
|
treatment buildTestAyaEbpf[logger: Logger](
|
|
var github_contexts: string
|
|
)
|
|
input trigger: Block<void>
|
|
output finished: Block<void>
|
|
output result: Block<Json>
|
|
model contexts: JavaScriptEngine()
|
|
{
|
|
build: runAction[contexts = contexts, logger = logger](
|
|
commands = ${{{set -euxo pipefail
|
|
cargo +nightly hack build \
|
|
--target ${{ matrix.target }} \
|
|
-Z build-std=core \
|
|
--package aya-ebpf \
|
|
--package aya-log-ebpf \
|
|
--feature-powerset
|
|
}}},
|
|
display_name = "Build",
|
|
env = |wrap<StringMap>(
|
|
|map(
|
|
[|entry(
|
|
"CARGO_CFG_BPF_TARGET_ARCH",
|
|
"${{ matrix.bpf_target_arch }}"
|
|
)]
|
|
)
|
|
),
|
|
name = "build"
|
|
)
|
|
jobResult: githubJobResult[contexts = contexts](
|
|
local_context = |null(
|
|
|
|
),
|
|
name = "buildTestAyaEbpf",
|
|
outputs = |map(
|
|
[]
|
|
)
|
|
)
|
|
prepareContexts[contexts = contexts](
|
|
github_contexts = github_contexts
|
|
)
|
|
step0: checkout[contexts = contexts, logger = logger]()
|
|
step1: RefNightlyrustToolchain[contexts = contexts, logger = logger](
|
|
components = "rust-src"
|
|
)
|
|
step2: RefStablerustToolchain[contexts = contexts, logger = logger]()
|
|
step3: rustCache[contexts = contexts, logger = logger]()
|
|
step4: runAction[contexts = contexts, logger = logger](
|
|
commands = "cargo install --git https://github.com/aya-rs/bpf-linker.git bpf-linker --features llvm-21",
|
|
name = "step4"
|
|
)
|
|
step5: RefCargoHackinstallAction[contexts = contexts, logger = logger]()
|
|
test: runAction[contexts = contexts, logger = logger](
|
|
commands = ${set -euxo pipefail
|
|
cargo hack test \
|
|
--doc \
|
|
--package aya-ebpf \
|
|
--package aya-log-ebpf \
|
|
--feature-powerset
|
|
},
|
|
display_name = "Test",
|
|
env = |wrap<StringMap>(
|
|
|map(
|
|
[|entry(
|
|
"RUST_BACKTRACE",
|
|
"full"
|
|
),
|
|
|entry(
|
|
"CARGO_CFG_BPF_TARGET_ARCH",
|
|
"${{ matrix.bpf_target_arch }}"
|
|
)]
|
|
)
|
|
),
|
|
name = "test"
|
|
)
|
|
|
|
Self.trigger -> prepareContexts.trigger
|
|
prepareContexts.ready -> step0.trigger
|
|
step0.continue -> step1.trigger
|
|
step1.continue -> step2.trigger
|
|
step2.continue -> step3.trigger
|
|
step3.continue -> step4.trigger
|
|
step4.continue -> step5.trigger
|
|
step5.continue -> build.trigger
|
|
build.continue -> test.trigger
|
|
test.continue -> jobResult.trigger_release
|
|
jobResult.result -> Self.result
|
|
jobResult.finished -> Self.finished
|
|
jobResult.finished -> step0.post_trigger
|
|
jobResult.finished -> step3.post_trigger
|
|
}
|
|
|
|
#[generated(true)]
|
|
#[job(buildWorkflowComplete)]
|
|
treatment buildWorkflowComplete[logger: Logger](
|
|
var github_contexts: string
|
|
)
|
|
#[job(build-test-aya)]
|
|
input need_build_test_aya: Block<Json>
|
|
#[job(build-test-aya-ebpf)]
|
|
input need_build_test_aya_ebpf: Block<Json>
|
|
#[job(lint)]
|
|
input need_lint: Block<Json>
|
|
#[job(run-integration-test)]
|
|
input need_run_integration_test: Block<Json>
|
|
input trigger: Block<void>
|
|
output finished: Block<void>
|
|
output result: Block<Json>
|
|
model contexts: JavaScriptEngine()
|
|
model readinessConcentrator: Concentrator()
|
|
{
|
|
includeNeedsBuildTestAya: includeNeeds[contexts = contexts](
|
|
from = "build-test-aya"
|
|
)
|
|
includeNeedsBuildTestAyaEbpf: includeNeeds[contexts = contexts](
|
|
from = "build-test-aya-ebpf"
|
|
)
|
|
includeNeedsBuildTestAyaEbpfReady: concentrateBlock<void>[concentrator = readinessConcentrator]()
|
|
includeNeedsBuildTestAyaReady: concentrateBlock<void>[concentrator = readinessConcentrator]()
|
|
includeNeedsLint: includeNeeds[contexts = contexts](
|
|
from = "lint"
|
|
)
|
|
includeNeedsLintReady: concentrateBlock<void>[concentrator = readinessConcentrator]()
|
|
includeNeedsRunIntegrationTest: includeNeeds[contexts = contexts](
|
|
from = "run-integration-test"
|
|
)
|
|
includeNeedsRunIntegrationTestReady: concentrateBlock<void>[concentrator = readinessConcentrator]()
|
|
jobResult: githubJobResult[contexts = contexts](
|
|
local_context = |null(
|
|
|
|
),
|
|
name = "buildWorkflowComplete",
|
|
outputs = |map(
|
|
[]
|
|
)
|
|
)
|
|
prepareContexts[contexts = contexts](
|
|
github_contexts = github_contexts
|
|
)
|
|
readiness: concentrated<void>[concentrator = readinessConcentrator]()
|
|
readinessTrigger: trigger<void>()
|
|
step0: runAction[contexts = contexts, logger = logger](
|
|
commands = "echo 'Build Complete'",
|
|
name = "step0"
|
|
)
|
|
|
|
Self.trigger -> prepareContexts.trigger
|
|
Self.need_lint -> includeNeedsLint.needs
|
|
prepareContexts.ready -> includeNeedsLint.trigger
|
|
includeNeedsLint.ready -> includeNeedsLintReady.data
|
|
Self.need_build_test_aya -> includeNeedsBuildTestAya.needs
|
|
prepareContexts.ready -> includeNeedsBuildTestAya.trigger
|
|
includeNeedsBuildTestAya.ready -> includeNeedsBuildTestAyaReady.data
|
|
Self.need_build_test_aya_ebpf -> includeNeedsBuildTestAyaEbpf.needs
|
|
prepareContexts.ready -> includeNeedsBuildTestAyaEbpf.trigger
|
|
includeNeedsBuildTestAyaEbpf.ready -> includeNeedsBuildTestAyaEbpfReady.data
|
|
Self.need_run_integration_test -> includeNeedsRunIntegrationTest.needs
|
|
prepareContexts.ready -> includeNeedsRunIntegrationTest.trigger
|
|
includeNeedsRunIntegrationTest.ready -> includeNeedsRunIntegrationTestReady.data
|
|
Self.trigger -> readiness.trigger
|
|
readiness.data -> readinessTrigger.stream
|
|
readinessTrigger.last -> step0.trigger
|
|
step0.continue -> jobResult.trigger_release
|
|
jobResult.result -> Self.result
|
|
jobResult.finished -> Self.finished
|
|
}
|
|
|
|
#[generated(true)]
|
|
#[job(lint)]
|
|
treatment lint[logger: Logger](
|
|
var github_contexts: string
|
|
)
|
|
input trigger: Block<void>
|
|
output finished: Block<void>
|
|
output result: Block<Json>
|
|
model contexts: JavaScriptEngine()
|
|
{
|
|
jobResult: githubJobResult[contexts = contexts](
|
|
local_context = |null(
|
|
|
|
),
|
|
name = "lint",
|
|
outputs = |map(
|
|
[]
|
|
)
|
|
)
|
|
prepareContexts[contexts = contexts](
|
|
github_contexts = github_contexts
|
|
)
|
|
runMiri: runAction[contexts = contexts, logger = logger](
|
|
commands = ${set -euxo pipefail
|
|
cargo +nightly hack miri test --all-targets --feature-powerset \
|
|
--exclude aya-ebpf \
|
|
--exclude aya-ebpf-bindings \
|
|
--exclude aya-log-ebpf \
|
|
--exclude integration-ebpf \
|
|
--exclude integration-test \
|
|
--workspace
|
|
},
|
|
display_name = "Run miri",
|
|
name = "runMiri"
|
|
)
|
|
step0: checkout[contexts = contexts, logger = logger]()
|
|
step1: RefNightlyrustToolchain[contexts = contexts, logger = logger](
|
|
components = "clippy,miri,rustfmt,rust-src"
|
|
)
|
|
step10: runAction[contexts = contexts, logger = logger](
|
|
commands = "cargo xtask public-api",
|
|
if = "${{ !(github.event_name == 'schedule' && github.repository == 'aya-rs/aya') }}",
|
|
name = "step10"
|
|
)
|
|
step11: runAction[contexts = contexts, logger = logger](
|
|
commands = "cargo xtask public-api --bless",
|
|
if = "${{ (github.event_name == 'schedule' && github.repository == 'aya-rs/aya') }}",
|
|
name = "step11"
|
|
)
|
|
step12: createPullRequest[contexts = contexts, logger = logger](
|
|
body = ${**Automated changes**
|
|
},
|
|
branch = "create-pull-request/public-api",
|
|
commit_message = "public-api: regenerate",
|
|
title = "public-api: regenerate",
|
|
token = "${{ secrets.CRABBY_GITHUB_TOKEN }}"
|
|
)
|
|
step2: RefStablerustToolchain[contexts = contexts, logger = logger]()
|
|
step3: rustCache[contexts = contexts, logger = logger]()
|
|
step4: RefV2installAction[contexts = contexts, logger = logger](
|
|
tool = "cargo-hack,taplo-cli"
|
|
)
|
|
step5: runAction[contexts = contexts, logger = logger](
|
|
commands = "git ls-files -- '*.c' '*.h' | xargs clang-format --dry-run --Werror",
|
|
name = "step5"
|
|
)
|
|
step6: markdownlintCli2Action[contexts = contexts, logger = logger]()
|
|
step7: runAction[contexts = contexts, logger = logger](
|
|
commands = "taplo fmt --check",
|
|
name = "step7"
|
|
)
|
|
step8: runAction[contexts = contexts, logger = logger](
|
|
commands = "cargo +nightly fmt --all -- --check",
|
|
name = "step8"
|
|
)
|
|
step9: runAction[contexts = contexts, logger = logger](
|
|
commands = "./clippy.sh",
|
|
name = "step9"
|
|
)
|
|
|
|
Self.trigger -> prepareContexts.trigger
|
|
prepareContexts.ready -> step0.trigger
|
|
step0.continue -> step1.trigger
|
|
step1.continue -> step2.trigger
|
|
step2.continue -> step3.trigger
|
|
step3.continue -> step4.trigger
|
|
step4.continue -> step5.trigger
|
|
step5.continue -> step6.trigger
|
|
step6.continue -> step7.trigger
|
|
step7.continue -> step8.trigger
|
|
step8.continue -> step9.trigger
|
|
step9.continue -> step10.trigger
|
|
step10.continue -> step11.trigger
|
|
step11.continue -> step12.trigger
|
|
step12.continue -> runMiri.trigger
|
|
runMiri.continue -> jobResult.trigger_release
|
|
jobResult.result -> Self.result
|
|
jobResult.finished -> Self.finished
|
|
jobResult.finished -> step0.post_trigger
|
|
jobResult.finished -> step3.post_trigger
|
|
}
|
|
|
|
#[generated(true)]
|
|
#[job(runIntegrationTest)]
|
|
treatment runIntegrationTest[logger: Logger](
|
|
var github_contexts: string
|
|
)
|
|
input trigger: Block<void>
|
|
output finished: Block<void>
|
|
output result: Block<Json>
|
|
model contexts: JavaScriptEngine()
|
|
{
|
|
cleanupStaleKernelsAndModules: runAction[contexts = contexts, logger = logger](
|
|
commands = ${set -euxo pipefail
|
|
rm -rf test/.tmp/boot test/.tmp/lib
|
|
},
|
|
display_name = "Cleanup stale kernels and modules",
|
|
name = "cleanupStaleKernelsAndModules"
|
|
)
|
|
downloadDebianKernels: runAction[contexts = contexts, logger = logger](
|
|
commands = ".github/scripts/download_kernel_images.sh test/.tmp/debian-kernels/arm64 arm64 6.1 6.12",
|
|
display_name = "Download debian kernels",
|
|
if = "runner.arch == 'ARM64'",
|
|
name = "downloadDebianKernels"
|
|
)
|
|
downloadDebianKernels_10: runAction[contexts = contexts, logger = logger](
|
|
commands = ".github/scripts/download_kernel_images.sh test/.tmp/debian-kernels/amd64 amd64 6.1 6.12",
|
|
display_name = "Download debian kernels",
|
|
if = "runner.arch == 'X64'",
|
|
name = "downloadDebianKernels_10"
|
|
)
|
|
extractDebianKernels: runAction[contexts = contexts, logger = logger](
|
|
commands = ${{set -euxo pipefail
|
|
# The wildcard '**/boot/*' extracts kernel images and config.
|
|
# The wildcard '**/modules/*' extracts kernel modules.
|
|
# Modules are required since not all parts of the kernel we want to
|
|
# test are built-in.
|
|
find test/.tmp -name '*.deb' -print0 | xargs -t -0 -I {} \
|
|
sh -c "dpkg --fsys-tarfile {} | tar -C test/.tmp \
|
|
--wildcards --extract '**/boot/*' '**/modules/*' --file -"
|
|
}},
|
|
display_name = "Extract debian kernels",
|
|
name = "extractDebianKernels"
|
|
)
|
|
installLibLlvm: runAction[contexts = contexts, logger = logger](
|
|
commands = ${{{set -euxo pipefail
|
|
# Get the partial SHA from Rust nightly.
|
|
rustc_sha=$(rustc +nightly --version | grep -oE '[a-f0-9]{7,40}')
|
|
# Get the full SHA from GitHub.
|
|
rustc_sha=$(curl -sfSL https://api.github.com/repos/rust-lang/rust/commits/$rustc_sha \
|
|
--header 'authorization: Bearer ${{ secrets.GITHUB_TOKEN }}' \
|
|
--header 'content-type: application/json' \
|
|
| jq -r '.sha')
|
|
mkdir -p /tmp/rustc-llvm
|
|
curl -sfSL https://ci-artifacts.rust-lang.org/rustc-builds/$rustc_sha/rust-dev-nightly-${{ matrix.target }}.tar.xz | \
|
|
tar -xJ --strip-components 2 -C /tmp/rustc-llvm
|
|
echo /tmp/rustc-llvm/bin >> $GITHUB_PATH
|
|
}}},
|
|
display_name = "Install libLLVM",
|
|
name = "installLibLlvm"
|
|
)
|
|
installPrerequisites: runAction[contexts = contexts, logger = logger](
|
|
commands = ${{set -euxo pipefail
|
|
sudo apt update
|
|
sudo apt -y install lynx qemu-system-{arm,x86} musl-tools
|
|
echo /usr/lib/llvm-15/bin >> $GITHUB_PATH
|
|
}},
|
|
display_name = "Install prerequisites",
|
|
if = "runner.os == 'Linux'",
|
|
name = "installPrerequisites"
|
|
)
|
|
installPrerequisites_2: runAction[contexts = contexts, logger = logger](
|
|
commands = ${{set -euxo pipefail
|
|
brew update
|
|
# https://github.com/actions/setup-python/issues/577
|
|
find /usr/local/bin -type l -exec sh -c 'readlink -f "$1" \
|
|
| grep -q ^/Library/Frameworks/Python.framework/Versions/' _ {} \; -exec rm -v {} \;
|
|
brew install --formula curl dpkg gnu-tar llvm lynx pkg-config qemu
|
|
echo $(brew --prefix curl)/bin >> $GITHUB_PATH
|
|
echo $(brew --prefix gnu-tar)/libexec/gnubin >> $GITHUB_PATH
|
|
echo $(brew --prefix llvm)/bin >> $GITHUB_PATH
|
|
brew install filosottile/musl-cross/musl-cross
|
|
ln -s "$(brew --prefix musl-cross)/bin/x86_64-linux-musl-gcc" /usr/local/bin/musl-gcc
|
|
}},
|
|
display_name = "Install prerequisites",
|
|
if = "runner.os == 'macOS'",
|
|
name = "installPrerequisites_2"
|
|
)
|
|
jobResult: githubJobResult[contexts = contexts](
|
|
local_context = |null(
|
|
|
|
),
|
|
name = "runIntegrationTest",
|
|
outputs = |map(
|
|
[]
|
|
)
|
|
)
|
|
prepareContexts[contexts = contexts](
|
|
github_contexts = github_contexts
|
|
)
|
|
runLocalIntegrationTests: runAction[contexts = contexts, logger = logger](
|
|
commands = "cargo xtask integration-test local",
|
|
display_name = "Run local integration tests",
|
|
if = "runner.os == 'Linux'",
|
|
name = "runLocalIntegrationTests"
|
|
)
|
|
runVirtualizedIntegrationTests: runAction[contexts = contexts, logger = logger](
|
|
commands = ${{{set -euxo pipefail
|
|
.github/scripts/find_kernels.py | xargs -t -0 \
|
|
cargo xtask integration-test vm --cache-dir test/.tmp \
|
|
--github-api-token ${{ secrets.GITHUB_TOKEN }} \
|
|
}}},
|
|
display_name = "Run virtualized integration tests",
|
|
if = "runner.os == 'Linux'",
|
|
name = "runVirtualizedIntegrationTests"
|
|
)
|
|
runVirtualizedIntegrationTests_15: runAction[contexts = contexts, logger = logger](
|
|
commands = ${{{set -euxo pipefail
|
|
.github/scripts/find_kernels.py | xargs -t -0 \
|
|
cargo xtask integration-test vm --cache-dir test/.tmp \
|
|
--github-api-token ${{ secrets.GITHUB_TOKEN }} \
|
|
}}},
|
|
display_name = "Run virtualized integration tests",
|
|
env = |wrap<StringMap>(
|
|
|map(
|
|
[|entry(
|
|
"CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER",
|
|
"x86_64-linux-musl-gcc"
|
|
)]
|
|
)
|
|
),
|
|
if = "runner.os == 'macOS'",
|
|
name = "runVirtualizedIntegrationTests_15"
|
|
)
|
|
step0: checkout[contexts = contexts, logger = logger](
|
|
submodules = "recursive"
|
|
)
|
|
step3: RefNightlyrustToolchain[contexts = contexts, logger = logger](
|
|
components = "rust-src"
|
|
)
|
|
step4: RefStablerustToolchain[contexts = contexts, logger = logger](
|
|
targets = "aarch64-unknown-linux-musl,x86_64-unknown-linux-musl"
|
|
)
|
|
step5: rustCache[contexts = contexts, logger = logger]()
|
|
step7: runAction[contexts = contexts, logger = logger](
|
|
commands = "cargo install --git https://github.com/aya-rs/bpf-linker.git bpf-linker --no-default-features --features llvm-21 --force",
|
|
name = "step7"
|
|
)
|
|
step8: cache[contexts = contexts, logger = logger](
|
|
key = "${{ runner.arch }}-${{ runner.os }}-test-cache",
|
|
path = "test/.tmp"
|
|
)
|
|
|
|
Self.trigger -> prepareContexts.trigger
|
|
prepareContexts.ready -> step0.trigger
|
|
step0.continue -> installPrerequisites.trigger
|
|
installPrerequisites.continue -> installPrerequisites_2.trigger
|
|
installPrerequisites_2.continue -> step3.trigger
|
|
step3.continue -> step4.trigger
|
|
step4.continue -> step5.trigger
|
|
step5.continue -> installLibLlvm.trigger
|
|
installLibLlvm.continue -> step7.trigger
|
|
step7.continue -> step8.trigger
|
|
step8.continue -> downloadDebianKernels.trigger
|
|
downloadDebianKernels.continue -> downloadDebianKernels_10.trigger
|
|
downloadDebianKernels_10.continue -> cleanupStaleKernelsAndModules.trigger
|
|
cleanupStaleKernelsAndModules.continue -> extractDebianKernels.trigger
|
|
extractDebianKernels.continue -> runLocalIntegrationTests.trigger
|
|
runLocalIntegrationTests.continue -> runVirtualizedIntegrationTests.trigger
|
|
runVirtualizedIntegrationTests.continue -> runVirtualizedIntegrationTests_15.trigger
|
|
runVirtualizedIntegrationTests_15.continue -> jobResult.trigger_release
|
|
jobResult.result -> Self.result
|
|
jobResult.finished -> Self.finished
|
|
jobResult.finished -> step0.post_trigger
|
|
jobResult.finished -> step5.post_trigger
|
|
jobResult.finished -> step8.post_trigger
|
|
}
|
|
|