mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 13:51:19 +01:00
The Komorebi License lets anyone distribute the source code but not binaries, so the flake has no public binary cache and the binaries of komorebi come only from this repository. The `build` job builds `komorebi` and `komorebic` with nix on every run, on ubuntu-24.04 and on ubuntu-24.04-arm, and keeps them as an artifact for 14 days; the arm64 job is `continue-on-error`. As nix builds them, the binaries load libc, libm and libgcc_s through the dynamic loader of the store and an RPATH into it, which only a machine with the same nixpkgs revision in its store has. The job points them at the system's loader at its standard path and drops the RPATH, with patchelf from the nixpkgs flake.lock pins, then runs `--version` on the Ubuntu runner to check that they start. Built from the locked nixpkgs (d3b13ad), the newest glibc symbol version they need is 2.39, the glibc of Ubuntu 24.04. The `publish` job runs on a `v*` tag, and on a scheduled or manual run on master, once lint, vm-fast and build have passed. It zips the two binaries of each architecture as `komorebi-<version>-<target>.zip` (an architecture whose build failed is left out with a warning), adds schema.json, the schema of komorebi.json, when the repository has one (it does), and writes checksums.txt with sha256sum. The release notes are kokai's, from the commit messages since the previous version tag, as komorebi for Mac writes them; kokai is not in nixpkgs, so cargo installs it, pinned at 0.3.1. A tag becomes a release. master replaces the rolling `nightly` prerelease and its tag; the old nightly tag is moved to the commit first, so that the notes list the commits since the last version and not since the last nightly. There is no Homebrew, winget or second repository. The cache key of the composite action gets the runner's architecture: the arm64 runner has the same `runner.os` as the x86_64 one, and would restore and save the other's store. The steps were run as written on aarch64 and x86_64 machines: the builds, whose binaries then started in Ubuntu 24.04 root filesystems of both architectures, and a first nightly, a later nightly and a tag release against a fake gh. GitHub Actions has not run them yet. CONTRIBUTING.md says how a release is made, the README where binaries come from and what the license allows, and DESIGN.md why. The pages that said there were no prebuilt binaries (README, installation.md and the entry on the binary cache in DESIGN.md) now say that the releases are the only ones.
325 lines
13 KiB
YAML
325 lines
13 KiB
YAML
# Every job is gated on the repository, so that a fork does not run them on its own runners.
|
|
|
|
name: ci
|
|
|
|
on:
|
|
pull_request:
|
|
branches:
|
|
- "*"
|
|
push:
|
|
branches:
|
|
- master
|
|
- feature/*
|
|
- hotfix/*
|
|
tags:
|
|
- v*
|
|
schedule:
|
|
- cron: "30 0 * * 0" # Every Sunday at 00:30 UTC
|
|
workflow_dispatch:
|
|
|
|
jobs:
|
|
cargo-deny:
|
|
if: github.repository == 'LGUG2Z/komorebi-for-kde'
|
|
runs-on: ubuntu-24.04
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
with:
|
|
fetch-depth: 0
|
|
- uses: EmbarkStudios/cargo-deny-action@v2
|
|
|
|
# Everything that does not need a virtual machine: the formatting, clippy, rustdoc, the tests and
|
|
# the VM library's own tests, as derivations. The jobs that boot KWin are separate, and `nix flake
|
|
# check` is not used here because on Linux it would run those suites with no KVM.
|
|
lint:
|
|
if: github.repository == 'LGUG2Z/komorebi-for-kde'
|
|
runs-on: ubuntu-24.04
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
with:
|
|
fetch-depth: 0
|
|
- uses: ./.github/actions/nix
|
|
- name: Build every check that needs no virtual machine
|
|
run: |
|
|
nix eval --json .#checks.x86_64-linux --apply builtins.attrNames |
|
|
jq -r '(.[] | select(startswith("vm-") | not)), "vm-lib"' |
|
|
sed 's|^|.#checks.x86_64-linux.|' |
|
|
xargs nix build -L --no-link
|
|
- run: nix develop --command just lint
|
|
|
|
# The suites are found in the flake, so that a new directory under nix/tests/vm/suites is run
|
|
# without an edit here.
|
|
discover:
|
|
if: github.repository == 'LGUG2Z/komorebi-for-kde'
|
|
runs-on: ubuntu-24.04
|
|
outputs:
|
|
fast: ${{ steps.tiers.outputs.fast }}
|
|
slow: ${{ steps.tiers.outputs.slow }}
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
- uses: ./.github/actions/nix
|
|
- id: tiers
|
|
run: |
|
|
tiers=$(nix eval --json .#legacyPackages.x86_64-linux.vmTiers)
|
|
echo "fast=$(jq -c '.fast // []' <<<"$tiers")" >> "$GITHUB_OUTPUT"
|
|
echo "slow=$(jq -c '.slow // []' <<<"$tiers")" >> "$GITHUB_OUTPUT"
|
|
|
|
# The pull request gate: the suites that take minutes, each in its own machine, in a sandboxed
|
|
# `nix build` like any other check.
|
|
vm-fast:
|
|
needs: discover
|
|
if: github.repository == 'LGUG2Z/komorebi-for-kde' && needs.discover.outputs.fast != '[]'
|
|
runs-on: ubuntu-24.04
|
|
timeout-minutes: 45
|
|
strategy:
|
|
fail-fast: false
|
|
matrix:
|
|
suite: ${{ fromJson(needs.discover.outputs.fast) }}
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
- uses: ./.github/actions/nix
|
|
with:
|
|
kvm: "true"
|
|
- run: nix build -L .#checks.x86_64-linux.vm-${{ matrix.suite }}
|
|
|
|
# The suites that draw and move a pointer. They run on master, every week, and on a pull
|
|
# request with the label `ci:vm-slow`. The driver is run by hand, outside the sandbox, so that
|
|
# the screenshots and the journals of a failed run can be uploaded.
|
|
vm-slow:
|
|
needs: discover
|
|
if: >-
|
|
github.repository == 'LGUG2Z/komorebi-for-kde' && needs.discover.outputs.slow != '[]' &&
|
|
(github.ref == 'refs/heads/master' || github.event_name == 'schedule' ||
|
|
github.event_name == 'workflow_dispatch' ||
|
|
contains(github.event.pull_request.labels.*.name, 'ci:vm-slow'))
|
|
runs-on: ubuntu-24.04
|
|
timeout-minutes: 60
|
|
strategy:
|
|
fail-fast: false
|
|
matrix:
|
|
suite: ${{ fromJson(needs.discover.outputs.slow) }}
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
- uses: ./.github/actions/nix
|
|
with:
|
|
kvm: "true"
|
|
- run: nix build -L .#legacyPackages.x86_64-linux.vm.${{ matrix.suite }}.driver -o driver
|
|
- run: mkdir -p out && cd out && ../driver/bin/nixos-test-driver -o .
|
|
- if: always()
|
|
uses: actions/upload-artifact@v7
|
|
with:
|
|
name: vm-${{ matrix.suite }}-${{ github.sha }}
|
|
path: out/
|
|
retention-days: 7
|
|
|
|
# The flake follows the tip of nixpkgs-unstable, so KWin and Plasma change under it whenever
|
|
# flake.lock moves. Every week, and on a manual run, this job moves nixpkgs to the tip in a copy
|
|
# of the checkout and builds every check against it, the VM suites of both tiers included, one
|
|
# after the other on one machine, so that komorebi and the guests are built once. When a check
|
|
# fails, it opens an issue, or comments on the one that is open. Nothing is pushed: the new lock
|
|
# exists only in the copy.
|
|
canary:
|
|
if: >-
|
|
github.repository == 'LGUG2Z/komorebi-for-kde' &&
|
|
(github.event_name == 'schedule' || github.event_name == 'workflow_dispatch')
|
|
runs-on: ubuntu-24.04
|
|
timeout-minutes: 360
|
|
permissions:
|
|
contents: read
|
|
issues: write
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
with:
|
|
persist-credentials: false
|
|
- uses: ./.github/actions/nix
|
|
with:
|
|
kvm: "true"
|
|
cache: "false"
|
|
- name: Move nixpkgs to the tip in a copy of the checkout
|
|
run: |
|
|
cp -a . "$RUNNER_TEMP/canary"
|
|
cd "$RUNNER_TEMP/canary"
|
|
locked=$(nix eval --raw --inputs-from . nixpkgs#kdePackages.kwin.version)
|
|
nix flake update nixpkgs
|
|
rev=$(jq -r .nodes.nixpkgs.locked.rev flake.lock)
|
|
echo "NIXPKGS_REV=$rev" >>"$GITHUB_ENV"
|
|
tip=$(nix eval --raw --inputs-from . nixpkgs#kdePackages.kwin.version)
|
|
echo "KWIN=$tip (flake.lock has $locked)" >>"$GITHUB_ENV"
|
|
- id: build
|
|
name: Build every check against it
|
|
working-directory: ${{ runner.temp }}/canary
|
|
run: |
|
|
failed="$RUNNER_TEMP/canary-failed"
|
|
: >"$failed"
|
|
# the checks that need no virtual machine, as the lint job lists them, then the suites
|
|
# of both tiers, as the discover job lists them
|
|
checks=$(nix eval --json .#checks.x86_64-linux --apply builtins.attrNames |
|
|
jq -r '(.[] | select(startswith("vm-") | not)), "vm-lib"')
|
|
suites=$(nix eval --json .#legacyPackages.x86_64-linux.vmTiers |
|
|
jq -r '(.fast // []) + (.slow // []) | .[] | "vm-" + .')
|
|
for check in $checks $suites; do
|
|
echo "::group::$check"
|
|
nix build -L --no-link ".#checks.x86_64-linux.$check" || echo "$check" >>"$failed"
|
|
echo "::endgroup::"
|
|
done
|
|
test ! -s "$failed"
|
|
- name: Report
|
|
if: always()
|
|
env:
|
|
BUILD: ${{ steps.build.outcome }}
|
|
RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
|
|
run: |
|
|
failed="$RUNNER_TEMP/canary-failed"
|
|
{
|
|
echo "- commit: $GITHUB_SHA"
|
|
if [ -n "${NIXPKGS_REV:-}" ]; then
|
|
echo "- nixpkgs-unstable:" \
|
|
"[\`${NIXPKGS_REV:0:12}\`](https://github.com/NixOS/nixpkgs/commit/$NIXPKGS_REV)${KWIN:+, with KWin $KWIN}"
|
|
else
|
|
echo "- nixpkgs-unstable: the update of flake.lock failed"
|
|
fi
|
|
echo
|
|
if [ -s "$failed" ]; then
|
|
echo "These failed:"
|
|
echo
|
|
while read -r check; do echo "- \`$check\`"; done <"$failed"
|
|
elif [ "$BUILD" = success ]; then
|
|
echo "Every check passed."
|
|
else
|
|
echo "The job failed before it could build the checks."
|
|
fi
|
|
echo
|
|
echo "The logs are in [the run]($RUN_URL)."
|
|
} >"$RUNNER_TEMP/canary.md"
|
|
cat "$RUNNER_TEMP/canary.md" >>"$GITHUB_STEP_SUMMARY"
|
|
- name: Open or update the canary issue
|
|
if: failure()
|
|
env:
|
|
GH_TOKEN: ${{ github.token }}
|
|
run: |
|
|
title="Canary: a check fails against the tip of nixpkgs-unstable"
|
|
number=$(gh issue list --repo "$GITHUB_REPOSITORY" --state open --limit 1000 \
|
|
--json number,title |
|
|
jq -r --arg title "$title" 'map(select(.title == $title)) | first | .number // empty')
|
|
if [ -n "$number" ]; then
|
|
gh issue comment "$number" --repo "$GITHUB_REPOSITORY" --body-file "$RUNNER_TEMP/canary.md"
|
|
else
|
|
gh issue create --repo "$GITHUB_REPOSITORY" --title "$title" \
|
|
--body-file "$RUNNER_TEMP/canary.md"
|
|
fi
|
|
|
|
# komorebi and komorebic for each architecture, kept for 14 days, and what the publish job
|
|
# releases. nix points a binary at the dynamic loader and the libraries of its store, which only a
|
|
# machine with those store paths has, so each binary is pointed at the system's loader instead,
|
|
# at the path every glibc system has it, and run on this Ubuntu runner to show that it works.
|
|
# The arm64 job may fail without failing the run.
|
|
build:
|
|
if: github.repository == 'LGUG2Z/komorebi-for-kde'
|
|
strategy:
|
|
fail-fast: false
|
|
matrix:
|
|
include:
|
|
- target: x86_64-unknown-linux-gnu
|
|
runs-on: ubuntu-24.04
|
|
loader: /lib64/ld-linux-x86-64.so.2
|
|
optional: false
|
|
- target: aarch64-unknown-linux-gnu
|
|
runs-on: ubuntu-24.04-arm
|
|
loader: /lib/ld-linux-aarch64.so.1
|
|
optional: true
|
|
runs-on: ${{ matrix.runs-on }}
|
|
continue-on-error: ${{ matrix.optional }}
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
- uses: ./.github/actions/nix
|
|
- name: Build komorebi and komorebic
|
|
env:
|
|
LOADER: ${{ matrix.loader }}
|
|
run: |
|
|
mkdir bin
|
|
for name in komorebi komorebic; do
|
|
cp "$(nix build -L --no-link --print-out-paths ".#$name")/bin/$name" bin/
|
|
done
|
|
chmod u+w bin/*
|
|
nix run --inputs-from . nixpkgs#patchelf -- --set-interpreter "$LOADER" --remove-rpath bin/*
|
|
echo "the newest glibc symbol version they need:" \
|
|
"$(objdump -T bin/* | grep -o 'GLIBC_[0-9.]*' | sort -uV | tail -n 1)"
|
|
bin/komorebi --version
|
|
bin/komorebic --version
|
|
- uses: actions/upload-artifact@v7
|
|
with:
|
|
name: komorebi-${{ matrix.target }}-${{ github.sha }}
|
|
path: bin/
|
|
retention-days: 14
|
|
|
|
# A push of a `v*` tag makes a release of what the build job made, and a scheduled or manual run
|
|
# on master replaces the rolling `nightly` prerelease, once the lint and the fast VM tier have
|
|
# passed. The release notes are the commit messages since the previous version tag, by kokai.
|
|
publish:
|
|
needs: [lint, vm-fast, build]
|
|
if: >-
|
|
github.repository == 'LGUG2Z/komorebi-for-kde' && (startsWith(github.ref, 'refs/tags/v') ||
|
|
(github.ref == 'refs/heads/master' &&
|
|
(github.event_name == 'schedule' || github.event_name == 'workflow_dispatch')))
|
|
runs-on: ubuntu-24.04
|
|
permissions:
|
|
contents: write
|
|
env:
|
|
GH_TOKEN: ${{ github.token }}
|
|
GH_REPO: ${{ github.repository }}
|
|
steps:
|
|
- uses: actions/checkout@v7
|
|
with:
|
|
fetch-depth: 0
|
|
- name: Decide what is published
|
|
run: |
|
|
if [[ "$GITHUB_REF" == refs/tags/v* ]]; then
|
|
echo "TAG=$GITHUB_REF_NAME" >>"$GITHUB_ENV"
|
|
echo "VERSION=${GITHUB_REF_NAME#v}" >>"$GITHUB_ENV"
|
|
else
|
|
echo "TAG=nightly" >>"$GITHUB_ENV"
|
|
echo "VERSION=nightly" >>"$GITHUB_ENV"
|
|
fi
|
|
- uses: actions/download-artifact@v8
|
|
with:
|
|
pattern: komorebi-*-${{ github.sha }}
|
|
path: artifacts
|
|
- name: Package
|
|
run: |
|
|
mkdir dist
|
|
for target in x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu; do
|
|
build="artifacts/komorebi-$target-$GITHUB_SHA"
|
|
if [ ! -d "$build" ]; then
|
|
echo "::warning::there is no build for $target, so it is not published"
|
|
continue
|
|
fi
|
|
# an artifact does not keep the executable bit
|
|
chmod +x "$build/komorebi" "$build/komorebic"
|
|
zip -j "dist/komorebi-$VERSION-$target.zip" "$build/komorebi" "$build/komorebic"
|
|
done
|
|
- name: Add the schema of komorebi.json
|
|
if: hashFiles('schema.json') != ''
|
|
run: cp schema.json dist/
|
|
- name: Write the checksums
|
|
working-directory: dist
|
|
run: sha256sum -- * >checksums.txt
|
|
- name: Write the release notes
|
|
run: |
|
|
cargo install --locked kokai@0.3.1
|
|
# kokai lists the commits between the tag before the one it is given and that one. The
|
|
# nightly tag of the last run moves to this commit, so that the range starts at the
|
|
# last version.
|
|
if [ "$TAG" = nightly ]; then git tag --force nightly; fi
|
|
kokai release --no-emoji --add-links github:commits,issues --ref "$TAG" \
|
|
>"$RUNNER_TEMP/release-notes.md"
|
|
- name: Publish
|
|
run: |
|
|
if [ "$TAG" = nightly ]; then
|
|
gh release delete nightly --cleanup-tag --yes || true
|
|
gh release create nightly --target "$GITHUB_SHA" --prerelease \
|
|
--title "komorebi for KDE nightly ($GITHUB_SHA)" \
|
|
--notes-file "$RUNNER_TEMP/release-notes.md" dist/*
|
|
else
|
|
gh release create "$TAG" --verify-tag --title "komorebi for KDE $TAG" \
|
|
--notes-file "$RUNNER_TEMP/release-notes.md" dist/*
|
|
fi
|