Add rhel8-package.yml that builds a RHEL8 install package from a tag
using the prebuilt RHEL8 CI container. It configures with an install
prefix, builds the install target, runs the CPack package target, and
uploads the resulting *.tar.gz as the ResInsight-RHEL8 artifact.
Wire the new workflow into release-draft.yml so the draft release waits
for the RHEL8 package run and attaches the *.tar.gz directly, alongside
the existing zipped platform artifacts.
The vcpkg binary cache was restored on every Windows run, but vcpkg rejected all binaries and rebuilt from source. vcpkg keys each binary by an ABI hash that includes the MSVC toolset version, which was not part of the cache key (only OS, compiler name, vcpkg submodule SHA and the vcpkg-configuration.json hash). When the runner image bumps MSVC, the restored binaries become ABI-incompatible and vcpkg rebuilds everything. Because the cache key stays unchanged, the action skips saving the freshly built binaries, so the stale entry can never refresh and the rebuild loop persists across runs.
Add the MSVC toolset version (VCToolsVersion, exported by the MSVC setup step) to the cache key on Windows. A toolset bump now yields a new key, producing one cold rebuild followed by a successful save under the new key, after which subsequent runs restore from cache.
On a tag push, wait for the Windows/Linux build (ResInsightWithCache.yml)
and the macOS build (ResInsightMac.yml) to finish, download their
application artifacts, zip them per platform, and create a draft GitHub
Release with the archives attached for maintainer review.
Plain pip has no time-based cutoff, so route the workflow's package
installs through uv and set UV_EXCLUDE_NEWER to refuse releases
published within the last week as supply-chain hardening. Mirror the
policy in the rips pyproject for local uv installs.
* Refactor: add MACOSX_BUNDLE option to qt_add_executable in multiple CMakeLists.txt files
* #14045 macOS: Guard std::stacktrace usage and skip ucontext on Apple platforms
* #14045 macOS: Guard std::ispanstream with std::istringstream fallback
* #14045 macOS: Add vcpkg overlay triplets for osx and exclude grpc on osx
* #14045 macOS: CMake macOS build support and openzgy OpenMP-disable patch
* #14045 CI: Add macOS build workflow
* #14045 macOS: Use feature-test macros to detect <stacktrace> and <spanstream>
* #14045 macOS: Make MAX_STIMPLAN_LAYERS constexpr to fix arm64 link error
* #14045 CI: Ship README-macOS.txt with artifact to document Gatekeeper workaround
* #14045 CI: Pin macOS runner to macos-14 and set deployment target to 14.0
* #14045 CI: Move macOS runner to macos-15 and fix README step on configure failure
vcpkg detects the compiler hash before the CMake toolchain file loads,
so -DCMAKE_C_COMPILER=gcc-14 on the cmake line was too late -- vcpkg
picked up /usr/bin/c++ (gcc-13 on Ubuntu 24.04) and computed an ABI
hash that did not match the gcc-14 entries baked into the image's
/opt/vcpkg-cache-gcc, restoring 0 packages and rebuilding all 102
ports from source. Export CC/CXX in the step env to match the
Dockerfile's vcpkg-builder-gcc stage.
Switches the Copilot Coding Agent's pre-flight job to the prebuilt
ghcr.io/<repo>/ci-ubuntu24 image so the toolchain, Qt, vcpkg cache, and
warm ResInsight buildcache are already provisioned at the start of every
agent session. The setup only fetches source, installs the editable rips
package, and warms an incremental build.
The image's buildcache was baked at /src so source path matching matters
for hit rate. actions/checkout puts source at $GITHUB_WORKSPACE; this
adds a /src -> $GITHUB_WORKSPACE symlink and configures at /src so gcc
command lines reference /src/... and match the baked entries. CMake
records CMAKE_SOURCE_DIR as the string passed to -S without resolving
symlinks, so the indirection is transparent to the build and to Copilot
edits (which still land on the workspace files the symlink points at).
Drops the in-workflow apt/Qt/buildcache restore/vcpkg restore plumbing
that the image now obviates, including the temporary cache-layout
diagnostic block added while debugging the prior restore behavior.
Adds .github/docker/Dockerfile.ubuntu24 -- a multi-stage image bundling gcc-14, clang-19, Qt 6.7.0, the buildcache binary from the canonical GitLab repo, per-compiler vcpkg binary caches, and per-compiler warm ResInsight buildcaches. Published to ghcr.io/<repo>/ci-ubuntu24 by a new nightly build workflow that mirrors the RHEL8 pattern, with a matching daily cleanup workflow that applies the same GHCR retention rules.
Adds .github/workflows/ResInsightWithCacheLinuxContainer.yml -- a parallel companion to the existing Linux legs in ResInsightWithCache.yml, running both compilers in a matrix inside the container with /src as the working directory so buildcache hashes line up with the warmup baked into the image.
The existing ResInsightWithCache.yml Linux legs remain unchanged during the validation phase. copilot-setup-steps.yml will be migrated to the container in a follow-up once the image is proven.
Cache action reports a hit and extracts ~787 MB, but vcpkg then
restores 0 packages from the path it advertises. Same cache key
works on regular GitHub-hosted runners, so the suspicion is a
workspace path mismatch in the Copilot cloud agent's bind-mounted
environment. Add a temporary step to print pwd, GITHUB_WORKSPACE,
the action's output path, and locate any .vcpkg-cache on disk.
The agent does not need a self-contained install tree with Qt staged
next to the binary; skipping the bundle step saves time without
affecting the buildcache/vcpkg cache the agent inherits.
Pre-flight workflow that GitHub Copilot's coding agent runs before each
session. Mirrors the Ubuntu/gcc-14 leg of ResInsightWithCache.yml so it
shares the same buildcache and vcpkg cache keys; the nightly CI run
warms the caches that this job restores.
Does a configure + build so the agent's first edit only recompiles the
translation units it actually touches. Unity build is off so a single
.cpp change doesn't invalidate a whole unity blob's cache entry.
The "Install dependencies" step does an editable install of the rips
package before CMake runs, so the CMake-generated rips/_version.py
does not yet exist and setuptools' attr: directive fails.
Write a dev fallback before pip install. The real version is regenerated
by CMake during the subsequent build step.
Replace legacy setup.py packaging with modern pyproject.toml (PEP 517/518/621).
Version is dynamically resolved via setuptools attr: directive from rips/_version.py,
which CMake generates.
Consolidate requirements.txt, dev-requirements.txt, and build-requirements.txt
into pyproject.toml dependencies and [dev] optional-dependencies.
Consolidate rips/mypy.ini into [tool.mypy] section of pyproject.toml.
Update GitHub Actions workflow and CMakeLists.txt accordingly.
Change the cache key prefix from `clang++-19` to `clang-tidy-19` to ensure the vcpkg cache for the clang-tidy job is isolated from standard build caches.
ruff check --diff only reported fixable violations, silently passing
on unfixable errors like E402. Replace with ruff check (no flags) to
fail CI on all violations. Auto-fix PR creation now only triggers on
failure for same-repo branches.
Add vcpkg-configuration-rhel8.json with an independent baseline that
can be updated separately from the default config. The RHEL8 CI workflow
copies this file over vcpkg-configuration.json before running cmake.
Add vcpkg-readme.md documenting the configuration files and their usage.
Switch from black to ruff for Python code linting and formatting.
Ruff provides both linting (ruff check) and formatting (ruff format)
in a single fast tool.
Use of Azure for caching is not working well for private forks of ResInsight. Use a custom vcpkg-cache to store binaries on Github cache.
https://github.com/TAServers/vcpkg-cache
This reverts commit 006a316749.
This reverts commit 1101d74b69.
Make vcpkg binary caching conditional on secret availability. When
AZURE_VCPKG_STORAGE_ACCOUNT is not available (fork PRs), fall back to
building dependencies from source instead of failing.
The peter-evans/create-pull-request action fails for fork PRs because
it tries to fetch a branch that only exists in the fork. Add conditional
logic to handle fork PRs differently:
- Fork PRs: Run black --check --diff and fail if formatting issues exist
- Same-repo PRs and pushes: Keep existing behavior (run black, create fix PR)
Creates a GitHub Actions workflow to automatically bump the ResInsight dev version number and create a pull request to the dev branch.
This workflow allows for automated incrementing of the `-dev.XX` version suffix upon manual trigger, ensuring consistent versioning and simplifying the release process.
Magne Sjaastad
dependabot[bot]
copilot-swe-agent[bot]andmagnesj
Kristian Bendiksen