mirror of
https://gitlab.com/TECHNOFAB/nix-gitlab-ci.git
synced 2025-12-11 17:50:08 +01:00
chore: remove old files in preparation for rewrite
This commit is contained in:
parent
0c6949f585
commit
046656458b
39 changed files with 0 additions and 2377 deletions
1
.envrc
1
.envrc
|
|
@ -1 +0,0 @@
|
|||
use flake . --impure --accept-flake-config
|
||||
6
.gitignore
vendored
6
.gitignore
vendored
|
|
@ -1,6 +0,0 @@
|
|||
.idea
|
||||
.devenv
|
||||
.direnv
|
||||
.pre-commit-config.yaml
|
||||
result
|
||||
*.xml
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
include:
|
||||
- component: $CI_SERVER_FQDN/$CI_PROJECT_PATH/nix-gitlab-ci@$CI_COMMIT_SHA
|
||||
inputs:
|
||||
version: $CI_COMMIT_SHORT_SHA
|
||||
stages:
|
||||
- build-images
|
||||
- build
|
||||
- trigger
|
||||
build:image:
|
||||
stage: build-images
|
||||
parallel:
|
||||
matrix:
|
||||
- ARCH: ["x86_64-linux", "aarch64-linux"]
|
||||
image: nixpkgs/nix-flakes:latest
|
||||
script:
|
||||
- nix build .#image --system $ARCH
|
||||
after_script:
|
||||
- install -D result dist/nix-ci-$ARCH.tar.gz
|
||||
artifacts:
|
||||
paths:
|
||||
- dist
|
||||
deploy:image:
|
||||
stage: build-images
|
||||
image: nixpkgs/nix-flakes:latest
|
||||
needs:
|
||||
- build:image
|
||||
before_script:
|
||||
- nix profile install nixpkgs#buildah
|
||||
- export PATH="$PATH:$HOME/.nix-profile/bin"
|
||||
- export REGISTRY_AUTH_FILE=''${HOME}/auth.json
|
||||
- echo "$CI_REGISTRY_PASSWORD" | buildah login -u "$CI_REGISTRY_USER" --password-stdin $CI_REGISTRY
|
||||
- mkdir -p /etc/containers && echo '{"default":[{"type":"insecureAcceptAnything"}]}' > /etc/containers/policy.json
|
||||
- mkdir -p /var/tmp
|
||||
script:
|
||||
- export NORMALIZED_BRANCH=${CI_COMMIT_BRANCH/\//-}
|
||||
- buildah manifest create localhost/nix-ci
|
||||
- buildah manifest add localhost/nix-ci docker-archive:dist/nix-ci-x86_64-linux.tar.gz
|
||||
- buildah manifest add localhost/nix-ci docker-archive:dist/nix-ci-aarch64-linux.tar.gz
|
||||
- buildah manifest push --all localhost/nix-ci docker://''${CI_REGISTRY_IMAGE}/nix-ci:${CI_COMMIT_SHORT_SHA}
|
||||
# branches
|
||||
- |
|
||||
if [ -z "$CI_COMMIT_TAG" ]; then
|
||||
buildah manifest push --all localhost/nix-ci docker://''${CI_REGISTRY_IMAGE}/nix-ci:${NORMALIZED_BRANCH/main/latest}
|
||||
fi
|
||||
# tags
|
||||
- |
|
||||
if [ -n "$CI_COMMIT_TAG" ]; then
|
||||
buildah manifest push --all localhost/nix-ci docker://''${CI_REGISTRY_IMAGE}/nix-ci:${CI_COMMIT_TAG}
|
||||
fi
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
Copyright 2024 TECHNOFAB
|
||||
|
||||
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.
|
||||
89
README.md
89
README.md
|
|
@ -1,89 +0,0 @@
|
|||
# Nix GitLab CI
|
||||
|
||||
[](https://builtwithnix.org)
|
||||
[](https://gitlab.com/TECHNOFAB/nix-gitlab-ci/-/commits/main)
|
||||
|
||||
[](https://gitlab.com/TECHNOFAB/nix-gitlab-ci/-/releases)
|
||||
[](https://tec.tf/#support)
|
||||
[](https://nix-gitlab-ci.projects.tf)
|
||||
|
||||
Flake module which allows generating a `.gitlab-ci.yml` from Nix.
|
||||
|
||||
This allows easily using any Nix package in CI.
|
||||
|
||||
Also makes it possible to split CI parts in a separate module which can be imported in multiple projects.
|
||||
|
||||
## Usage
|
||||
|
||||
```nix
|
||||
# flake.nix
|
||||
{
|
||||
...
|
||||
inputs.nix-gitlab-ci.url = "gitlab:TECHNOFAB/nix-gitlab-ci/<version>?dir=lib"; # recommendation: pin to the latest release/version
|
||||
|
||||
outputs = {...}: flake-parts.lib.mkFlake {...} {
|
||||
imports = [
|
||||
inputs.nix-gitlab-ci.flakeModule
|
||||
];
|
||||
...
|
||||
|
||||
perSystem = {pkgs, ...}: {
|
||||
# ci is a shortcut and creates a "default" pipeline
|
||||
ci = {
|
||||
stages = ["test"];
|
||||
jobs = {
|
||||
"test" = {
|
||||
stage = "test";
|
||||
nix.deps = [pkgs.unixtools.ping];
|
||||
script = [
|
||||
"ping -c 5 8.8.8.8"
|
||||
];
|
||||
};
|
||||
};
|
||||
};
|
||||
# runs on a merge request for example
|
||||
pipelines."merge_request_event" = {
|
||||
stages = ["some_stage"];
|
||||
jobs = { ... };
|
||||
};
|
||||
...
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```yaml
|
||||
# .gitlab-ci.yml
|
||||
include:
|
||||
- component: gitlab.com/TECHNOFAB/nix-gitlab-ci/nix-gitlab-ci@<version> # recommendation: pin to the latest release/version (don't use "main" etc.)
|
||||
inputs:
|
||||
version: <version> # docker image tag, use the same version as a above
|
||||
```
|
||||
|
||||
## Utilities
|
||||
|
||||
### Disable Caching temporarily
|
||||
|
||||
To disable any of the provided caches for a pipeline one can set `NIX_CI_DISABLE_CACHE` to
|
||||
anything non-empty (eg. "yes") when triggering the pipeline.
|
||||
|
||||
The `build:nix-ci` job has a different special environment variable `NIX_CI_FORCE_BUILD`
|
||||
(useful if the generated pipeline in the cache is outdated, this will build it again).
|
||||
|
||||
### Run Jobs locally
|
||||
|
||||
You can run any job's script (+ before and after) locally with Nix for easier testing:
|
||||
|
||||
```sh
|
||||
# / pipeline name, like "default"
|
||||
nix run .#gitlab-ci:pipeline:<pipeline name>:job:<name>
|
||||
```
|
||||
|
||||
There is also `.#gitlab-ci:pipeline:<pipeline name>:job-deps:<name>` which generates and exports the required environment variables for each job:
|
||||
|
||||
- PATH (with all deps)
|
||||
- any custom env variables which contain store paths to not break stuff when switching archs
|
||||
|
||||
## Thanks to
|
||||
|
||||
Some parts of this implementation are adapted/inspired from https://gitlab.com/Cynerd/gitlab-ci-nix
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
# Caching
|
||||
|
||||
Nix GitLab CI supports several caching mechanisms to speed up your pipelines.
|
||||
|
||||
## GitLab Runner Cache
|
||||
|
||||
The runner cache strategy copies the new store paths into a directory `.nix-cache`,
|
||||
which is then saved in the regular GitLab cache (technically runner cache).
|
||||
It's also configured as a substituter automatically.
|
||||
|
||||
To enable, set the cache strategy to `runner`.
|
||||
|
||||
Configure it using these environment variables:
|
||||
|
||||
- `RUNNER_CACHE`: path to the runner cache (default `.nix-cache`)
|
||||
|
||||
!!! warning
|
||||
|
||||
This is very inefficient and should probably only be used for very very small
|
||||
dependency counts. Otherwise it takes an eternity to save to cache.
|
||||
|
||||
## Cachix
|
||||
|
||||
Cachix is a hosted binary cache service that can significantly speed up Nix
|
||||
builds by sharing build results.
|
||||
|
||||
To enable, set the cache strategy to `attic`.
|
||||
|
||||
Configure it using these environment variables:
|
||||
|
||||
- `CACHIX_CACHE`: name of the cache to use
|
||||
- (`CACHIX_AUTH_TOKEN`): cachix client itself uses this for authentication
|
||||
|
||||
!!! warning
|
||||
|
||||
Cachix has not been tested. Feedback is appreciated :)
|
||||
|
||||
## Attic (Self-Hosted Cache)
|
||||
|
||||
Attic is a self-hosted, deduplicating binary cache. It's a great option if you
|
||||
want more control over your caching infrastructure and to have the cache closer
|
||||
to your runners.
|
||||
|
||||
To enable, set the cache strategy to `attic`.
|
||||
|
||||
Configure it using these environment variables:
|
||||
|
||||
- `ATTIC_SERVER`: URL of the server
|
||||
- `ATTIC_CACHE`: name of the cache to use
|
||||
- `ATTIC_TOKEN`: auth token from the attic server
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
# CI/CD Component
|
||||
|
||||
The CI/CD Component has some inputs which configure defaults for Nix GitLab CI.
|
||||
|
||||
## `version`
|
||||
|
||||
- Type: `string`
|
||||
|
||||
Which version of the Nix CI image to use. Using a tag/version is recommended.
|
||||
Will not do anything if a custom image is specified using `NIX_CI_IMAGE`.
|
||||
|
||||
## `cache_strategy`
|
||||
|
||||
- Type: `string`
|
||||
- Default: `"auto"`
|
||||
- Options: `auto` | `none` | `runner` | `cachix` | `attic`
|
||||
|
||||
Sets the default caching strategy.
|
||||
|
||||
- `auto`: dynamically selects the best strategy for every job based on env variables
|
||||
- `none`: disables caching
|
||||
- `runner`, `cachix` & `attic`: forces every job to use this strategy
|
||||
|
||||
Can be overridden by `NIX_CI_CACHE_STRATEGY`, see [Environment Variables](./environment_variables.md).
|
||||
|
||||
## `cache_files`
|
||||
|
||||
- Type: `array` (of strings)
|
||||
- Default: `["flake.nix", "flake.lock"]`
|
||||
|
||||
Files to use as the cache key for the generated pipeline yaml.
|
||||
If you use a file like `ci.nix` to define CI, add that here for example.
|
||||
This makes sure that changes to your Nix CI configuration will invalidate the cache,
|
||||
otherwise an old pipeline yaml might be used.
|
||||
|
||||
!!! warning
|
||||
|
||||
The value of this is used in `cache:key:files`, which currently only supports
|
||||
a max of 2 entries. So use something like `["flake.*", "ci.nix"]` to match
|
||||
`flake.lock`, `flake.nix` and `ci.nix`.
|
||||
See [gitlab-org/gitlab#301161](https://gitlab.com/gitlab-org/gitlab/-/issues/301161)
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
# Environment Variables
|
||||
|
||||
Nix GitLab CI is mostly controlled using environment variables.
|
||||
This page outlines all the variables and their use case.
|
||||
|
||||
## `NIX_CI_IMAGE`
|
||||
|
||||
| | |
|
||||
| ----------- | -------------------------------------------------------------------------- |
|
||||
| Default | `registry.gitlab.com/technofab/nix-gitlab-ci/nix-ci@$[[ inputs.version ]]` |
|
||||
| Description | Image to use for the jobs |
|
||||
|
||||
## `NIX_CI_PIPELINE_NAME`
|
||||
|
||||
| | |
|
||||
| ----------- | ------------------------------------------------- |
|
||||
| Default | N/A |
|
||||
| Description | Explicitly request a pipeline to be built and ran |
|
||||
| See also | [Multi Pipeline](./multi_pipeline.md) |
|
||||
|
||||
## `NIX_CI_DEFAULT_SOURCES`
|
||||
|
||||
| | |
|
||||
| ----------- | -------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| Default | `.*` |
|
||||
| Description | Regex to match `$CI_PIPELINE_SOURCE` against. If it matches, the `default` pipeline will be ran, otherwise `$CI_PIPELINE_SOURCE` |
|
||||
| See also | [Multi Pipeline](./multi_pipeline.md) |
|
||||
|
||||
## `NIX_CI_FORCE_BUILD`
|
||||
|
||||
| | |
|
||||
| ----------- | -------------------------------------------------------------------------------------- |
|
||||
| Default | N/A |
|
||||
| Description | Set to any non-empty value to force the `nix-ci:build` job to freshly build the config |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `NIX_CI_DISABLE_CACHE`
|
||||
|
||||
| | |
|
||||
| ----------- | ------------------------------------------------------ |
|
||||
| Default | N/A |
|
||||
| Description | Set to any non-empty value to disable caching for jobs |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `NIX_CI_CACHE_STRATEGY`
|
||||
|
||||
| | |
|
||||
| ----------- | --------------------------------------------------------------------------------- |
|
||||
| Default | `$[[ inputs.cache_strategy ]]` -> defaults to `auto` |
|
||||
| Description | Caching strategy to use. `auto` will select the strategy based on runner settings |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `NIX_CI_RUNNER_CACHE_STRATEGY`
|
||||
|
||||
| | |
|
||||
| ----------- | ---------------------------------------------------------------- |
|
||||
| Default | N/A |
|
||||
| Description | Every runner can set it's own preferred cache strategy with this |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `NIX_CI_DEFAULT_CACHE_STRATEGY`
|
||||
|
||||
| | |
|
||||
| ----------- | ------------------------------------------------------------------------------------------------- |
|
||||
| Default | `none` |
|
||||
| Description | If no runner cache strategy is set and the main strategy is set to auto, this will be the default |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `RUNNER_CACHE`
|
||||
|
||||
| | |
|
||||
| ----------- | -------------------------------------- |
|
||||
| Default | `.nix-cache` |
|
||||
| Description | Path to directory for the runner cache |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `CACHIX_CACHE`
|
||||
|
||||
| | |
|
||||
| ----------- | ------------------------------- |
|
||||
| Default | N/A |
|
||||
| Description | Name of the cachix cache to use |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `ATTIC_CACHE`
|
||||
|
||||
| | |
|
||||
| ----------- | ------------------------------ |
|
||||
| Default | N/A |
|
||||
| Description | Name of the attic cache to use |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `ATTIC_SERVER`
|
||||
|
||||
| | |
|
||||
| ----------- | ----------------------- |
|
||||
| Default | N/A |
|
||||
| Description | URL of the attic server |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
||||
## `ATTIC_TOKEN`
|
||||
|
||||
| | |
|
||||
| ----------- | ------------------------------- |
|
||||
| Default | N/A |
|
||||
| Description | API token from the attic server |
|
||||
| See also | [Caching](./caching.md) |
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
# Example Configs
|
||||
|
||||
## V2
|
||||
|
||||
- [TECHNOFAB/nix-gitlab-ci](https://gitlab.com/TECHNOFAB/nix-gitlab-ci)
|
||||
See `flake.nix` for some random example jobs.
|
||||
- [TECHNOFAB/nixlets](https://gitlab.com/TECHNOFAB/nixlets)
|
||||
- [TECHNOFAB/nixmkdocs](https://gitlab.com/TECHNOFAB/nixmkdocs)
|
||||
- [TECHNOFAB/tofunix](https://gitlab.com/TECHNOFAB/tofunix)
|
||||
|
||||
## Old / V1
|
||||
|
||||
- [TECHNOFAB/coder-templates](https://gitlab.com/TECHNOFAB/coder-templates)
|
||||
|
||||
!!! note
|
||||
|
||||
Feel free to edit this page and add your project if you're using
|
||||
Nix GitLab CI :)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 1.9 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 40 KiB |
|
|
@ -1,11 +0,0 @@
|
|||
# Nix GitLab CI
|
||||
|
||||
This project provides a Nix flake module that allows you to generate your `.gitlab-ci.yml` file directly from your Nix configuration.
|
||||
|
||||
## Features
|
||||
|
||||
- **Reproducibility:** Leverage Nix's strength in creating reproducible environments for your CI jobs.
|
||||
- **Easy Dependency Management:** Easily include any package available in Nixpkgs or your own defined packages within your CI jobs using Nix.
|
||||
- **Modularity:** Define and manage your CI configurations in a structured and modular way using Nix modules, making it easier to share and reuse CI logic across multiple projects.
|
||||
|
||||
This documentation will guide you through setting up and using Nix GitLab CI for your projects.
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
# Kubernetes Runner Setup
|
||||
|
||||
Using the GitLab Kubernetes runner allows your CI jobs to run as pods in a Kubernetes cluster.
|
||||
Nix GitLab CI can be integrated with this setup, and using advanced configuration options like
|
||||
`pod_spec` makes it easy to add runner specific caching.
|
||||
|
||||
Using this Runner configuration ...
|
||||
|
||||
```toml
|
||||
[[runners.kubernetes.pod_spec]]
|
||||
name = "nix-ci-cache-secrets"
|
||||
patch = '''
|
||||
containers:
|
||||
- name: build
|
||||
envFrom:
|
||||
- secretRef:
|
||||
name: nix-ci-cache-env
|
||||
'''
|
||||
```
|
||||
|
||||
... and a secret containing ...
|
||||
|
||||
```yaml
|
||||
NIX_CI_RUNNER_CACHE_STRATEGY: attic
|
||||
ATTIC_SERVER: <in-cluster-url> # example: http://atticd.<ns>.svc.cluster.local:8080
|
||||
ATTIC_CACHE: ci # name however you want, just needs to exist
|
||||
ATTIC_TOKEN: <token>
|
||||
```
|
||||
|
||||
... makes your jobs automatically cache their Nix store paths to the in-cluster
|
||||
attic when running with this runner.
|
||||
|
||||
Other runners could use cachix or no cache, you get the idea ;P
|
||||
|
||||
!!! note
|
||||
|
||||
This of course works with any executor where you can set environment
|
||||
variables. This is just an example how to do it in Kubernetes easily.
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
# Multiple Pipelines
|
||||
|
||||
With V2, Nix GitLab CI can generate different pipelines, depending on the
|
||||
pipeline source (`$CI_PIPELINE_SOURCE`).
|
||||
|
||||
By default, no matter which source, the `default` pipeline is built and ran.
|
||||
`$NIX_CI_PIPELINE` can override that, eg. when manually triggering a run.
|
||||
To configure which source should be 1-to-1 translated to a pipeline with the
|
||||
same name, set `$NIX_CI_DEFAULT_SOURCES` to a regex which explicitly does not
|
||||
match these sources. Or set it to an impossible to match regex, then it will
|
||||
always run the pipeline named after `$CI_PIPELINE_SOURCE`.
|
||||
|
||||
## Example 1: always run default
|
||||
|
||||
If you only have a single pipeline, you just have to call it `default`.
|
||||
Everything else works out of the box.
|
||||
|
||||
## Example 2: default and merge_request_event
|
||||
|
||||
If you want the source `merge_request_event` to trigger a different pipeline,
|
||||
name it like that and set `$NIX_CI_DEFAULT_SOURCES` to `^(merge_request_event)$`.
|
||||
Now a merge request will run this pipeline, while everything else runs `default`.
|
||||
|
||||
## Example 3: default, push and web
|
||||
|
||||
Set `$NIX_CI_DEFAULT_SOURCES` to `^(push|web)$`.
|
||||
|
||||
## Example 4: always run the specific pipelines, never default
|
||||
|
||||
Set `$NIX_CI_DEFAULT_SOURCES` to any regex that never matches the sources,
|
||||
like `a\A` or `nothing`.
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
# Setup
|
||||
|
||||
To integrate Nix GitLab CI into your project, you need to make two main changes:
|
||||
|
||||
1. Add the `nix-gitlab-ci` flake module to your `flake.nix`.
|
||||
1. Include the necessary component in your `.gitlab-ci.yml`.
|
||||
|
||||
## Adding to `flake.nix`
|
||||
|
||||
In your project's `flake.nix`, add `nix-gitlab-ci` as an input and import its
|
||||
flake module within your `flake-parts` configuration.
|
||||
|
||||
```nix title="flake.nix"
|
||||
{
|
||||
inputs = {
|
||||
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; # Or your preferred nixpkgs branch/version
|
||||
flake-parts.url = "github:hercules-ci/flake-parts";
|
||||
|
||||
# Add nix-gitlab-ci as an input
|
||||
# recommendation: pin to a specific release/version
|
||||
nix-gitlab-ci.url = "gitlab:TECHNOFAB/nix-gitlab-ci/<version>?dir=lib";
|
||||
};
|
||||
|
||||
outputs = { nixpkgs, flake-parts, ... }@inputs:
|
||||
flake-parts.lib.mkFlake { inherit inputs; } {
|
||||
imports = [
|
||||
# Import the nix-gitlab-ci flake module
|
||||
inputs.nix-gitlab-ci.flakeModule
|
||||
];
|
||||
|
||||
systems = [
|
||||
"x86_64-linux"
|
||||
"aarch64-linux"
|
||||
# Add other systems you need
|
||||
];
|
||||
|
||||
perSystem = { pkgs, ... }: {
|
||||
# define your CI pipelines
|
||||
# ci = { ... };
|
||||
# pipelines."merge_request_event" = { ... };
|
||||
};
|
||||
};
|
||||
}
|
||||
```
|
||||
|
||||
Replace `<version>` with the specific version or commit hash of `nix-gitlab-ci`
|
||||
you wish to use. Pinning to a specific version is highly recommended for
|
||||
reproducibility and compatibility.
|
||||
|
||||
!!! warning
|
||||
|
||||
While the flake input is locked through `flake.lock`, the CI/CD component
|
||||
will always use the latest commit of the reference. This means that by using
|
||||
a branch like `main` as version for both, the CI/CD component will always use
|
||||
the latest commit while your flake uses a fixed one.
|
||||
This could result in drift between both, potentially breaking stuff.
|
||||
|
||||
## Including in `.gitlab-ci.yml`
|
||||
|
||||
Your `.gitlab-ci.yml` file will be minimal. Its primary role is to include the
|
||||
`nix-gitlab-ci` component, which will then generate the full CI configuration
|
||||
based on your Nix code.
|
||||
|
||||
```yaml title=".gitlab-ci.yml"
|
||||
include:
|
||||
- component: gitlab.com/TECHNOFAB/nix-gitlab-ci/nix-gitlab-ci@<version>
|
||||
inputs:
|
||||
# This input sets the Docker image tag used for the CI jobs.
|
||||
# Use the same version as you pinned in your flake.nix for consistency.
|
||||
version: <version>
|
||||
```
|
||||
|
||||
Again, ensure `<version>` matches the version used in your `flake.nix`.
|
||||
This component includes a job (`build:nix-ci`) that will evaluate your Nix
|
||||
configuration and generate the `.gitlab-ci.yml` used for the pipeline run.
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
# Usage
|
||||
|
||||
To create a basic pipeline, configure it by setting `ci` in `perSystem`.
|
||||
The schema is similar to the `.gitlab-ci.yml`, only jobs are defined differently:
|
||||
|
||||
```nix
|
||||
ci = {
|
||||
# Nix GitLab CI specific config, see `configType` in `flakeModule.nix`
|
||||
config = {};
|
||||
jobs = {
|
||||
"job-a" = {};
|
||||
"job-b" = {};
|
||||
};
|
||||
};
|
||||
```
|
||||
|
||||
For every job, there are a couple of settings you can adjust aswell:
|
||||
|
||||
```nix
|
||||
"job-a" = {
|
||||
# see `jobType` in `flakeModule.nix`
|
||||
nix = {
|
||||
enable = true; # is this a nix-based job?
|
||||
deps = []; # dependencies to install for this job
|
||||
# for gitlab runner cache:
|
||||
enable-runner-cache = false;
|
||||
runner-cache-key = "";
|
||||
};
|
||||
};
|
||||
```
|
||||
|
||||
Since V2 multiple pipelines are supported.
|
||||
See [Multiple Pipelines](./multi_pipeline.md) for more.
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
# Utilities
|
||||
|
||||
Nix GitLab CI provides a couple of utilities to help with development and
|
||||
debugging.
|
||||
|
||||
## Disabling caching temporarily
|
||||
|
||||
Nix GitLab CI often utilizes caching mechanisms to speed up your pipelines
|
||||
(see [Caching](./caching.md)).
|
||||
However, there might be situations where you need to temporarily disable these
|
||||
caches for a specific pipeline run, for example, to debug a caching issue or
|
||||
ensure a clean build.
|
||||
|
||||
To disable most of the provided caches for a pipeline, set the environment
|
||||
variable `NIX_CI_DISABLE_CACHE` to any non-empty value (e.g., `yes`, `true`, `1`)
|
||||
when triggering the pipeline in the GitLab UI or via the API.
|
||||
|
||||
## Forcing a rebuild of the CI pipeline definition
|
||||
|
||||
The job responsible for generating the `.gitlab-ci.yml` from your Nix code
|
||||
(`build:nix-ci`) might itself be cached. If you've made changes to your Nix CI
|
||||
configuration and the pipeline doesn't seem to pick them up, the cached job
|
||||
definition might be the reason.
|
||||
|
||||
You should first double check if all the Nix files you defined the CI config in
|
||||
are specified in the `cache_files` CI/CD-component input
|
||||
(see [CI/CD Component](./cicd_component.md) for more).
|
||||
|
||||
To force this specific job to rebuild and re-evaluate your Nix configuration,
|
||||
set the environment variable `NIX_CI_FORCE_BUILD` when triggering the pipeline.
|
||||
|
||||
## Running jobs locally
|
||||
|
||||
One of the benefits of defining your CI jobs with Nix is the ability to run them
|
||||
locally in an environment that closely mirrors the CI environment. This can
|
||||
significantly speed up debugging and development.
|
||||
|
||||
You can run the script of any defined job locally using the `nix run` command.
|
||||
The syntax is:
|
||||
|
||||
```sh
|
||||
nix run .#gitlab-ci:pipeline:<pipeline name>:job:<job name>
|
||||
```
|
||||
|
||||
Replace `<pipeline name>` with the name of the pipeline the job belongs to
|
||||
(e.g., `default` for jobs defined under the `ci` attribute) and `<job name>`
|
||||
with the name of the job you want to run.
|
||||
|
||||
This command will set up the environment with the specified `nix.deps` and
|
||||
execute the job's `script`.
|
||||
|
||||
There is also an attribute `.#gitlab-ci:pipeline:<pipeline name>:job-deps:<job name>`.
|
||||
Building this derivation will generate a shell script which exports the required
|
||||
environment variables for the job, such as the `PATH` including all dependencies
|
||||
and any custom environment variables that contain store paths (ensuring they are
|
||||
correctly resolved across different architectures).
|
||||
|
||||
You can use this to inspect the environment that would be set up for a job without
|
||||
running the full script.
|
||||
398
flake.lock
generated
398
flake.lock
generated
|
|
@ -1,398 +0,0 @@
|
|||
{
|
||||
"nodes": {
|
||||
"cachix": {
|
||||
"inputs": {
|
||||
"devenv": [
|
||||
"devenv"
|
||||
],
|
||||
"flake-compat": [
|
||||
"devenv"
|
||||
],
|
||||
"git-hooks": [
|
||||
"devenv"
|
||||
],
|
||||
"nixpkgs": "nixpkgs"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1737621947,
|
||||
"narHash": "sha256-8HFvG7fvIFbgtaYAY2628Tb89fA55nPm2jSiNs0/Cws=",
|
||||
"owner": "cachix",
|
||||
"repo": "cachix",
|
||||
"rev": "f65a3cd5e339c223471e64c051434616e18cc4f5",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "cachix",
|
||||
"ref": "latest",
|
||||
"repo": "cachix",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"devenv": {
|
||||
"inputs": {
|
||||
"cachix": "cachix",
|
||||
"flake-compat": "flake-compat",
|
||||
"git-hooks": "git-hooks",
|
||||
"nix": "nix",
|
||||
"nixpkgs": "nixpkgs_3"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1743687534,
|
||||
"narHash": "sha256-QIh5jKWE0aZ4N77Zu3kz0RjA22zqqy5p6PfJnOW5rPE=",
|
||||
"owner": "cachix",
|
||||
"repo": "devenv",
|
||||
"rev": "efd5d68a6483573410565d0b940e1a67b6f92591",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "cachix",
|
||||
"repo": "devenv",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"flake-compat": {
|
||||
"flake": false,
|
||||
"locked": {
|
||||
"lastModified": 1733328505,
|
||||
"narHash": "sha256-NeCCThCEP3eCl2l/+27kNNK7QrwZB1IJCrXfrbv5oqU=",
|
||||
"owner": "edolstra",
|
||||
"repo": "flake-compat",
|
||||
"rev": "ff81ac966bb2cae68946d5ed5fc4994f96d0ffec",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "edolstra",
|
||||
"repo": "flake-compat",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"flake-parts": {
|
||||
"inputs": {
|
||||
"nixpkgs-lib": [
|
||||
"devenv",
|
||||
"nix",
|
||||
"nixpkgs"
|
||||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1712014858,
|
||||
"narHash": "sha256-sB4SWl2lX95bExY2gMFG5HIzvva5AVMJd4Igm+GpZNw=",
|
||||
"owner": "hercules-ci",
|
||||
"repo": "flake-parts",
|
||||
"rev": "9126214d0a59633752a136528f5f3b9aa8565b7d",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "hercules-ci",
|
||||
"repo": "flake-parts",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"flake-parts_2": {
|
||||
"inputs": {
|
||||
"nixpkgs-lib": "nixpkgs-lib"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1743550720,
|
||||
"narHash": "sha256-hIshGgKZCgWh6AYJpJmRgFdR3WUbkY04o82X05xqQiY=",
|
||||
"owner": "hercules-ci",
|
||||
"repo": "flake-parts",
|
||||
"rev": "c621e8422220273271f52058f618c94e405bb0f5",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "hercules-ci",
|
||||
"repo": "flake-parts",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"git-hooks": {
|
||||
"inputs": {
|
||||
"flake-compat": [
|
||||
"devenv"
|
||||
],
|
||||
"gitignore": "gitignore",
|
||||
"nixpkgs": [
|
||||
"devenv",
|
||||
"nixpkgs"
|
||||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1740849354,
|
||||
"narHash": "sha256-oy33+t09FraucSZ2rZ6qnD1Y1c8azKKmQuCvF2ytUko=",
|
||||
"owner": "cachix",
|
||||
"repo": "git-hooks.nix",
|
||||
"rev": "4a709a8ce9f8c08fa7ddb86761fe488ff7858a07",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "cachix",
|
||||
"repo": "git-hooks.nix",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"gitignore": {
|
||||
"inputs": {
|
||||
"nixpkgs": [
|
||||
"devenv",
|
||||
"git-hooks",
|
||||
"nixpkgs"
|
||||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1709087332,
|
||||
"narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=",
|
||||
"owner": "hercules-ci",
|
||||
"repo": "gitignore.nix",
|
||||
"rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "hercules-ci",
|
||||
"repo": "gitignore.nix",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"libgit2": {
|
||||
"flake": false,
|
||||
"locked": {
|
||||
"lastModified": 1697646580,
|
||||
"narHash": "sha256-oX4Z3S9WtJlwvj0uH9HlYcWv+x1hqp8mhXl7HsLu2f0=",
|
||||
"owner": "libgit2",
|
||||
"repo": "libgit2",
|
||||
"rev": "45fd9ed7ae1a9b74b957ef4f337bc3c8b3df01b5",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "libgit2",
|
||||
"repo": "libgit2",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"mkdocs-material-umami": {
|
||||
"locked": {
|
||||
"lastModified": 1745840856,
|
||||
"narHash": "sha256-1Ad1JTMQMP6YsoIKAA+SBCE15qWrYkGue9/lXOLnu9I=",
|
||||
"owner": "technofab",
|
||||
"repo": "mkdocs-material-umami",
|
||||
"rev": "3ac9b194450f6b779c37b8d16fec640198e5cd0a",
|
||||
"type": "gitlab"
|
||||
},
|
||||
"original": {
|
||||
"owner": "technofab",
|
||||
"repo": "mkdocs-material-umami",
|
||||
"type": "gitlab"
|
||||
}
|
||||
},
|
||||
"nix": {
|
||||
"inputs": {
|
||||
"flake-compat": [
|
||||
"devenv"
|
||||
],
|
||||
"flake-parts": "flake-parts",
|
||||
"libgit2": "libgit2",
|
||||
"nixpkgs": "nixpkgs_2",
|
||||
"nixpkgs-23-11": [
|
||||
"devenv"
|
||||
],
|
||||
"nixpkgs-regression": [
|
||||
"devenv"
|
||||
],
|
||||
"pre-commit-hooks": [
|
||||
"devenv"
|
||||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1741798497,
|
||||
"narHash": "sha256-E3j+3MoY8Y96mG1dUIiLFm2tZmNbRvSiyN7CrSKuAVg=",
|
||||
"owner": "domenkozar",
|
||||
"repo": "nix",
|
||||
"rev": "f3f44b2baaf6c4c6e179de8cbb1cc6db031083cd",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "domenkozar",
|
||||
"ref": "devenv-2.24",
|
||||
"repo": "nix",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nix-mkdocs": {
|
||||
"locked": {
|
||||
"dir": "lib",
|
||||
"lastModified": 1745175318,
|
||||
"narHash": "sha256-eJOTw3SK4psqBPP2hNJ4D/13/oi/FLoM0tYKoCGVFP8=",
|
||||
"owner": "technofab",
|
||||
"repo": "nixmkdocs",
|
||||
"rev": "6d6e0139060c896ae14de4b9c82335655a384643",
|
||||
"type": "gitlab"
|
||||
},
|
||||
"original": {
|
||||
"dir": "lib",
|
||||
"owner": "technofab",
|
||||
"repo": "nixmkdocs",
|
||||
"type": "gitlab"
|
||||
}
|
||||
},
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1733212471,
|
||||
"narHash": "sha256-M1+uCoV5igihRfcUKrr1riygbe73/dzNnzPsmaLCmpo=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "55d15ad12a74eb7d4646254e13638ad0c4128776",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "nixos-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs-lib": {
|
||||
"locked": {
|
||||
"lastModified": 1743296961,
|
||||
"narHash": "sha256-b1EdN3cULCqtorQ4QeWgLMrd5ZGOjLSLemfa00heasc=",
|
||||
"owner": "nix-community",
|
||||
"repo": "nixpkgs.lib",
|
||||
"rev": "e4822aea2a6d1cdd36653c134cacfd64c97ff4fa",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nix-community",
|
||||
"repo": "nixpkgs.lib",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs_2": {
|
||||
"locked": {
|
||||
"lastModified": 1717432640,
|
||||
"narHash": "sha256-+f9c4/ZX5MWDOuB1rKoWj+lBNm0z0rs4CK47HBLxy1o=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "88269ab3044128b7c2f4c7d68448b2fb50456870",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "release-24.05",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs_3": {
|
||||
"locked": {
|
||||
"lastModified": 1733477122,
|
||||
"narHash": "sha256-qamMCz5mNpQmgBwc8SB5tVMlD5sbwVIToVZtSxMph9s=",
|
||||
"owner": "cachix",
|
||||
"repo": "devenv-nixpkgs",
|
||||
"rev": "7bd9e84d0452f6d2e63b6e6da29fe73fac951857",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "cachix",
|
||||
"ref": "rolling",
|
||||
"repo": "devenv-nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs_4": {
|
||||
"locked": {
|
||||
"lastModified": 1745377448,
|
||||
"narHash": "sha256-jhZDfXVKdD7TSEGgzFJQvEEZ2K65UMiqW5YJ2aIqxMA=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "507b63021ada5fee621b6ca371c4fca9ca46f52c",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "nixpkgs-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs_5": {
|
||||
"locked": {
|
||||
"lastModified": 1735554305,
|
||||
"narHash": "sha256-zExSA1i/b+1NMRhGGLtNfFGXgLtgo+dcuzHzaWA6w3Q=",
|
||||
"owner": "nixos",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "0e82ab234249d8eee3e8c91437802b32c74bb3fd",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nixos",
|
||||
"ref": "nixpkgs-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixtest": {
|
||||
"locked": {
|
||||
"dir": "lib",
|
||||
"lastModified": 1748945995,
|
||||
"narHash": "sha256-OWflapMq78nCUT7N0vS/AuK4E8y7p8oh0zjnDioJ4Lw=",
|
||||
"owner": "technofab",
|
||||
"repo": "nixtest",
|
||||
"rev": "392e8796f386373a36aecd3216925accf2714a1a",
|
||||
"type": "gitlab"
|
||||
},
|
||||
"original": {
|
||||
"dir": "lib",
|
||||
"owner": "technofab",
|
||||
"ref": "1.0.0",
|
||||
"repo": "nixtest",
|
||||
"type": "gitlab"
|
||||
}
|
||||
},
|
||||
"root": {
|
||||
"inputs": {
|
||||
"devenv": "devenv",
|
||||
"flake-parts": "flake-parts_2",
|
||||
"mkdocs-material-umami": "mkdocs-material-umami",
|
||||
"nix-mkdocs": "nix-mkdocs",
|
||||
"nixpkgs": "nixpkgs_4",
|
||||
"nixtest": "nixtest",
|
||||
"systems": "systems",
|
||||
"treefmt-nix": "treefmt-nix"
|
||||
}
|
||||
},
|
||||
"systems": {
|
||||
"locked": {
|
||||
"lastModified": 1689347949,
|
||||
"narHash": "sha256-12tWmuL2zgBgZkdoB6qXZsgJEH9LR3oUgpaQq2RbI80=",
|
||||
"owner": "nix-systems",
|
||||
"repo": "default-linux",
|
||||
"rev": "31732fcf5e8fea42e59c2488ad31a0e651500f68",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nix-systems",
|
||||
"repo": "default-linux",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"treefmt-nix": {
|
||||
"inputs": {
|
||||
"nixpkgs": "nixpkgs_5"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1743677901,
|
||||
"narHash": "sha256-eWZln+k+L/VHO69tUTzEmgeDWNQNKIpSUa9nqQgBrSE=",
|
||||
"owner": "numtide",
|
||||
"repo": "treefmt-nix",
|
||||
"rev": "57dabe2a6255bd6165b2437ff6c2d1f6ee78421a",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "numtide",
|
||||
"repo": "treefmt-nix",
|
||||
"type": "github"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
"version": 7
|
||||
}
|
||||
304
flake.nix
304
flake.nix
|
|
@ -1,304 +0,0 @@
|
|||
{
|
||||
outputs = {
|
||||
flake-parts,
|
||||
systems,
|
||||
...
|
||||
} @ inputs:
|
||||
flake-parts.lib.mkFlake {inherit inputs;} {
|
||||
imports = [
|
||||
inputs.devenv.flakeModule
|
||||
inputs.treefmt-nix.flakeModule
|
||||
inputs.nix-mkdocs.flakeModule
|
||||
inputs.nixtest.flakeModule
|
||||
./lib/flakeModule.nix
|
||||
];
|
||||
systems = import systems;
|
||||
flake = {};
|
||||
perSystem = {
|
||||
pkgs,
|
||||
config,
|
||||
system,
|
||||
...
|
||||
}: rec {
|
||||
imports = [
|
||||
./tests
|
||||
];
|
||||
treefmt = {
|
||||
projectRootFile = "flake.nix";
|
||||
programs = {
|
||||
alejandra.enable = true;
|
||||
mdformat.enable = true;
|
||||
yamlfmt.enable = true;
|
||||
};
|
||||
settings.formatter = {
|
||||
yamlfmt.excludes = ["templates/nix-gitlab-ci.yml"];
|
||||
mdformat.command = let
|
||||
pkg = pkgs.python3.withPackages (p: [
|
||||
p.mdformat
|
||||
p.mdformat-mkdocs
|
||||
]);
|
||||
in "${pkg}/bin/mdformat";
|
||||
};
|
||||
};
|
||||
devenv.shells.default = {
|
||||
containers = pkgs.lib.mkForce {};
|
||||
packages = with pkgs; [dive skopeo];
|
||||
|
||||
pre-commit = {
|
||||
hooks = {
|
||||
treefmt = {
|
||||
enable = true;
|
||||
packageOverrides.treefmt = config.treefmt.build.wrapper;
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
doc = {
|
||||
path = ./docs;
|
||||
deps = pp: [
|
||||
pp.mkdocs-material
|
||||
(pp.callPackage inputs.mkdocs-material-umami {})
|
||||
];
|
||||
config = {
|
||||
site_name = "Nix GitLab CI";
|
||||
repo_name = "TECHNOFAB/nix-gitlab-ci";
|
||||
repo_url = "https://gitlab.com/TECHNOFAB/nix-gitlab-ci";
|
||||
edit_uri = "edit/main/docs/";
|
||||
theme = {
|
||||
name = "material";
|
||||
features = ["content.code.copy" "content.action.edit"];
|
||||
icon.repo = "simple/gitlab";
|
||||
logo = "images/logo.png";
|
||||
favicon = "images/favicon.png";
|
||||
palette = [
|
||||
{
|
||||
scheme = "default";
|
||||
media = "(prefers-color-scheme: light)";
|
||||
primary = "deep orange";
|
||||
accent = "orange";
|
||||
toggle = {
|
||||
icon = "material/brightness-7";
|
||||
name = "Switch to dark mode";
|
||||
};
|
||||
}
|
||||
{
|
||||
scheme = "slate";
|
||||
media = "(prefers-color-scheme: dark)";
|
||||
primary = "deep orange";
|
||||
accent = "orange";
|
||||
toggle = {
|
||||
icon = "material/brightness-4";
|
||||
name = "Switch to light mode";
|
||||
};
|
||||
}
|
||||
];
|
||||
};
|
||||
plugins = ["search" "material-umami"];
|
||||
nav = [
|
||||
{"Introduction" = "index.md";}
|
||||
{"Setup" = "setup.md";}
|
||||
{"Usage" = "usage.md";}
|
||||
{"CI/CD Component" = "cicd_component.md";}
|
||||
{"Environment Variables" = "environment_variables.md";}
|
||||
{"Caching" = "caching.md";}
|
||||
{"Multiple Pipelines" = "multi_pipeline.md";}
|
||||
{"Utilities" = "utilities.md";}
|
||||
{"Kubernetes Runner Example" = "kubernetes_runner.md";}
|
||||
{"Example Configs" = "examples.md";}
|
||||
];
|
||||
markdown_extensions = [
|
||||
{
|
||||
"pymdownx.highlight".pygments_lang_class = true;
|
||||
}
|
||||
"pymdownx.inlinehilite"
|
||||
"pymdownx.snippets"
|
||||
"pymdownx.superfences"
|
||||
"fenced_code"
|
||||
"admonition"
|
||||
];
|
||||
extra.analytics = {
|
||||
provider = "umami";
|
||||
site_id = "28f7c904-db22-4c2b-9ee4-ed42e14b6db9";
|
||||
src = "https://analytics.tf/umami";
|
||||
domains = "nix-gitlab-ci.projects.tf";
|
||||
feedback = {
|
||||
title = "Was this page helpful?";
|
||||
ratings = [
|
||||
{
|
||||
icon = "material/thumb-up-outline";
|
||||
name = "This page is helpful";
|
||||
data = "good";
|
||||
note = "Thanks for your feedback!";
|
||||
}
|
||||
{
|
||||
icon = "material/thumb-down-outline";
|
||||
name = "This page could be improved";
|
||||
data = "bad";
|
||||
note = "Thanks for your feedback! Please leave feedback by creating an issue :)";
|
||||
}
|
||||
];
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
# should set the "default" pipeline
|
||||
ci = {
|
||||
stages = ["test" "nixtest" "build" "deploy"];
|
||||
jobs = {
|
||||
"test" = {
|
||||
stage = "test";
|
||||
nix = {
|
||||
deps = [pkgs.hello pkgs.curl];
|
||||
enable-runner-cache = true;
|
||||
};
|
||||
variables = {
|
||||
TEST = "test";
|
||||
TEST_WITH_DERIVATION = "${pkgs.hello}/test";
|
||||
};
|
||||
script = [
|
||||
"hello"
|
||||
"curl google.de"
|
||||
"echo $TEST $TEST_WITH_DERIVATION"
|
||||
];
|
||||
};
|
||||
"test-default" = {
|
||||
stage = "test";
|
||||
nix.deps = [pkgs.hello];
|
||||
script = ["hello"];
|
||||
};
|
||||
"test-non-nix" = {
|
||||
nix.enable = false;
|
||||
stage = "test";
|
||||
image = "alpine:latest";
|
||||
script = [
|
||||
"echo \"This job will not be modified to use nix\""
|
||||
];
|
||||
};
|
||||
# -- actually useful jobs --
|
||||
"docs" = {
|
||||
stage = "build";
|
||||
script = [
|
||||
# sh
|
||||
''
|
||||
nix build .#docs:default
|
||||
mkdir -p public
|
||||
cp -r result/. public/
|
||||
''
|
||||
];
|
||||
artifacts.paths = ["public"];
|
||||
};
|
||||
"pages" = {
|
||||
nix.enable = false;
|
||||
image = "alpine:latest";
|
||||
stage = "deploy";
|
||||
script = ["true"];
|
||||
artifacts.paths = ["public"];
|
||||
rules = [
|
||||
{
|
||||
"if" = "$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH";
|
||||
}
|
||||
];
|
||||
};
|
||||
"nixtest" = {
|
||||
stage = "nixtest";
|
||||
script = [
|
||||
# sh
|
||||
"nix run .#nixtests:run -- --junit=junit.xml --pure"
|
||||
];
|
||||
allow_failure = true;
|
||||
artifacts = {
|
||||
when = "always";
|
||||
reports.junit = "junit.xml";
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
pipelines."non-default" = {
|
||||
stages = ["test"];
|
||||
jobs = {
|
||||
"test" = {
|
||||
stage = "test";
|
||||
script = [
|
||||
"echo Hello from another pipeline"
|
||||
];
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
packages = let
|
||||
setupScript = pkgs.writeShellScriptBin "setup_nix_ci" (builtins.readFile ./scripts/setup_nix_ci.sh);
|
||||
finalizeScript = pkgs.writeShellScriptBin "finalize_nix_ci" (builtins.readFile ./scripts/finalize_nix_ci.sh);
|
||||
in {
|
||||
setup-script = setupScript;
|
||||
finalize-script = finalizeScript;
|
||||
image = pkgs.dockerTools.buildImage {
|
||||
name = "nix-ci";
|
||||
fromImage = let
|
||||
hashes = {
|
||||
"x86_64-linux" = "sha256-kJ7dqje5o1KPr3RDZ7/THbhMSoiCU1C/7HshDrNfwnM=";
|
||||
"aarch64-linux" = "sha256-jz+Z3Ji+hy5d9ImOh/YOKCqy9P9/cseSov+5J/O95bg=";
|
||||
};
|
||||
# check digest of tags like nixos-24.11-aarch64-linux etc.
|
||||
digests = {
|
||||
"x86_64-linux" = "sha256:345f210dea4cbd049e2d01d13159c829066dfb6e273cdd49ea878186d17b19f7";
|
||||
"aarch64-linux" = "sha256:66163fdf446d851416dd4e9be28c0794d9c2550214a57a846957699a3f5747f6";
|
||||
};
|
||||
hash = hashes.${system} or (throw "Unsupported system");
|
||||
imageDigest = digests.${system} or (throw "Unsupported system");
|
||||
in
|
||||
pkgs.dockerTools.pullImage {
|
||||
imageName = "nixpkgs/nix-flakes";
|
||||
inherit hash imageDigest;
|
||||
};
|
||||
copyToRoot = pkgs.buildEnv {
|
||||
name = "image-root";
|
||||
paths = with pkgs;
|
||||
[
|
||||
gitMinimal
|
||||
gnugrep
|
||||
gnused
|
||||
coreutils
|
||||
diffutils
|
||||
cachix
|
||||
attic-client
|
||||
]
|
||||
++ [
|
||||
setupScript
|
||||
finalizeScript
|
||||
];
|
||||
pathsToLink = ["/bin"];
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
checks = packages;
|
||||
};
|
||||
};
|
||||
|
||||
inputs = {
|
||||
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
|
||||
|
||||
# flake & devenv related
|
||||
flake-parts.url = "github:hercules-ci/flake-parts";
|
||||
systems.url = "github:nix-systems/default-linux";
|
||||
devenv.url = "github:cachix/devenv";
|
||||
treefmt-nix.url = "github:numtide/treefmt-nix";
|
||||
nix-mkdocs.url = "gitlab:technofab/nixmkdocs?dir=lib";
|
||||
mkdocs-material-umami.url = "gitlab:technofab/mkdocs-material-umami";
|
||||
nixtest.url = "gitlab:technofab/nixtest/1.0.0?dir=lib";
|
||||
};
|
||||
|
||||
nixConfig = {
|
||||
extra-substituters = [
|
||||
"https://cache.nixos.org/"
|
||||
"https://nix-community.cachix.org"
|
||||
"https://devenv.cachix.org"
|
||||
];
|
||||
|
||||
extra-trusted-public-keys = [
|
||||
"cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY="
|
||||
"nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs="
|
||||
"devenv.cachix.org-1:w1cLUi8dv3hnoSPGAuibQv+f9TZLr6cv/Hm9XgU50cw="
|
||||
];
|
||||
};
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
args: {
|
||||
helpers = import ./helpers.nix args;
|
||||
jobDeps = import ./jobDeps.nix args;
|
||||
jobRun = import ./jobRun.nix args;
|
||||
jobPatch = import ./jobPatch.nix args;
|
||||
pipeline = import ./pipeline.nix args;
|
||||
utils = import ./utils.nix args;
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
{
|
||||
description = "Nix-GitLab-CI lib";
|
||||
|
||||
outputs = {...}: {
|
||||
flakeModule = import ./flakeModule.nix;
|
||||
lib = import ./default.nix;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,172 +0,0 @@
|
|||
{
|
||||
flake-parts-lib,
|
||||
lib,
|
||||
...
|
||||
}: {
|
||||
options.perSystem = flake-parts-lib.mkPerSystemOption (
|
||||
{
|
||||
config,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./. {inherit lib pkgs;};
|
||||
inherit (cilib.pipeline) mkPipeline;
|
||||
inherit (lib) types mkOption;
|
||||
|
||||
cfg = config.ci.config;
|
||||
|
||||
subType = options: types.submodule {inherit options;};
|
||||
mkNullOption = type:
|
||||
mkOption {
|
||||
default = null;
|
||||
type = types.nullOr type;
|
||||
};
|
||||
|
||||
configType = subType {
|
||||
nix-jobs-by-default = mkOption {
|
||||
type = types.bool;
|
||||
default = true;
|
||||
description = "Handle jobs nix-based by default or via opt-in (in a job set nix.enable = true) if false";
|
||||
};
|
||||
};
|
||||
jobType = subType {
|
||||
# nix ci opts
|
||||
nix = mkOption {
|
||||
type = subType {
|
||||
enable = mkOption {
|
||||
type = types.bool;
|
||||
default = cfg.nix-jobs-by-default;
|
||||
description = "Handle this job as a nix job";
|
||||
};
|
||||
deps = mkOption {
|
||||
type = types.listOf types.package;
|
||||
default = [];
|
||||
description = "Dependencies/packages to install for this job";
|
||||
};
|
||||
enable-runner-cache = mkOption {
|
||||
type = types.bool;
|
||||
default = false;
|
||||
description = ''
|
||||
Cache this job using the GitLab Runner cache.
|
||||
Warning: useful for tiny jobs, but most of the time it just takes an eternity.
|
||||
'';
|
||||
};
|
||||
runner-cache-key = mkOption {
|
||||
type = types.str;
|
||||
default = "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG";
|
||||
description = "Cache key to use for the runner nix cache. Requires enable-runner-cache = true";
|
||||
};
|
||||
};
|
||||
default = {};
|
||||
description = "Configure Nix Gitlab CI for each job individually";
|
||||
};
|
||||
# gitlab opts
|
||||
script = mkOption {
|
||||
type = types.listOf types.str;
|
||||
default = [];
|
||||
};
|
||||
stage = mkOption {
|
||||
type = types.str;
|
||||
default = "test";
|
||||
};
|
||||
image = mkOption {
|
||||
type = types.str;
|
||||
default = "$NIX_CI_IMAGE";
|
||||
};
|
||||
after_script = mkNullOption (types.listOf types.str);
|
||||
allow_failure = mkNullOption (types.either types.attrs types.bool);
|
||||
artifacts = mkNullOption (types.attrs);
|
||||
before_script = mkNullOption (types.listOf types.str);
|
||||
cache = mkNullOption (types.either (types.listOf types.attrs) types.attrs);
|
||||
coverage = mkNullOption (types.str);
|
||||
dependencies = mkNullOption (types.listOf types.str);
|
||||
environment = mkNullOption (types.either types.attrs types.str);
|
||||
extends = mkNullOption (types.str);
|
||||
hooks = mkNullOption (types.attrs);
|
||||
id_tokens = mkNullOption (types.attrs);
|
||||
"inherit" = mkNullOption (types.attrs);
|
||||
interruptible = mkNullOption (types.bool);
|
||||
needs = mkNullOption (types.listOf (types.either types.str types.attrs));
|
||||
publish = mkNullOption (types.str);
|
||||
pages = mkNullOption (types.attrs);
|
||||
parallel = mkNullOption (types.either types.int types.attrs);
|
||||
release = mkNullOption (types.attrs);
|
||||
retry = mkNullOption (types.either types.int types.attrs);
|
||||
rules = mkNullOption (types.listOf types.attrs);
|
||||
resource_group = mkNullOption (types.str);
|
||||
secrets = mkNullOption (types.attrs);
|
||||
services = mkNullOption (types.listOf types.attrs);
|
||||
start_in = mkNullOption (types.str);
|
||||
tags = mkNullOption (types.listOf types.str);
|
||||
timeout = mkNullOption (types.str);
|
||||
variables = mkNullOption (types.attrs);
|
||||
when = mkNullOption (types.str);
|
||||
};
|
||||
|
||||
ciType = subType {
|
||||
config = mkOption {
|
||||
type = configType;
|
||||
description = ''
|
||||
Configuration options for the nix part itself
|
||||
'';
|
||||
default = {};
|
||||
};
|
||||
image = mkNullOption (types.str);
|
||||
variables = mkNullOption (types.attrs);
|
||||
default = mkNullOption (types.attrs);
|
||||
stages = mkNullOption (types.listOf types.str);
|
||||
include = mkNullOption (types.attrs);
|
||||
workflow = mkNullOption (types.attrs);
|
||||
jobs = mkOption {
|
||||
type = types.lazyAttrsOf jobType;
|
||||
default = {};
|
||||
};
|
||||
};
|
||||
in {
|
||||
options = {
|
||||
pipelines = mkOption {
|
||||
type = types.lazyAttrsOf ciType;
|
||||
description = ''
|
||||
Create multiple GitLab CI pipelines.
|
||||
|
||||
See README.md for more information about how a pipeline is selected.
|
||||
'';
|
||||
default = {};
|
||||
apply = op: let
|
||||
# NOTE: show warning if "default" is set and config.ci is not {}
|
||||
legacyMode = config.ci != {};
|
||||
defaultExists = builtins.hasAttr "default" op;
|
||||
value =
|
||||
{
|
||||
"default" = config.ci;
|
||||
}
|
||||
// op;
|
||||
in
|
||||
if defaultExists && legacyMode
|
||||
then builtins.trace "Warning: config.ci is overwritten by pipelines.default" value
|
||||
else value;
|
||||
};
|
||||
ci = mkOption {
|
||||
type = ciType;
|
||||
description = ''
|
||||
Note: this is a shorthand for writing `pipelines."default"`
|
||||
|
||||
Generate a Gitlab CI configuration which can be used to trigger a child pipeline.
|
||||
This will inject code which pre-downloads the nix deps before each job and adds them to PATH.
|
||||
'';
|
||||
default = {};
|
||||
};
|
||||
};
|
||||
|
||||
config.legacyPackages = lib.fold (pipeline: acc: acc // pipeline) {} (
|
||||
map (
|
||||
pipeline_name:
|
||||
(mkPipeline {
|
||||
pipeline = config.pipelines."${pipeline_name}";
|
||||
name = pipeline_name;
|
||||
}).packages
|
||||
) (builtins.attrNames config.pipelines)
|
||||
);
|
||||
}
|
||||
);
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
{lib, ...} @ args: let
|
||||
inherit (lib) isAttrs filterAttrs mapAttrs;
|
||||
in rec {
|
||||
prepend = key: arr: job:
|
||||
job
|
||||
// lib.optionalAttrs (job.nix.enable or false) {
|
||||
${key} =
|
||||
arr
|
||||
++ (job.${key} or []);
|
||||
};
|
||||
append = key: arr: job:
|
||||
job
|
||||
// lib.optionalAttrs (job.nix.enable or false) {
|
||||
${key} = (job.${key} or []) ++ arr;
|
||||
};
|
||||
prependToBeforeScript = prepend "before_script";
|
||||
appendToAfterScript = append "after_script";
|
||||
|
||||
# json is also valid yaml and this removes dependency on jq and/or remarshal
|
||||
# (used in pkgs.formats.json and pkgs.formats.yaml respectively)
|
||||
toYaml = name: value: builtins.toFile name (builtins.toJSON value);
|
||||
|
||||
customMapAttrs = cb: set: builtins.listToAttrs (builtins.map (key: cb key (builtins.getAttr key set)) (builtins.attrNames set));
|
||||
|
||||
filterAttrsRec = pred: v:
|
||||
if isAttrs v
|
||||
then filterAttrs pred (mapAttrs (path: filterAttrsRec pred) v)
|
||||
else v;
|
||||
|
||||
# filter job's variables to either only those containing store paths
|
||||
# or those that do not
|
||||
filterJobVariables = nix: job:
|
||||
lib.concatMapAttrs (
|
||||
name: value:
|
||||
lib.optionalAttrs ((lib.hasInfix "/nix/store/" value) == nix) {
|
||||
${name} = value;
|
||||
}
|
||||
)
|
||||
(job.variables or {});
|
||||
|
||||
# args.pkgs so "pkgs" does not need to be passed all the time
|
||||
stdenvMinimal = args.pkgs.stdenvNoCC.override {
|
||||
cc = null;
|
||||
preHook = "";
|
||||
allowedRequisites = null;
|
||||
initialPath = with args.pkgs; [coreutils findutils];
|
||||
extraNativeBuildInputs = [];
|
||||
};
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./. {inherit lib pkgs;};
|
||||
inherit (cilib.helpers) filterJobVariables stdenvMinimal;
|
||||
in {
|
||||
mkJobDeps = {
|
||||
key,
|
||||
job,
|
||||
}: let
|
||||
variablesWithStorePaths = filterJobVariables true job;
|
||||
variableExports = lib.concatLines (
|
||||
lib.mapAttrsToList (name: value: "export ${name}=\"${value}\"") variablesWithStorePaths
|
||||
);
|
||||
script = ''
|
||||
export PATH="${lib.makeBinPath (job.nix.deps or [])}:$PATH";
|
||||
# variables containing nix derivations:
|
||||
${variableExports}
|
||||
'';
|
||||
in
|
||||
stdenvMinimal.mkDerivation {
|
||||
name = "gitlab-ci-job-deps-${key}";
|
||||
dontUnpack = true;
|
||||
installPhase =
|
||||
# sh
|
||||
''
|
||||
echo '${script}' > $out
|
||||
chmod +x $out
|
||||
'';
|
||||
passthru = {
|
||||
inherit script;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./. {inherit lib pkgs;};
|
||||
inherit (lib) toList;
|
||||
inherit (cilib.helpers) prependToBeforeScript appendToAfterScript filterJobVariables;
|
||||
in {
|
||||
mkJobPatched = {
|
||||
key,
|
||||
job,
|
||||
pipeline_name,
|
||||
}:
|
||||
builtins.removeAttrs (
|
||||
(prependToBeforeScript [
|
||||
"source setup_nix_ci \"gitlab-ci:pipeline:${pipeline_name}:job-deps:${key}\""
|
||||
]
|
||||
(appendToAfterScript [
|
||||
"finalize_nix_ci"
|
||||
]
|
||||
job))
|
||||
// lib.optionalAttrs job.nix.enable (
|
||||
(let
|
||||
variables =
|
||||
(filterJobVariables false job)
|
||||
// lib.optionalAttrs job.nix.enable-runner-cache {
|
||||
NIX_CI_CACHE_STRATEGY = "runner";
|
||||
};
|
||||
in
|
||||
# filter empty variables
|
||||
lib.optionalAttrs (variables != {}) {
|
||||
inherit variables;
|
||||
})
|
||||
// (let
|
||||
cache =
|
||||
(toList (job.cache or []))
|
||||
++ (lib.optional (job.nix.enable-runner-cache) {
|
||||
key = job.nix.runner-cache-key;
|
||||
paths = [".nix-cache/"];
|
||||
});
|
||||
in
|
||||
# filter empty cache
|
||||
lib.optionalAttrs (cache != []) {
|
||||
inherit cache;
|
||||
})
|
||||
)
|
||||
) ["nix"];
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./. {inherit lib pkgs;};
|
||||
inherit (cilib.helpers) filterJobVariables;
|
||||
in {
|
||||
mkJobRun = {
|
||||
key,
|
||||
job,
|
||||
jobDeps,
|
||||
}: let
|
||||
variablesWithoutStorePaths = filterJobVariables false job;
|
||||
variableExports = lib.concatLines (
|
||||
lib.mapAttrsToList (name: value: "export ${name}=\"${value}\"") variablesWithoutStorePaths
|
||||
);
|
||||
sandboxHelper = pkgs.writeShellScriptBin "gitlab-ci-job-sandbox-helper" (builtins.readFile ./sandbox_helper.sh);
|
||||
actualJobScript = pkgs.writeShellScript "gitlab-ci-job:${key}:raw" ''
|
||||
# set up deps and environment variables containing store paths
|
||||
. ${jobDeps}
|
||||
# normal environment variables
|
||||
${variableExports}
|
||||
# run before_script, script and after_script
|
||||
echo -e "\e[32mRunning before_script...\e[0m"
|
||||
set -x
|
||||
${lib.concatLines (job.before_script or [])}
|
||||
{ set +x; } 2>/dev/null
|
||||
echo -e "\e[32mRunning script...\e[0m"
|
||||
set -x
|
||||
${lib.concatLines job.script}
|
||||
{ set +x; } 2>/dev/null
|
||||
echo -e "\e[32mRunning after_script...\e[0m"
|
||||
set -x
|
||||
${lib.concatLines (job.after_script or [])}
|
||||
{ set +x; } 2>/dev/null
|
||||
'';
|
||||
in
|
||||
# this way the sandbox helper just needs to be built once
|
||||
pkgs.writeShellScriptBin "gitlab-ci-job:${key}" ''
|
||||
exec ${lib.getExe sandboxHelper} ${actualJobScript} $@
|
||||
''
|
||||
// {
|
||||
passthru = {
|
||||
inherit jobDeps actualJobScript;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./. {inherit lib pkgs;};
|
||||
inherit (cilib.helpers) filterAttrsRec customMapAttrs toYaml;
|
||||
inherit (cilib.jobDeps) mkJobDeps;
|
||||
inherit (cilib.jobRun) mkJobRun;
|
||||
inherit (cilib.jobPatch) mkJobPatched;
|
||||
in {
|
||||
mkPipeline = {
|
||||
name,
|
||||
pipeline,
|
||||
}: let
|
||||
jobs = filterAttrsRec (n: v: v != null) pipeline.jobs;
|
||||
rest = filterAttrsRec (n: v: v != null) (builtins.removeAttrs pipeline ["jobs" "config"]);
|
||||
# this allows us to nix build this to get all the mentioned dependencies from the binary cache
|
||||
# pro: we don't have to download everything, just the deps for the current job
|
||||
# before, we just allowed pkgs inside the script string directly, but now with the ability to source this file
|
||||
# we can support different architectures between runners (eg. the arch of the initial runner does not matter)
|
||||
jobsMappedForDeps =
|
||||
customMapAttrs (key: job: {
|
||||
name = "gitlab-ci:pipeline:${name}:job-deps:${key}";
|
||||
value = mkJobDeps {inherit key job;};
|
||||
})
|
||||
jobs;
|
||||
# allows the user to directly run the script
|
||||
jobsMappedForScript =
|
||||
customMapAttrs (key: job: {
|
||||
name = "gitlab-ci:pipeline:${name}:job:${key}";
|
||||
value = mkJobRun {
|
||||
inherit key job;
|
||||
jobDeps = jobsMappedForDeps."gitlab-ci:pipeline:${name}:job-deps:${key}";
|
||||
};
|
||||
})
|
||||
jobs;
|
||||
# build the deps specific for this job before anything, this way the deps should be fetched from the cache
|
||||
jobsPatched =
|
||||
customMapAttrs (key: job: {
|
||||
name = key;
|
||||
value = assert lib.assertMsg (builtins.elem job.stage (rest.stages or [])) "stage '${job.stage}' of job '${key}' does not exist";
|
||||
mkJobPatched {
|
||||
inherit key job;
|
||||
pipeline_name = name;
|
||||
};
|
||||
})
|
||||
jobs;
|
||||
in {
|
||||
packages =
|
||||
# gitlab-ci:pipeline:<name>
|
||||
# gitlab-ci:pipeline:<name>:job:<name>
|
||||
# gitlab-ci:pipeline:<name>:job-deps:<name>
|
||||
{
|
||||
"gitlab-ci:pipeline:${name}" = toYaml "gitlab-ci-${name}.yml" (rest // jobsPatched);
|
||||
}
|
||||
// jobsMappedForDeps
|
||||
// jobsMappedForScript;
|
||||
finalConfig = rest // jobsPatched;
|
||||
};
|
||||
}
|
||||
|
|
@ -1,73 +0,0 @@
|
|||
echo -e "\e[32mSetting up...\e[0m"
|
||||
|
||||
actualJobScript=$1
|
||||
shift
|
||||
|
||||
INCLUDE_DIRTY=false
|
||||
NO_SANDBOX=false
|
||||
KEEP_TMP=false
|
||||
KEEP_ENV=""
|
||||
# parse flags
|
||||
while [[ $# -gt 0 ]]; do
|
||||
case "$1" in
|
||||
--include-dirty)
|
||||
INCLUDE_DIRTY=true
|
||||
shift
|
||||
;;
|
||||
--no-sandbox)
|
||||
NO_SANDBOX=true
|
||||
shift
|
||||
;;
|
||||
--keep-tmp)
|
||||
KEEP_TMP=true
|
||||
shift
|
||||
;;
|
||||
--keep-env)
|
||||
KEEP_ENV="$2"
|
||||
shift 2
|
||||
;;
|
||||
*)
|
||||
echo "Unknown option: $1" >&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
if [ "$NO_SANDBOX" = false ]; then
|
||||
echo "Running with simple sandboxing"
|
||||
if [ "$KEEP_TMP" = false ]; then
|
||||
trap "rm -rf '$TMPDIR'" EXIT
|
||||
else
|
||||
echo "Temp dir will be preserved at: $TMPDIR"
|
||||
fi
|
||||
|
||||
# check if dirty
|
||||
DIRTY_PATCH=""
|
||||
if ! git diff --quiet && ! git diff --staged --quiet; then
|
||||
echo "Warning: working tree is dirty."
|
||||
DIRTY_PATCH=$(mktemp -t "nix-gitlab-ci.XXX.patch")
|
||||
git diff --staged > "$DIRTY_PATCH"
|
||||
trap "rm -f '$DIRTY_PATCH'" EXIT
|
||||
fi
|
||||
TMPDIR=$(mktemp -dt "nix-gitlab-ci.XXX")
|
||||
git clone . $TMPDIR
|
||||
pushd $TMPDIR >/dev/null
|
||||
if [[ ! -z "$DIRTY_PATCH" && "$INCLUDE_DIRTY" = true ]]; then
|
||||
echo "Copying dirty changes..."
|
||||
git apply "$DIRTY_PATCH" 2>/dev/null || echo "Failed to copy dirty changes"
|
||||
fi
|
||||
|
||||
echo "Running job in $TMPDIR"
|
||||
env -i $(
|
||||
if [[ -n "$KEEP_ENV" ]]; then
|
||||
IFS=',' read -ra VARS <<< "$KEEP_ENV"
|
||||
for var in "${VARS[@]}"; do
|
||||
printf '%s=%q ' "$var" "${!var}"
|
||||
done
|
||||
fi
|
||||
) bash $actualJobScript
|
||||
popd >/dev/null
|
||||
else
|
||||
exec $actualJobScript
|
||||
fi
|
||||
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
{pkgs, ...}: {
|
||||
commitAndPushFiles = {
|
||||
message,
|
||||
files ? [],
|
||||
}: jobArgs:
|
||||
jobArgs
|
||||
// {
|
||||
before_script =
|
||||
(jobArgs.before_script or [])
|
||||
++ [
|
||||
# sh
|
||||
''
|
||||
echo -e "\\e[0Ksection_start:`date +%s`:commit_setup[collapsed=true]\\r\\e[0KSetting up commitAndPushFiles"
|
||||
eval "$(ssh-agent -s)" >/dev/null;
|
||||
mkdir -p ~/.ssh; touch ~/.ssh/known_hosts;
|
||||
ssh-keyscan -t rsa $CI_SERVER_HOST >> ~/.ssh/known_hosts;
|
||||
echo "$GIT_SSH_PRIV_KEY" | tr -d '\r' | ssh-add - >/dev/null;
|
||||
git config --global user.email "$GIT_EMAIL" >/dev/null;
|
||||
git config --global user.name "$GIT_NAME" >/dev/null;
|
||||
export CI_PUSH_REPO=`echo $CI_REPOSITORY_URL | sed -e "s|.*@\(.*\)|git@\1|" -e "s|/|:|"`;
|
||||
git remote rm origin && git remote add origin ''${CI_PUSH_REPO}
|
||||
echo -e "\\e[0Ksection_end:`date +%s`:commit_setup\\r\\e[0K"
|
||||
''
|
||||
];
|
||||
script = let
|
||||
addScript =
|
||||
if builtins.length files == 0
|
||||
then ""
|
||||
else "git add ${builtins.concatStringsSep " " files}";
|
||||
in
|
||||
(jobArgs.script or [])
|
||||
++ [
|
||||
# sh
|
||||
''
|
||||
echo -e "\\e[0Ksection_start:`date +%s`:commit[collapsed=true]\\r\\e[0KCommiting & pushing changes if necessary"
|
||||
${addScript}
|
||||
git diff --cached --exit-code >/dev/null &&
|
||||
echo "Nothing to commit" ||
|
||||
git commit -m "${message}" --no-verify;
|
||||
git push --tags origin ''${GIT_SOURCE_REF:-HEAD}:''${GIT_TARGET_REF:-$CI_COMMIT_REF_NAME} -o ci.skip
|
||||
echo -e "\\e[0Ksection_end:`date +%s`:commit\\r\\e[0K"
|
||||
''
|
||||
];
|
||||
nix.deps = (jobArgs.nix.deps or []) ++ [pkgs.openssh pkgs.gitMinimal pkgs.gnused];
|
||||
};
|
||||
}
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
echo -e "\\e[0Ksection_start:`date +%s`:finalize_nix_ci[collapsed=true]\\r\\e[0KFinalizing Nix CI..."
|
||||
nix path-info --all > /tmp/nix-store-after
|
||||
echo "Finding new paths..."
|
||||
NEW_PATHS=$(diff --new-line-format="%L" \
|
||||
--old-line-format="" --unchanged-line-format="" \
|
||||
/tmp/nix-store-before /tmp/nix-store-after)
|
||||
COUNT=$(wc -l <<<"$NEW_PATHS")
|
||||
|
||||
if [[ "$NIX_CI_CACHE_STRATEGY" == "auto" ]]; then
|
||||
export NIX_CI_CACHE_STRATEGY="${NIX_CI_RUNNER_CACHE_STRATEGY:-${NIX_CI_DEFAULT_CACHE_STRATEGY:-none}}";
|
||||
fi
|
||||
|
||||
if [ -z "$NIX_CI_DISABLE_CACHE" ]; then
|
||||
echo -e "\\e[0Ksection_start:`date +%s`:cache_push[collapsed=true]\\r\\e[0KPushing $COUNT new store paths to cache ($NIX_CI_CACHE_STRATEGY)"
|
||||
echo -n "$NEW_PATHS" | {
|
||||
case "$NIX_CI_CACHE_STRATEGY" in
|
||||
"runner")
|
||||
export RUNNER_CACHE=''${RUNNER_CACHE:-"file://$(pwd)/.nix-cache"}
|
||||
# add ^* to all store paths ending in .drv (prevent warning log spam)
|
||||
sed '/\.drv$/s/$/^*/' | nix copy --quiet --to "$RUNNER_CACHE" --stdin || true
|
||||
;;
|
||||
"attic")
|
||||
attic push --stdin ci:$ATTIC_CACHE || true
|
||||
;;
|
||||
"cachix")
|
||||
cachix push $CACHIX_CACHE || true
|
||||
;;
|
||||
"none")
|
||||
echo "Cache strategy is none, doing nothing..."
|
||||
;;
|
||||
*)
|
||||
echo "WARNING: Invalid cache strategy set: '$NIX_CI_CACHE_STRATEGY'"
|
||||
;;
|
||||
esac
|
||||
}
|
||||
echo -e "\\e[0Ksection_end:`date +%s`:cache_push\\r\\e[0K"
|
||||
else
|
||||
echo "Caching disabled, not uploading $COUNT new store entries..."
|
||||
fi
|
||||
echo -e "\\e[0Ksection_end:`date +%s`:finalize_nix_ci\\r\\e[0K"
|
||||
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
echo -e "\\e[0Ksection_start:`date +%s`:nix_setup[collapsed=true]\\r\\e[0KSetting up Nix CI"
|
||||
nix path-info --all > /tmp/nix-store-before
|
||||
|
||||
if [[ "$NIX_CI_CACHE_STRATEGY" == "auto" ]]; then
|
||||
export NIX_CI_CACHE_STRATEGY="${NIX_CI_RUNNER_CACHE_STRATEGY:-${NIX_CI_DEFAULT_CACHE_STRATEGY:-none}}";
|
||||
echo "NIX_CI_CACHE_STRATEGY was set to auto, selected '$NIX_CI_CACHE_STRATEGY' for this job"
|
||||
fi
|
||||
|
||||
if [ -z "$NIX_CI_DISABLE_CACHE" ]; then
|
||||
echo -e "\\e[0Ksection_start:`date +%s`:cache_setup[collapsed=true]\\r\\e[0KConfiguring cache ($NIX_CI_CACHE_STRATEGY)"
|
||||
case "$NIX_CI_CACHE_STRATEGY" in
|
||||
"runner")
|
||||
export RUNNER_CACHE=''${RUNNER_CACHE:-"file://$(pwd)/.nix-cache"}
|
||||
echo "Runner Cache: $RUNNER_CACHE"
|
||||
export NIX_CONFIG="$NIX_CONFIG
|
||||
extra-trusted-substituters = $RUNNER_CACHE?priority=10&trusted=true
|
||||
extra-substituters = $RUNNER_CACHE?priority=10&trusted=true
|
||||
"
|
||||
;;
|
||||
"attic")
|
||||
echo "Attic Cache: $ATTIC_CACHE"
|
||||
attic login --set-default ci "$ATTIC_SERVER" "$ATTIC_TOKEN" || true
|
||||
attic use "$ATTIC_CACHE" || true
|
||||
;;
|
||||
"cachix")
|
||||
echo "Cachix Cache: $CACHIX_CACHE"
|
||||
cachix use "$CACHIX_CACHE" || true
|
||||
;;
|
||||
"none")
|
||||
echo "Cache strategy is none, doing nothing..."
|
||||
;;
|
||||
*)
|
||||
echo "WARNING: Invalid cache strategy set: '$NIX_CI_CACHE_STRATEGY'"
|
||||
;;
|
||||
esac
|
||||
echo -e "\\e[0Ksection_end:`date +%s`:cache_setup\\r\\e[0K"
|
||||
else
|
||||
echo "Caching disabled (NIX_CI_DISABLE_CACHE), skipping cache configuration..."
|
||||
fi
|
||||
|
||||
# load the job's deps only if the name was passed
|
||||
if [[ ! -z $1 ]]; then
|
||||
echo -e "\\e[0Ksection_start:`date +%s`:nix_deps[collapsed=true]\\r\\e[0KFetching Nix dependencies for job"
|
||||
nix build .#$1
|
||||
source $(readlink -f result)
|
||||
echo -e "\\e[0Ksection_end:`date +%s`:nix_deps\\r\\e[0K"
|
||||
fi
|
||||
echo -e "\\e[0Ksection_end:`date +%s`:nix_setup\\r\\e[0K"
|
||||
|
||||
|
|
@ -1 +0,0 @@
|
|||
{"docs":{"after_script":["finalize_nix_ci"],"artifacts":{"paths":["public"]},"before_script":["source setup_nix_ci \"gitlab-ci:pipeline:default:job-deps:docs\""],"image":"$NIX_CI_IMAGE","script":["nix build .#docs:default\nmkdir -p public\ncp -r result/. public/\n"],"stage":"build"},"nixtest":{"after_script":["finalize_nix_ci"],"allow_failure":true,"artifacts":{"reports":{"junit":"junit.xml"},"when":"always"},"before_script":["source setup_nix_ci \"gitlab-ci:pipeline:default:job-deps:nixtest\""],"image":"$NIX_CI_IMAGE","script":["nix run .#nixtests:run -- --junit=junit.xml --pure"],"stage":"nixtest"},"pages":{"artifacts":{"paths":["public"]},"image":"alpine:latest","rules":[{"if":"$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH"}],"script":["true"],"stage":"deploy"},"stages":["test","nixtest","build","deploy"],"test":{"after_script":["finalize_nix_ci"],"before_script":["source setup_nix_ci \"gitlab-ci:pipeline:default:job-deps:test\""],"cache":[{"key":"$CI_JOB_NAME-$CI_COMMIT_REF_SLUG","paths":[".nix-cache/"]}],"image":"$NIX_CI_IMAGE","script":["hello","curl google.de","echo $TEST $TEST_WITH_DERIVATION"],"stage":"test","variables":{"NIX_CI_CACHE_STRATEGY":"runner","TEST":"test"}},"test-default":{"after_script":["finalize_nix_ci"],"before_script":["source setup_nix_ci \"gitlab-ci:pipeline:default:job-deps:test-default\""],"image":"$NIX_CI_IMAGE","script":["hello"],"stage":"test"},"test-non-nix":{"image":"alpine:latest","script":["echo \"This job will not be modified to use nix\""],"stage":"test"}}
|
||||
|
|
@ -1 +0,0 @@
|
|||
{"stages":["test"],"test":{"after_script":["finalize_nix_ci"],"before_script":["source setup_nix_ci \"gitlab-ci:pipeline:non-default:job-deps:test\""],"image":"$NIX_CI_IMAGE","script":["echo Hello from another pipeline"],"stage":"test"}}
|
||||
|
|
@ -1,112 +0,0 @@
|
|||
spec:
|
||||
inputs:
|
||||
cache_strategy:
|
||||
type: string
|
||||
description: |
|
||||
auto (default) | none | runner | cachix | attic
|
||||
Sets the default caching strategy.
|
||||
- "auto": dynamically selects the best strategy for every job based on env variables
|
||||
- "none": disables caching
|
||||
- "runner", "cachix" & "attic": forces every job to use this strategy
|
||||
|
||||
Can be overridden by setting NIX_CI_CACHE_STRATEGY in the pipeline variables.
|
||||
default: "auto"
|
||||
cache_files:
|
||||
type: array
|
||||
description: |
|
||||
Files to use as the cache key for the generated pipeline yaml.
|
||||
If you use "ci.nix" to define CI, add that here for example.
|
||||
Note that max 2 items are allowed in cache:key:files, so use something like
|
||||
["flake.*", "ci.nix"] f. ex. to match flake.lock, flake.nix and ci.nix.
|
||||
default: ["flake.nix", "flake.lock"]
|
||||
version:
|
||||
type: string
|
||||
description: |
|
||||
Which version of the Nix CI image to use. Using a tag/version is recommended.
|
||||
stage_build:
|
||||
type: string
|
||||
description: The CI stage for building the dynamic pipeline.
|
||||
default: build
|
||||
stage_trigger:
|
||||
type: string
|
||||
description: The CI stage for triggering the dynamic pipeline.
|
||||
default: trigger
|
||||
---
|
||||
stages:
|
||||
- $[[ inputs.stage_build ]]
|
||||
- $[[ inputs.stage_trigger ]]
|
||||
variables:
|
||||
# These can be overriden, see https://docs.gitlab.com/ci/variables/#cicd-variable-precedence
|
||||
# which image should be used by default.
|
||||
NIX_CI_IMAGE: registry.gitlab.com/technofab/nix-gitlab-ci/nix-ci:$[[ inputs.version ]]
|
||||
# default cache stategy
|
||||
NIX_CI_CACHE_STRATEGY: $[[ inputs.cache_strategy ]]
|
||||
nix-ci:build:
|
||||
stage: $[[ inputs.stage_build ]]
|
||||
image: $NIX_CI_IMAGE
|
||||
cache:
|
||||
- key:
|
||||
files: $[[ inputs.cache_files ]]
|
||||
paths:
|
||||
- .nix-ci-pipelines/
|
||||
- key: nix
|
||||
paths:
|
||||
- .nix-cache/
|
||||
before_script:
|
||||
- |
|
||||
# if no explicit pipeline is requested
|
||||
if [[ -z "${NIX_CI_PIPELINE_NAME:-}" ]]; then
|
||||
# if regex matches, use pipeline "default", otherwise $CI_PIPELINE_SOURCE
|
||||
[[ "${CI_PIPELINE_SOURCE}" =~ ${NIX_CI_DEFAULT_SOURCES:-.*} ]] \
|
||||
&& NIX_CI_PIPELINE_NAME="default" \
|
||||
|| NIX_CI_PIPELINE_NAME="$CI_PIPELINE_SOURCE";
|
||||
fi
|
||||
echo "NIX_CI_GENERATED_PIPELINE_NAME=$NIX_CI_PIPELINE_NAME" >> trigger.env
|
||||
# inheritance of pipeline variables is a bit weird, so explicitly override them
|
||||
# (ctx: setting any of these in the project variables would only apply correctly
|
||||
# in this pipeline, not the child pipeline, instead weirdly enough the default
|
||||
# variables above are used). If any other variables are added at the top, add them
|
||||
# here aswell
|
||||
echo "NIX_CI_IMAGE=$NIX_CI_IMAGE" >> trigger.env
|
||||
echo "NIX_CI_CACHE_STRATEGY=$NIX_CI_CACHE_STRATEGY" >> trigger.env
|
||||
|
||||
mkdir -p .nix-ci-pipelines/
|
||||
# generated-gitlab-ci.yml exists in the cache
|
||||
[[ -f ".nix-ci-pipelines/${NIX_CI_PIPELINE_NAME}.yml" ]] && export CACHED=true && echo "A cached pipeline file exists (skip cache with NIX_CI_FORCE_BUILD)" || true
|
||||
# allow the user to manually skip the cache (when the key files are not correctly configured etc.)
|
||||
[[ -n "$NIX_CI_FORCE_BUILD" ]] && unset CACHED && echo "Caching skipped for this job (through NIX_CI_FORCE_BUILD)" || true
|
||||
|
||||
# only setup when we need to generate the pipeline yaml
|
||||
if [[ -z "$CACHED" ]]; then
|
||||
source setup_nix_ci;
|
||||
fi
|
||||
script:
|
||||
# build the pipeline if it does not exist in the cache
|
||||
- >
|
||||
if [[ -z "$CACHED" ]]; then
|
||||
nix build .#gitlab-ci:pipeline:${NIX_CI_PIPELINE_NAME} && install result .nix-ci-pipelines/${NIX_CI_PIPELINE_NAME}.yml;
|
||||
fi
|
||||
after_script:
|
||||
# save to binary cache or Gitlab CI cache only if we actually built something
|
||||
# check if /tmp/nix-store-before exists as $CACHED never exists here and the file only exists if "setup_nix_ci" is called
|
||||
- |
|
||||
if [[ -f "/tmp/nix-store-before" ]]; then
|
||||
finalize_nix_ci;
|
||||
fi
|
||||
artifacts:
|
||||
paths:
|
||||
- .nix-ci-pipelines/
|
||||
reports:
|
||||
dotenv: trigger.env
|
||||
|
||||
nix-ci:trigger:
|
||||
stage: $[[ inputs.stage_trigger ]]
|
||||
needs:
|
||||
- nix-ci:build
|
||||
trigger:
|
||||
include:
|
||||
- artifact: .nix-ci-pipelines/${NIX_CI_GENERATED_PIPELINE_NAME}.yml
|
||||
job: nix-ci:build
|
||||
strategy: depend
|
||||
forward:
|
||||
pipeline_variables: true
|
||||
140
tests/ci-lib.nix
140
tests/ci-lib.nix
|
|
@ -1,140 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./../lib {inherit lib pkgs;};
|
||||
in {
|
||||
nixtest.suites."CI Lib" = {
|
||||
pos = __curPos;
|
||||
tests = let
|
||||
inherit (cilib.jobDeps) mkJobDeps;
|
||||
inherit (cilib.jobRun) mkJobRun;
|
||||
inherit (cilib.jobPatch) mkJobPatched;
|
||||
inherit (cilib.pipeline) mkPipeline;
|
||||
deps = mkJobDeps {
|
||||
key = "test";
|
||||
job = {
|
||||
nix.deps = [pkgs.hello];
|
||||
variables.TEST = "${pkgs.curl}";
|
||||
};
|
||||
};
|
||||
in [
|
||||
{
|
||||
name = "jobDeps";
|
||||
type = "script";
|
||||
script =
|
||||
# sh
|
||||
''
|
||||
export PATH=${lib.makeBinPath [pkgs.gnugrep]}
|
||||
grep -q "/nix/store" ${deps}
|
||||
grep -q 'hello/bin:$PATH' ${deps}
|
||||
grep -q "export TEST=" ${deps}
|
||||
grep -q "curl" ${deps}
|
||||
'';
|
||||
}
|
||||
{
|
||||
name = "jobRun";
|
||||
type = "script";
|
||||
script = let
|
||||
run = mkJobRun {
|
||||
key = "test";
|
||||
job.script = ["hello"];
|
||||
jobDeps = deps;
|
||||
};
|
||||
in
|
||||
# sh
|
||||
''
|
||||
export PATH=${lib.makeBinPath [pkgs.gnugrep]}
|
||||
grep -q "sandbox-helper" ${run}/bin/gitlab-ci-job:test
|
||||
grep -q "gitlab-ci-job-test-raw" ${run}/bin/gitlab-ci-job:test
|
||||
grep -q "gitlab-ci-job-deps-test" ${run.passthru.actualJobScript}
|
||||
grep -q "Running script..." ${run.passthru.actualJobScript}
|
||||
grep -q "hello" ${run.passthru.actualJobScript}
|
||||
'';
|
||||
}
|
||||
{
|
||||
name = "jobPatched nix disabled";
|
||||
expected = {};
|
||||
actual = mkJobPatched {
|
||||
key = "test";
|
||||
pipeline_name = "test";
|
||||
job.nix.enable = false;
|
||||
};
|
||||
}
|
||||
{
|
||||
name = "jobPatched without runner cache";
|
||||
expected = {
|
||||
after_script = ["finalize_nix_ci"];
|
||||
before_script = ["source setup_nix_ci \"gitlab-ci:pipeline:test:job-deps:test\""];
|
||||
};
|
||||
actual = mkJobPatched {
|
||||
key = "test";
|
||||
pipeline_name = "test";
|
||||
job.nix = {
|
||||
enable = true;
|
||||
enable-runner-cache = false;
|
||||
};
|
||||
};
|
||||
}
|
||||
{
|
||||
name = "jobPatched with runner cache";
|
||||
expected = {
|
||||
after_script = ["finalize_nix_ci"];
|
||||
before_script = ["source setup_nix_ci \"gitlab-ci:pipeline:test:job-deps:test\""];
|
||||
cache = [
|
||||
{
|
||||
key = "test";
|
||||
paths = [".nix-cache/"];
|
||||
}
|
||||
];
|
||||
variables."NIX_CI_CACHE_STRATEGY" = "runner";
|
||||
};
|
||||
actual = mkJobPatched {
|
||||
key = "test";
|
||||
pipeline_name = "test";
|
||||
job.nix = {
|
||||
enable = true;
|
||||
enable-runner-cache = true;
|
||||
runner-cache-key = "test";
|
||||
};
|
||||
};
|
||||
}
|
||||
{
|
||||
name = "mkPipeline empty";
|
||||
expected = {};
|
||||
actual =
|
||||
(mkPipeline {
|
||||
name = "test";
|
||||
pipeline.jobs = {};
|
||||
}).finalConfig;
|
||||
}
|
||||
{
|
||||
name = "mkPipeline empty packages";
|
||||
type = "script";
|
||||
script = let
|
||||
pipeline = builtins.toFile "pipeline-test" (builtins.toJSON
|
||||
(mkPipeline {
|
||||
name = "test";
|
||||
pipeline.jobs = {};
|
||||
}).packages);
|
||||
in
|
||||
# sh
|
||||
''
|
||||
set -euo pipefail
|
||||
export PATH=${lib.makeBinPath [pkgs.jq pkgs.gnugrep pkgs.coreutils]}
|
||||
# single key
|
||||
jq 'keys | length == 1' "${pipeline}" | grep -q true
|
||||
# key is exactly "gitlab-ci:pipeline:test"
|
||||
jq -r 'keys[0]' "${pipeline}" | grep -qx "gitlab-ci:pipeline:test"
|
||||
# value contains "/nix/store/"
|
||||
jq -r '.["gitlab-ci:pipeline:test"]' "${pipeline}" | grep -q "/nix/store/"
|
||||
# value contains "gitlab-ci-test.yml"
|
||||
jq -r '.["gitlab-ci:pipeline:test"]' "${pipeline}" | grep -q "gitlab-ci-test.yml"
|
||||
# file only contains "{}"
|
||||
[[ "$(cat $(jq -r '.["gitlab-ci:pipeline:test"]' "${pipeline}"))" == "{}" ]]
|
||||
'';
|
||||
}
|
||||
];
|
||||
};
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
{
|
||||
imports = [
|
||||
./utils.nix
|
||||
./ci-lib.nix
|
||||
./helpers.nix
|
||||
./pipeline-yamls.nix
|
||||
];
|
||||
}
|
||||
|
|
@ -1,96 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./../lib {inherit lib pkgs;};
|
||||
in {
|
||||
nixtest.suites."Helpers" = {
|
||||
pos = __curPos;
|
||||
tests = let
|
||||
inherit (cilib) helpers;
|
||||
in [
|
||||
{
|
||||
name = "appendToAfterScript nix disabled";
|
||||
expected = {};
|
||||
actual = helpers.appendToAfterScript [] {};
|
||||
}
|
||||
{
|
||||
name = "appendToAfterScript empty";
|
||||
expected = {
|
||||
nix.enable = true;
|
||||
after_script = [];
|
||||
};
|
||||
actual = helpers.appendToAfterScript [] {nix.enable = true;};
|
||||
}
|
||||
{
|
||||
name = "appendToAfterScript";
|
||||
expected = {
|
||||
nix.enable = true;
|
||||
after_script = ["echo after_script" "finalize_nix_ci"];
|
||||
};
|
||||
actual = helpers.appendToAfterScript ["finalize_nix_ci"] {
|
||||
nix.enable = true;
|
||||
after_script = ["echo after_script"];
|
||||
};
|
||||
}
|
||||
{
|
||||
name = "prependToBeforeScript nix disabled";
|
||||
expected = {};
|
||||
actual = helpers.prependToBeforeScript [] {};
|
||||
}
|
||||
{
|
||||
name = "prependToBeforeScript empty";
|
||||
expected = {
|
||||
nix.enable = true;
|
||||
before_script = [];
|
||||
};
|
||||
actual = helpers.prependToBeforeScript [] {nix.enable = true;};
|
||||
}
|
||||
{
|
||||
name = "prependToBeforeScript";
|
||||
expected = {
|
||||
nix.enable = true;
|
||||
before_script = ["setup_nix_ci" "echo before_script"];
|
||||
};
|
||||
actual = helpers.prependToBeforeScript ["setup_nix_ci"] {
|
||||
nix.enable = true;
|
||||
before_script = ["echo before_script"];
|
||||
};
|
||||
}
|
||||
{
|
||||
name = "toYaml";
|
||||
expected = ''{"hello":"world"}'';
|
||||
actual = builtins.readFile (helpers.toYaml "test" {hello = "world";});
|
||||
}
|
||||
{
|
||||
name = "filterAttrsRec";
|
||||
expected = {world = "world";};
|
||||
actual = helpers.filterAttrsRec (n: v: v != null) {
|
||||
hello = null;
|
||||
world = "world";
|
||||
};
|
||||
}
|
||||
{
|
||||
name = "filterJobVariables with store paths";
|
||||
expected = {HELLO = "${pkgs.hello}";};
|
||||
actual = helpers.filterJobVariables true {
|
||||
variables = {
|
||||
HELLO = "${pkgs.hello}";
|
||||
WORLD = "world";
|
||||
};
|
||||
};
|
||||
}
|
||||
{
|
||||
name = "filterJobVariables without store paths";
|
||||
expected = {WORLD = "world";};
|
||||
actual = helpers.filterJobVariables false {
|
||||
variables = {
|
||||
HELLO = "${pkgs.hello}";
|
||||
WORLD = "world";
|
||||
};
|
||||
};
|
||||
}
|
||||
];
|
||||
};
|
||||
}
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
self',
|
||||
...
|
||||
}: let
|
||||
cilib = import ./../lib {inherit lib pkgs;};
|
||||
in {
|
||||
nixtest.suites."Pipeline YAMLs" = {
|
||||
pos = __curPos;
|
||||
tests = let
|
||||
jsonFile = file: builtins.fromJSON (builtins.readFile file);
|
||||
in [
|
||||
{
|
||||
name = "default";
|
||||
type = "snapshot";
|
||||
actual = jsonFile self'.legacyPackages."gitlab-ci:pipeline:default";
|
||||
}
|
||||
{
|
||||
name = "non-default";
|
||||
type = "snapshot";
|
||||
actual = jsonFile self'.legacyPackages."gitlab-ci:pipeline:non-default";
|
||||
}
|
||||
];
|
||||
};
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
{
|
||||
lib,
|
||||
pkgs,
|
||||
...
|
||||
}: let
|
||||
cilib = import ./../lib {inherit lib pkgs;};
|
||||
in {
|
||||
nixtest.suites."Utils" = {
|
||||
pos = __curPos;
|
||||
tests = [
|
||||
{
|
||||
name = "commitAndPushFiles";
|
||||
type = "script";
|
||||
script = let
|
||||
inherit (cilib) utils;
|
||||
job = builtins.toFile "test" (
|
||||
builtins.unsafeDiscardStringContext (
|
||||
builtins.toJSON (
|
||||
utils.commitAndPushFiles {
|
||||
message = "hello world";
|
||||
files = ["a.md" "b.txt"];
|
||||
} {}
|
||||
)
|
||||
)
|
||||
);
|
||||
in
|
||||
# sh
|
||||
''
|
||||
export PATH=${lib.makeBinPath [pkgs.gnugrep]}
|
||||
grep -q 'git commit -m \\"hello world\\"' ${job}
|
||||
grep -q 'git add a.md b.txt' ${job}
|
||||
'';
|
||||
}
|
||||
];
|
||||
};
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue