Maximilian Bosch
8d581f42d9
Step II to move the code out of flake.nix. Done in a second intermediate commit to make it easier to review. Change-Id: I13fb386f2e9b87b1d28c366e9b7f0d2dbe03315c
664 lines
24 KiB
Nix
664 lines
24 KiB
Nix
{
|
|
description = "Lix: A modern, delicious implementation of the Nix package manager";
|
|
|
|
inputs = {
|
|
nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11-small";
|
|
nixpkgs-regression.url = "github:NixOS/nixpkgs/215d4d0fd80ca5163643b03a33fde804a29cc1e2";
|
|
|
|
# Required because Nix 2.18 is not in Nixpkgs ≥ 25.05 anymore.
|
|
nix_2_18 = {
|
|
url = "github:NixOS/nix/2.18.9";
|
|
# NOTE(Raito): this is not possible because patches on libseccomp does not apply anymore on this Nix.
|
|
# Let's keep the latest known nixpkgs useable with Nix 2.18 for our tests.
|
|
# inputs.nixpkgs.follows = "nixpkgs";
|
|
inputs.nixpkgs-regression.follows = "nixpkgs-regression";
|
|
inputs.flake-compat.follows = "flake-compat";
|
|
};
|
|
|
|
pre-commit-hooks = {
|
|
url = "github:cachix/git-hooks.nix";
|
|
flake = false;
|
|
};
|
|
nix2container = {
|
|
url = "github:nlewo/nix2container";
|
|
flake = false;
|
|
};
|
|
flake-compat = {
|
|
url = "https://git.lix.systems/lix-project/flake-compat/archive/main.tar.gz";
|
|
flake = false;
|
|
};
|
|
};
|
|
|
|
outputs =
|
|
{
|
|
self,
|
|
nixpkgs,
|
|
nixpkgs-regression,
|
|
pre-commit-hooks,
|
|
nix2container,
|
|
nix_2_18,
|
|
flake-compat,
|
|
}:
|
|
|
|
let
|
|
inherit (nixpkgs) lib;
|
|
lixSrc = self;
|
|
|
|
# This notice gets echoed as a dev shell hook, and can be turned off with
|
|
# `touch .nocontribmsg`
|
|
sgr = builtins.fromJSON ''"\u001b["'';
|
|
freezePage = "https://wiki.lix.systems/books/lix-contributors/page/freezes-and-recommended-contributions";
|
|
codebaseOverview = "https://wiki.lix.systems/books/lix-contributors/page/codebase-overview";
|
|
gerritWiki = "https://wiki.lix.systems/books/lix-contributors/page/gerrit";
|
|
contribNotice = builtins.toFile "lix-contrib-notice" ''
|
|
Hey there!
|
|
|
|
If you're thinking of working on Lix, please consider talking to us about it!
|
|
You should be aware that we are ${sgr}1mnot${sgr}0m accepting major features without some conditions,
|
|
and we highly recommend looking at our freeze status page on the wiki:
|
|
${sgr}32m${freezePage}${sgr}0m
|
|
|
|
We also have an overview of the codebase at
|
|
${sgr}32m${codebaseOverview}${sgr}0m,
|
|
and other helpful information on the wiki.
|
|
|
|
But above all else, ${sgr}1mwe want to hear from you!${sgr}0m
|
|
We can help you figure out where in the codebase to look for whatever you want to do,
|
|
and we'd like to work together with all contributors as much as possible.
|
|
Lix is a collaborative project :)
|
|
|
|
If you want to submit a patch and you never used gerrit before, please
|
|
check our gerrit wiki section:
|
|
${sgr}32m${gerritWiki}${sgr}0m
|
|
|
|
You can open an issue at https://git.lix.systems/lix-project/lix/issues
|
|
or chat with us on Matrix: #space:lix.systems.
|
|
|
|
(Run `touch .nocontribmsg` to hide this message.)
|
|
'';
|
|
|
|
scope = lib.fix (self: {
|
|
# Set to true to build the release notes for the next release.
|
|
buildUnreleasedNotes = true;
|
|
|
|
versionJson = builtins.fromJSON (builtins.readFile ./version.json);
|
|
officialRelease = self.versionJson.official_release;
|
|
|
|
versionSuffix =
|
|
if self.officialRelease then
|
|
""
|
|
else
|
|
"pre${
|
|
builtins.substring 0 8 (lixSrc.lastModifiedDate or lixSrc.lastModified or "19700101")
|
|
}-dev_${lixSrc.shortRev or "dirty"}";
|
|
|
|
linux32BitSystems = [ "i686-linux" ];
|
|
linux64BitSystems = [
|
|
"x86_64-linux"
|
|
"aarch64-linux"
|
|
];
|
|
linuxSystems = self.linux32BitSystems ++ self.linux64BitSystems;
|
|
darwinSystems = [
|
|
"x86_64-darwin"
|
|
"aarch64-darwin"
|
|
];
|
|
nonDarwinSystems = self.linuxSystems;
|
|
systems = self.linuxSystems ++ self.darwinSystems;
|
|
|
|
# If you add something here, please update the list in doc/manual/src/contributing/hacking.md.
|
|
# Thanks~
|
|
crossSystems = [
|
|
"armv6l-linux"
|
|
"armv7l-linux"
|
|
"riscv64-linux"
|
|
"aarch64-linux"
|
|
"x86_64-freebsd"
|
|
# FIXME: broken dev shell due to python
|
|
# "x86_64-netbsd"
|
|
];
|
|
|
|
stdenvs = [
|
|
# see assertion in package.nix why these two are disabled
|
|
# "stdenv"
|
|
# "gccStdenv"
|
|
"clangStdenv"
|
|
"libcxxStdenv"
|
|
"ccacheStdenv"
|
|
];
|
|
|
|
forAllSystems = lib.genAttrs self.systems;
|
|
# Same as forAllSystems, but removes nulls, in case something is broken
|
|
# on that system.
|
|
forAvailableSystems =
|
|
f: lib.filterAttrs (name: value: value != null && value != { }) (self.forAllSystems f);
|
|
|
|
forAllCrossSystems = lib.genAttrs self.crossSystems;
|
|
|
|
forAllStdenvs =
|
|
f:
|
|
lib.listToAttrs (
|
|
map (stdenvName: {
|
|
name = "${stdenvName}Packages";
|
|
value = f stdenvName;
|
|
}) self.stdenvs
|
|
)
|
|
// {
|
|
# TODO delete this and reënable gcc stdenvs once gcc compiles kj coros correctly
|
|
stdenvPackages = f "clangStdenv";
|
|
};
|
|
|
|
# Memoize nixpkgs for different platforms for efficiency.
|
|
nixpkgsFor = self.forAllSystems (
|
|
system:
|
|
let
|
|
make-pkgs =
|
|
crossSystem: stdenv:
|
|
import nixpkgs {
|
|
localSystem = {
|
|
inherit system;
|
|
};
|
|
crossSystem = if crossSystem == null then null else { system = crossSystem; };
|
|
overlays = [ (self.overlayFor (p: p.${stdenv})) ];
|
|
};
|
|
stdenvs = self.forAllStdenvs (make-pkgs null);
|
|
native = stdenvs.stdenvPackages;
|
|
in
|
|
{
|
|
inherit stdenvs native;
|
|
static = native.pkgsStatic;
|
|
cross = self.forAllCrossSystems (crossSystem: make-pkgs crossSystem "clangStdenv");
|
|
}
|
|
);
|
|
|
|
overlayFor =
|
|
getStdenv: final: prev:
|
|
let
|
|
currentStdenv = getStdenv final;
|
|
in
|
|
{
|
|
nixStable = prev.nix;
|
|
|
|
nixVersions = prev.nixVersions // {
|
|
# Nix 2.18 has been removed from Nixpkgs ≥ 25.05, so we need to reintroduce it ourselves for our tests.
|
|
nix_2_18 =
|
|
(import nix_2_18).packages.${currentStdenv.hostPlatform.system}.default.overrideAttrs
|
|
(_: {
|
|
pname = "nix";
|
|
});
|
|
};
|
|
|
|
check-headers = final.buildPackages.callPackage ./maintainers/check-headers.nix { };
|
|
check-syscalls = final.buildPackages.callPackage ./maintainers/check-syscalls.nix { };
|
|
|
|
default-busybox-sandbox-shell = final.busybox.override {
|
|
useMusl = true;
|
|
enableStatic = true;
|
|
enableMinimal = true;
|
|
extraConfig = ''
|
|
CONFIG_FEATURE_FANCY_ECHO y
|
|
CONFIG_FEATURE_SH_MATH y
|
|
CONFIG_FEATURE_SH_MATH_64 y
|
|
|
|
CONFIG_ASH y
|
|
CONFIG_ASH_OPTIMIZE_FOR_SIZE y
|
|
|
|
CONFIG_ASH_ALIAS y
|
|
CONFIG_ASH_BASH_COMPAT y
|
|
CONFIG_ASH_CMDCMD y
|
|
CONFIG_ASH_ECHO y
|
|
CONFIG_ASH_GETOPTS y
|
|
CONFIG_ASH_INTERNAL_GLOB y
|
|
CONFIG_ASH_JOB_CONTROL y
|
|
CONFIG_ASH_PRINTF y
|
|
CONFIG_ASH_TEST y
|
|
'';
|
|
};
|
|
|
|
nix = final.callPackage ./package.nix {
|
|
inherit (self) versionSuffix officialRelease;
|
|
stdenv = currentStdenv;
|
|
busybox-sandbox-shell = final.busybox-sandbox-shell or final.default-busybox-sandbox-shell;
|
|
# See below
|
|
lowdown = final.lowdown_3_0;
|
|
lowdown-unsandboxed = final.lowdown_3_0.override { enableDarwinSandbox = false; };
|
|
};
|
|
|
|
lix-clang-tidy = final.callPackage ./subprojects/lix-clang-tidy { };
|
|
|
|
nix-eval-jobs = final.callPackage ./subprojects/nix-eval-jobs {
|
|
stdenv = currentStdenv;
|
|
srcDir = ./subprojects/nix-eval-jobs;
|
|
};
|
|
|
|
# HACK: We need nix-prefetch-git for fetchCargoVendor for Rust stuff,
|
|
# so it can't use Lix, or we infrec:
|
|
# lix -> Rust stuff -> fetchCargoVendor -> nix-prefetch-git -> nix (lix)
|
|
# This will eventually become a problem upstream, but until then,
|
|
# apply some duct tape and pray.
|
|
nix-prefetch-git =
|
|
if (lib.functionArgs prev.nix-prefetch-git.override) ? "nix" then
|
|
prev.nix-prefetch-git.override { nix = prev.nix; }
|
|
else
|
|
prev.nix-prefetch-git;
|
|
|
|
# Export the patched version of boehmgc that Lix uses into the overlay
|
|
# for consumers of this flake.
|
|
boehmgc-nix = final.nix.passthru.boehmgc-nix;
|
|
# And same thing for our build-release-notes package.
|
|
build-release-notes = final.nix.passthru.build-release-notes;
|
|
|
|
# As soon as Nixpkgs updates to >= 3.0.0, change to lowdown_2_0!
|
|
# We don't change the default version in order to not change the hash
|
|
# of Nix/Lix from upstream Nixpkgs.
|
|
lowdown_3_0 =
|
|
if (lib.versions.major prev.lowdown.version == "3") then
|
|
prev.lowdown
|
|
else
|
|
prev.lowdown.overrideAttrs (
|
|
finalAttrs: _prevAttrs: {
|
|
version = "3.0.0";
|
|
|
|
src = final.fetchurl {
|
|
url = "https://kristaps.bsd.lv/lowdown/snapshots/lowdown-${finalAttrs.version}.tar.gz";
|
|
sha512 = "94e97234d598382c3c3dc27f9bfdb3a3a2fcf7dbb6a8df3c85ee09f27f792449034a41d49d9cfd3d8450d2de01b8562c20c3d120e65c81af4d7d6c9454119e93";
|
|
};
|
|
}
|
|
);
|
|
|
|
capnproto = prev.capnproto.overrideAttrs (old: {
|
|
patches =
|
|
old.patches or [ ]
|
|
++ [
|
|
# backport of https://github.com/capnproto/capnproto/pull/1810
|
|
./misc/capnproto-promise-nodiscard.patch
|
|
]
|
|
++ lib.optionals (lib.versionOlder old.version "1.2.0") [
|
|
# backport of https://github.com/capnproto/capnproto/pull/2296
|
|
./misc/capnproto-monotonic-clocks-are-a-lie.patch
|
|
];
|
|
});
|
|
};
|
|
});
|
|
|
|
inherit (scope)
|
|
buildUnreleasedNotes
|
|
crossSystems
|
|
darwinSystems
|
|
forAllStdenvs
|
|
forAllSystems
|
|
forAvailableSystems
|
|
linux64BitSystems
|
|
nixpkgsFor
|
|
nonDarwinSystems
|
|
officialRelease
|
|
overlayFor
|
|
stdenvs
|
|
systems
|
|
versionSuffix
|
|
;
|
|
in
|
|
{
|
|
# for repl debugging
|
|
inherit self;
|
|
|
|
# A Nixpkgs overlay that overrides the 'nix' and
|
|
# 'nix.perl-bindings' packages.
|
|
overlays.default = overlayFor (p: p.clangStdenv);
|
|
|
|
hydraJobs = {
|
|
# Aggregate job that is finished in Hydra _after_ all constituent jobs (here: grouped by system)
|
|
# succeed.
|
|
# This is used to run CD scripts once all builds are finished on Hydra.
|
|
release = forAllSystems (
|
|
system:
|
|
let
|
|
pkgs = nixpkgsFor.${system}.native;
|
|
in
|
|
pkgs.runCommand "release"
|
|
{
|
|
_hydraAggregate = true;
|
|
constituents = lib.filter (x: x != null) (
|
|
lib.mapAttrsToListRecursiveCond
|
|
(_: val: !(lib.isDerivation val || builtins.any (system': val ? ${system'}) systems))
|
|
(
|
|
path: drv:
|
|
if drv ? ${system} then
|
|
lib.concatStringsSep "." (path ++ [ system ])
|
|
else if drv.system or null == system then
|
|
lib.concatStringsSep "." path
|
|
else
|
|
null
|
|
)
|
|
(
|
|
removeAttrs self.hydraJobs [
|
|
"devShell"
|
|
"release"
|
|
"rl-next"
|
|
]
|
|
)
|
|
);
|
|
}
|
|
''
|
|
touch $out
|
|
''
|
|
);
|
|
|
|
# Binary package for various platforms.
|
|
build = forAllSystems (system: self.packages.${system}.nix);
|
|
|
|
# Ensure support for lowdown < 3.0 doesn't regress for NixOS 25.11
|
|
build-lowdown_2_0 = lib.genAttrs [ "aarch64-linux" ] (
|
|
system:
|
|
assert lib.versionOlder nixpkgsFor.${system}.native.lowdown.version "3.0.0";
|
|
self.packages.${system}.nix.override {
|
|
lowdown = nixpkgsFor.${system}.native.lowdown;
|
|
lowdown-unsandboxed = nixpkgsFor.${system}.native.lowdown-unsandboxed;
|
|
}
|
|
);
|
|
|
|
buildStatic = lib.genAttrs linux64BitSystems (system: self.packages.${system}.nix-static);
|
|
|
|
devShell = forAllSystems (system: {
|
|
default = self.devShells.${system}.default;
|
|
clang = self.devShells.${system}.native-clangStdenvPackages;
|
|
});
|
|
|
|
rl-next = forAllSystems (
|
|
system:
|
|
let
|
|
rl-next-check =
|
|
name: dir:
|
|
let
|
|
pkgs = nixpkgsFor.${system}.native;
|
|
in
|
|
pkgs.buildPackages.runCommand "test-${name}-release-notes" { } ''
|
|
LANG=C.UTF-8 ${lib.getExe pkgs.build-release-notes} --change-authors ${./doc/manual/change-authors.yml} ${dir} >$out
|
|
'';
|
|
in
|
|
{
|
|
user = rl-next-check "rl-next" ./doc/manual/rl-next;
|
|
}
|
|
);
|
|
|
|
# Completion tests for the Nix REPL.
|
|
repl-completion = forAllSystems (
|
|
system: nixpkgsFor.${system}.native.callPackage ./tests/repl-completion.nix { }
|
|
);
|
|
|
|
# Perl bindings for various platforms.
|
|
perlBindings = forAllSystems (system: nixpkgsFor.${system}.native.nix.passthru.perl-bindings);
|
|
|
|
# nix-eval-jobs can be built against this Lix.
|
|
nix-eval-jobs = forAllSystems (system: nixpkgsFor.${system}.native.nix-eval-jobs);
|
|
|
|
# Binary tarball for various platforms, containing a Nix store
|
|
# with the closure of 'nix' package.
|
|
binaryTarball = forAllSystems (system: nixpkgsFor.${system}.native.nix.passthru.binaryTarball);
|
|
|
|
# docker image with Lix inside
|
|
dockerImage = lib.genAttrs linux64BitSystems (system: self.packages.${system}.dockerImage);
|
|
|
|
# API docs for Nix's unstable internal C++ interfaces.
|
|
internal-api-docs =
|
|
let
|
|
nixpkgs = nixpkgsFor.x86_64-linux.native;
|
|
inherit (nixpkgs) pkgs;
|
|
|
|
nix = pkgs.callPackage ./package.nix {
|
|
inherit versionSuffix officialRelease buildUnreleasedNotes;
|
|
inherit (pkgs) build-release-notes;
|
|
# Required since we don't support gcc stdenv
|
|
stdenv = pkgs.clangStdenv;
|
|
internalApiDocs = true;
|
|
busybox-sandbox-shell = pkgs.busybox-sandbox-shell;
|
|
};
|
|
in
|
|
nix.overrideAttrs (prev: {
|
|
# This Hydra job is just for the internal API docs.
|
|
# We don't need the build artifacts here.
|
|
dontBuild = true;
|
|
doCheck = false;
|
|
doInstallCheck = false;
|
|
});
|
|
|
|
# System tests.
|
|
tests =
|
|
import ./tests/nixos {
|
|
inherit
|
|
lib
|
|
nixpkgs
|
|
nixpkgsFor
|
|
;
|
|
}
|
|
// {
|
|
# the n-e-j test suite is unusably slow in darwin ci. disbled until anywho fixes this.
|
|
nix-eval-jobs = (lib.genAttrs nonDarwinSystems) (
|
|
system: self.packages.${system}.nix-eval-jobs.tests.nix-eval-jobs
|
|
);
|
|
|
|
# This is x86_64-linux only, just because we have significantly
|
|
# cheaper x86_64-linux compute in CI.
|
|
# It is clangStdenv because clang's sanitizers are nicer.
|
|
asanBuild = self.packages.x86_64-linux.nix-clangStdenv.override {
|
|
# Improve caching of non-code changes by not changing the
|
|
# derivation name every single time, since this will never be seen
|
|
# by users anyway.
|
|
versionSuffix = "";
|
|
sanitize = [
|
|
"address"
|
|
"undefined"
|
|
];
|
|
# it is very hard to make *every* CI build use this option such
|
|
# that we don't wind up building Lix twice, so we do it here where
|
|
# we are already doing so.
|
|
werror = true;
|
|
};
|
|
|
|
# Although this might be nicer to do with pre-commit, that would
|
|
# require adding 12MB of nodejs to the dev shell, whereas building it
|
|
# in CI with Nix avoids that at a cost of slower feedback on rarely
|
|
# touched files.
|
|
jsSyntaxCheck =
|
|
let
|
|
nixpkgs = nixpkgsFor.x86_64-linux.native;
|
|
inherit (nixpkgs) pkgs;
|
|
docSources = lib.fileset.toSource {
|
|
root = ./doc;
|
|
fileset = lib.fileset.fileFilter (f: f.hasExt "js") ./doc;
|
|
};
|
|
in
|
|
pkgs.runCommand "js-syntax-check" { } ''
|
|
find ${docSources} -type f -print -exec ${pkgs.nodejs-slim}/bin/node --check '{}' ';'
|
|
touch $out
|
|
'';
|
|
|
|
# clang-tidy run against the Lix codebase using the Lix clang-tidy plugin
|
|
clang-tidy = forAllSystems (
|
|
system:
|
|
let
|
|
pkgs = nixpkgsFor.${system}.native;
|
|
in
|
|
pkgs.callPackage ./package.nix {
|
|
# Required since we don't support gcc stdenv
|
|
stdenv = pkgs.clangStdenv;
|
|
versionSuffix = "";
|
|
lintInsteadOfBuild = true;
|
|
}
|
|
);
|
|
|
|
# Make sure that nix-env still produces the exact same result
|
|
# on a particular version of Nixpkgs.
|
|
evalNixpkgs = nixpkgsFor.x86_64-linux.native.callPackage ./tests/nixpkgs/eval.nix {
|
|
inherit nixpkgs-regression;
|
|
};
|
|
|
|
nixpkgsLibTests = forAllSystems (
|
|
system:
|
|
nixpkgsFor.${system}.native.callPackage ./tests/nixpkgs/lib.nix {
|
|
inherit nixpkgs system;
|
|
inherit (self.packages.${system}) nix;
|
|
}
|
|
);
|
|
};
|
|
|
|
pre-commit = forAvailableSystems (
|
|
system:
|
|
let
|
|
pkgs = nixpkgsFor.${system}.native;
|
|
pre-commit-check = import ./misc/pre-commit.nix { inherit self pkgs pre-commit-hooks; };
|
|
# dotnet-sdk_6, a nativeBuildInputs of pre-commit, is broken on i686-linux.
|
|
available = lib.meta.availableOn { inherit system; } pkgs.dotnet-sdk_6;
|
|
in
|
|
lib.optionalAttrs available pre-commit-check
|
|
);
|
|
};
|
|
|
|
release-jobs = import ./releng/release-jobs.nix {
|
|
inherit (self) hydraJobs;
|
|
pkgs = nixpkgsFor.x86_64-linux.native;
|
|
};
|
|
|
|
releaseTests = lib.foldl lib.recursiveUpdate { } [
|
|
(lib.genAttrs (linux64BitSystems ++ darwinSystems) (system: {
|
|
nativeBuild = self.packages.${system}.nix;
|
|
}))
|
|
(lib.genAttrs (linux64BitSystems) (system: {
|
|
staticBuild = self.packages.${system}.nix-static;
|
|
}))
|
|
{
|
|
x86_64-linux = {
|
|
# TODO add more cross/static release targets?
|
|
crossBuild.aarch64-linux = self.packages.x86_64-linux.nix-aarch64-linux;
|
|
|
|
# TODO wire up a nixos installer test with that lix and
|
|
# run it, once nixpkgs can actually do that (again). :/
|
|
# # nix build .#nixosTests.installer.{btrfsSimple,luksroot,lvm,simple,switchToFlake}
|
|
};
|
|
}
|
|
];
|
|
|
|
# NOTE *do not* add fresh derivations to checks, always add them to
|
|
# hydraJobs first (so CI will pick them up) and only link them here
|
|
checks = forAvailableSystems (
|
|
system:
|
|
{
|
|
# devShells and packages already get checked by nix flake check, so
|
|
# this is just jobs that are special
|
|
|
|
binaryTarball = self.hydraJobs.binaryTarball.${system};
|
|
perlBindings = self.hydraJobs.perlBindings.${system};
|
|
nix-eval-jobs = self.hydraJobs.nix-eval-jobs.${system};
|
|
nixpkgsLibTests = self.hydraJobs.tests.nixpkgsLibTests.${system};
|
|
rl-next = self.hydraJobs.rl-next.${system}.user;
|
|
# Will be empty attr set on i686-linux, and filtered out by forAvailableSystems.
|
|
pre-commit = self.hydraJobs.pre-commit.${system};
|
|
repl-completion = self.hydraJobs.repl-completion.${system};
|
|
}
|
|
// (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
|
|
dockerImage = self.hydraJobs.dockerImage.${system};
|
|
}
|
|
);
|
|
|
|
packages = forAllSystems (
|
|
system:
|
|
rec {
|
|
inherit (nixpkgsFor.${system}.native) nix;
|
|
default = nix;
|
|
|
|
inherit (nixpkgsFor.${system}.native) lix-clang-tidy nix-eval-jobs;
|
|
}
|
|
// (
|
|
lib.optionalAttrs (builtins.elem system linux64BitSystems) {
|
|
# python doesn't work in static builds as of 2025-06-27
|
|
nix-static = nixpkgsFor.${system}.static.nix.overrideAttrs (_: {
|
|
doCheck = false;
|
|
});
|
|
dockerImage =
|
|
let
|
|
pkgs = nixpkgsFor.${system}.native;
|
|
nix2container' = import nix2container { inherit pkgs; };
|
|
in
|
|
import ./docker.nix {
|
|
inherit pkgs;
|
|
nix2container = nix2container'.nix2container;
|
|
tag = pkgs.nix.version;
|
|
};
|
|
}
|
|
// builtins.listToAttrs (
|
|
map (crossSystem: {
|
|
name = "nix-${crossSystem}";
|
|
value = nixpkgsFor.${system}.cross.${crossSystem}.nix;
|
|
}) crossSystems
|
|
)
|
|
// builtins.listToAttrs (
|
|
map (stdenvName: {
|
|
name = "nix-${stdenvName}";
|
|
value = nixpkgsFor.${system}.stdenvs."${stdenvName}Packages".nix;
|
|
}) stdenvs
|
|
)
|
|
)
|
|
);
|
|
|
|
devShells =
|
|
let
|
|
makeShell =
|
|
pkgs: stdenv:
|
|
let
|
|
nix = pkgs.callPackage ./package.nix {
|
|
inherit stdenv versionSuffix;
|
|
busybox-sandbox-shell = pkgs.busybox-sandbox-shell or pkgs.default-busybox-sandbox;
|
|
internalApiDocs = false;
|
|
includeSanitizerLibs = true;
|
|
# Use LLD in the dev shell by default for faster link times.
|
|
useLld = stdenv.hostPlatform.isLinux;
|
|
};
|
|
pre-commit = self.hydraJobs.pre-commit.${pkgs.stdenv.hostPlatform.system} or { };
|
|
in
|
|
pkgs.callPackage nix.mkDevShell {
|
|
pre-commit-checks = pre-commit;
|
|
inherit contribNotice;
|
|
};
|
|
in
|
|
forAllSystems (
|
|
system:
|
|
let
|
|
makeShells =
|
|
prefix: pkgs:
|
|
lib.mapAttrs' (k: v: lib.nameValuePair "${prefix}-${k}" v) (
|
|
forAllStdenvs (stdenvName: makeShell pkgs pkgs.${stdenvName})
|
|
);
|
|
in
|
|
(makeShells "native" nixpkgsFor.${system}.native)
|
|
// (makeShells "static" nixpkgsFor.${system}.static)
|
|
// (lib.listToAttrs (
|
|
# Provide e.g., both '.#native-aarch64-linux` and `.#static-aarch64-linux`,
|
|
# for each cross-system.
|
|
# "native" feels like a misnomer here since it's literally cross compiling,
|
|
# but at least it's consistent with the native/static dichotomy we've set up.
|
|
lib.concatMap (
|
|
crossSystem:
|
|
let
|
|
pkgs = nixpkgsFor.${system}.cross.${crossSystem};
|
|
inherit (pkgs) pkgsStatic;
|
|
native = makeShell pkgs pkgs.clangStdenv;
|
|
static = makeShell pkgsStatic pkgsStatic.clangStdenv;
|
|
in
|
|
[
|
|
{
|
|
name = "native-${crossSystem}";
|
|
value = native;
|
|
}
|
|
{
|
|
name = "static-${crossSystem}";
|
|
value = static;
|
|
}
|
|
]
|
|
) crossSystems
|
|
))
|
|
// {
|
|
default = self.devShells.${system}.native-clangStdenvPackages;
|
|
}
|
|
);
|
|
};
|
|
}
|