They're still slightly flaky even with insanely long timeouts, and even when not they waste a huge amount of our runner time sitting and waiting for the DHT to disconnect and reconnect.
Still run on our fedora job to get almost all of the benefit, plus AddressSanitizer is enabled there for better testing synergy.
Commit format is already checked in CI, unlike this template which doesn't
actually enforce anything. Each PR showing "1 task done" clutters the PR list
view.
The installer is only built on release builds. We used to ignore failure to
upload prior to 5fcf86b521. We stopped ignoring
because a07ab89cc8 tried to make our upload
targetted, but it only resolved the issue for the zip, not the installer.
Keep disabled for jobs that produce artifacts to not affect user performance.
Keep disabled for other distros that don't produce artifacts as well since other versions of Qt fail themselves in e.g. TestSmileyPack's QGuiApplication usage.
Don't enable thread sanitizer yet due to many Qt internal errors.
This should still give us a significant increase in qTox coverage, even if we have low platform coverage.
Changed in 41a555def9, I think by accident.
Causes our release uploader to no longer replace the old version, instead
adding a new version each time it runs.
Keeping named overwrite instead of removing release artifacts and
uploading new ones, since removing old artifacts would require a new job
that all other jobs depend on to avoid re-removing, and would also
create a gap while CI is running run where no artifact is available.
We could upload artifacts using actions/upload-artifact in each job then
download them at the end and update the release at that point too, if we
really want to keep sha name in the nightly release artifacts. I don't
see much value of having the sha in the filename though.
Hasn't been run since the travis days.
Now managed through a deploy key rather than an access token to limit scope to
a single repo. Private key is stored in qTox/qTox as a repository secret, and
the public portion is saved to qTox/doxygen as a deploy key.
They're not platform dependent and the rest of our jobs run on ubuntu-latest.
Might as well move this one over so we don't have to remember to update it.
gitstats is not available in repo any longer, so install manually.
We've only been updating translatable strings for Weblate rarely based on
MAINTAINING.md#translations-from-weblate. Since Weblate pulls in commits live
from qTox, we should generate the translatable strings as soon as they're
introduced so that translators can not waste time translating deleted strings,
and can spend time translating new strings.
We can't auto-commit the changes in CI due to our requirement of signed
commits, so just fail CI if any new strings are found.
Move it into its own job, it doesn't depend on docker or the build, and doesn't need to run for debug/release/full/minimal
* Since nightlies are now published under qTox/qTox, different update
info is not needed for the zsync file.
* The github action yaml already handles naming files correctly
otherwise.
Hasn't been run since the travis days.
Now managed through a deploy key rather than an access token to limit scope to
a single repo. Private key is stored in qTox/qTox as a repository secret, and
the public portion is saved to qTox/gitstats as a deploy key.
By default our organization on GH only grants a more restricted read
permission to actions for content APIs, which include both writing to
repo for nightly tag creation, and writing to releases for nightly and
tag release creation or updates.
Release will be created as a draft, remaining private until manually published.
All generated artifacts will be uploaded, but will still need to be signed, and
the code archives still need to be created following
MAINTAINING.md#after-tagging
Fix#6345
* Tag is required to create a release, so tag "nightly" is moved to
latest commit on each run.
* Each time the tag is moved, the existing "nightly" release is updated
automatically by github to point to the new tag and bundle the new
commit's source code.
* Artifacts are uploaded with intentionally conflicting names to replace
last commit's version of artifacts, rather than deleting the whole
release and making a new one.
* This has two benefits, it doesn't notify of a new release on each
commit, and it doesn't leave a gap where there's no nightly release
available.
* It is only partially covered by CI and doesn't simplify the build process
much for users. Replacing it in CI with just build-osx.sh significantly reduces
script complexity and is fully tested.
* bootstrap-osx.sh copying system libs and headers locally is unneeded.
Already the DMG file contains them, and re-linking the app against
updated system files may be desirable.
* Update INSTALL.md for macOS to use brewfile, use common dependency build
scripts, and use cmake rather than wrapper scripts.
* Build macOS in Release mode in CI, for release artifact creation
* Don't copy all used libs into a local folder, macdeployerqt already
handles this for the dmg, and for local running of the app using the
system libs and relinking on update is desirable to avoid running out of
date dependencies unexpectedly.
Motiviation:
* Reproducing issues in CI is currently difficult
* Predicting issues in CI is currently difficult if you are not on
ubuntu 18.04
* Reproducing issues submitted from other distros is currently done by
creating a VM of that distro and building qtox for it locally
* Documentation for how to build on different distros is out of date
* Issues on non-ubuntu distributions are not caught by CI
* Cross compiling for windows locally is not trivial
* Iterating when working with custom build scripts is slow, scripts
don't necessarily support re-running without re-starting the docker
container and re-building qtox again
* Updating dependencies is a pain
Changes:
* docker-compose file has been added to the root of our repo.
After `docker compose run --rm ubuntu` (or other supported distros),
you are ready to compile and run qtox
* Dependencies are owned by dependency install scripts in buildscripts/.
This allows us to use the same exact dependencies in our
OSX/windows/linux scripts
* New docker images have been added for a variety of distributions.
These are now run in CI in a variety of configurations
* Docker images are cached in CI so rebuild time for the majority of
jobs is quite quick
* Build scripts have been trimmed to leverage state of docker
containers.
* Windows build script no longer installs anything, dependencies are
now managed by the windows_builder docker images
* Build scripts should now be easily re-runnable. Usage is now `docker
compose run --rm <image>` and then run the scripts
* All artifacts are now uploaded to github after build, this means we
can take an appimage/flatpak/exe/dmg for any given PR and try it out
without having to build it ourselves
Notes:
* Docker image size is quite important. We have a maximum of 5GB cache
space on github actions. The majority of the linux distro docker
images cache at ~300-400MB, which gives us room to test ~6 distros
after accounting for the sizes of flatpak/windows docker images
* Docker layer ordering is relatively intentional. Approximate order
should be that large dependencies that change infrequently should be
farther up. This lowers the amount of rebuilding we have to do when
dependencies are updated
* download_xxx.sh scripts are the cleanest way I could find to implement
a shared dependency map between osx scripts and docker containers.
Although it would be nice to have a single dependency mapping file,
splitting it into individual scripts allows us to only rebuild some
docker layers when dependencies are updated.
* Github actions are split between docker image building and docker
image use. This allows us to re-use the same docker images for
multiple jobs, but only build it once
* Unfortunately I could not find a way to de-duplicate the stitching
between jobs, so we have a lot of copy pasta in that area
Previously, the four matrix Windows jobs would run in parallel and each
build deps, which is redundant since both debug and release qTox use the
same deps.
Now, the win-deps job builds only the needed two versions of deps, and
the four windows builds wait for it to complete before running in
parallel.
So that each commit in repo is tested, including merge commits that
aren't present in PRs. Also prepares for running releases only on push
but not on PRs.
Workflows have a global runs-on, so commit format check needs to be
split out from the shared PR and push workflow to since checking all
commit messages on pushes always fails due to very old commits not
following the proper format.
Partially fix#6345, only PR portion, not nightly or releases.
Unlike travis, we're not caching our brew packages. `actions/cache` doesn't
update the cache on cache hit, making it hard to use a rolling cache like
before. We also don't know what cache key we should use before running, since
it relies on the live package list of brew.
Using a docker image containing brew packages seems like a better option if we
need the speedup going forward. ATM a full build with deps only takes about 12
minutes. Windows builds don't have this issue, since deps there are keyed off of
known versions in our repo.
Current Windows matrix form works, but causes a double-build on dep change due
to both debug/release rebuilding the release deps. Instead, should probably
separate the dep jobs, block build on the dep jobs, and update the cache on dep
jobs, guaranteeing a cache hit on build jobs?
Windows stage 1 and stage 2 can probably be recombined, if they were split due
to travis single build length limits, since GH actions allows much longer single
builds.
Add a pull request template to tell contributors that their commits
should follow the project's git commit guidelines before submitting
a pull request.
Short lines make it easier to evaluate diffs.
Fix only critical typos, like missing full stops in the middle of a
sentence. Everything else left untouched.
