devos/lib/default.nix

228 lines
6.2 KiB
Nix
Raw Normal View History

2021-02-02 02:57:19 +01:00
{ nixos, ... }:
let
inherit (builtins) attrNames attrValues isAttrs readDir listToAttrs mapAttrs
2021-02-04 00:41:21 +01:00
pathExists filter;
2021-02-02 02:57:19 +01:00
inherit (nixos.lib) fold filterAttrs hasSuffix mapAttrs' nameValuePair removeSuffix
recursiveUpdate genAttrs nixosSystem mkForce;
# mapFilterAttrs ::
# (name -> value -> bool )
# (name -> value -> { name = any; value = any; })
# attrs
2020-01-04 06:06:31 +01:00
mapFilterAttrs = seive: f: attrs: filterAttrs seive (mapAttrs' f attrs);
# Generate an attribute set by mapping a function over a list of values.
genAttrs' = values: f: listToAttrs (map f values);
# pkgImport :: Nixpkgs -> Overlays -> System -> Pkgs
pkgImport = nixpkgs: overlays: system:
import nixpkgs {
inherit system overlays;
config = { allowUnfree = true; };
};
# Convert a list to file paths to attribute set
# that has the filenames stripped of nix extension as keys
# and imported content of the file as value.
#
pathsToImportedAttrs = paths:
2021-02-04 03:35:10 +01:00
let
paths' = filter (hasSuffix ".nix") paths;
in
genAttrs' paths' (path: {
name = removeSuffix ".nix" (baseNameOf path);
value = import path;
});
overlayPaths =
let
overlayDir = ../overlays;
fullPath = name: overlayDir + "/${name}";
in
map fullPath (attrNames (readDir overlayDir));
2021-02-15 19:24:43 +01:00
/**
Synopsis: mkNodes _nixosConfigurations_
Generate the `nodes` attribute expected by deploy-rs
where _nixosConfigurations_ are `nodes`.
**/
mkNodes = deploy: mapAttrs (_: config: {
hostname = config.config.networking.hostName;
profiles.system = {
user = "root";
path = deploy.lib.x86_64-linux.activate.nixos config;
};
});
2021-02-06 21:30:17 +01:00
/**
Synopsis: importDefaults _path_
Recursively import the subdirs of _path_ containing a default.nix.
Example:
let profiles = importDefaults ./profiles; in
assert profiles ? core.default; 0
**/
importDefaults = dir:
let
2021-02-06 21:30:17 +01:00
imports =
let
files = readDir dir;
p = n: v:
v == "directory"
&& pathExists "${dir}/${n}/default.nix";
in
filterAttrs p files;
f = n: _:
{ default = import "${dir}/${n}/default.nix"; }
// importDefaults "${dir}/${n}";
in
2021-02-06 21:30:17 +01:00
mapAttrs f imports;
in
{
2021-02-06 21:30:17 +01:00
inherit importDefaults mapFilterAttrs genAttrs' pkgImport
2021-02-15 19:24:43 +01:00
pathsToImportedAttrs mkNodes;
overlays = pathsToImportedAttrs overlayPaths;
genPkgs = { self }:
let inherit (self) inputs;
in
2021-02-15 06:11:49 +01:00
(inputs.utils.lib.eachDefaultSystem
(system:
let
extern = import ../extern { inherit inputs; };
2021-02-14 03:38:20 +01:00
overridePkgs = pkgImport inputs.override [ ] system;
overridesOverlay = (import ../overrides).packages;
overlays = [
2021-02-14 03:38:20 +01:00
(overridesOverlay overridePkgs)
self.overlay
(final: prev: {
lib = (prev.lib or { }) // {
inherit (nixos.lib) nixosSystem;
flk = self.lib;
2021-02-15 06:11:49 +01:00
utils = inputs.utils.lib;
};
})
]
++ (attrValues self.overlays)
++ extern.overlays;
in
{ pkgs = pkgImport nixos overlays system; }
)
).pkgs;
profileMap = map (profile: profile.default);
2020-01-04 06:06:31 +01:00
recImport = { dir, _import ? base: import "${dir}/${base}.nix" }:
2020-07-31 06:17:28 +02:00
mapFilterAttrs
(_: v: v != null)
(n: v:
if n != "default.nix" && hasSuffix ".nix" n && v == "regular"
then
let name = removeSuffix ".nix" n; in nameValuePair (name) (_import name)
else
nameValuePair ("") (null))
(readDir dir);
2021-01-28 03:11:38 +01:00
nixosSystemExtended = { modules, ... } @ args:
2021-02-02 02:57:19 +01:00
nixosSystem (args // {
modules =
let
modpath = "nixos/modules";
cd = "installer/cd-dvd/installation-cd-minimal-new-kernel.nix";
2021-02-04 00:41:21 +01:00
ciConfig =
(nixosSystem (args // {
modules =
let
# remove host module
modules' = filter (x: ! x ? require) modules;
in
modules' ++ [
({ suites, ... }: {
imports = with suites;
allProfiles ++ allUsers;
boot.loader.systemd-boot.enable = true;
boot.loader.efi.canTouchEfiVariables = true;
fileSystems."/" = { device = "/dev/disk/by-label/nixos"; };
})
];
})).config;
2021-02-02 02:57:19 +01:00
isoConfig = (nixosSystem
(args // {
modules = modules ++ [
"${nixos}/${modpath}/${cd}"
({ config, ... }: {
isoImage.isoBaseName = "nixos-" + config.networking.hostName;
# confilcts with networking.wireless which might be slightly
# more useful on a stick
networking.networkmanager.enable = mkForce false;
# confilcts with networking.wireless
networking.wireless.iwd.enable = mkForce false;
})
];
})).config;
in
modules ++ [{
system.build = {
iso = isoConfig.system.build.isoImage;
2021-02-04 00:41:21 +01:00
ci = ciConfig.system.build.toplevel;
2021-02-02 02:57:19 +01:00
};
}];
});
2021-01-28 03:11:38 +01:00
nixosModules =
let
# binary cache
cachix = import ../cachix.nix;
cachixAttrs = { inherit cachix; };
# modules
2021-02-14 03:38:20 +01:00
moduleList = import ../modules/module-list.nix;
modulesAttrs = pathsToImportedAttrs moduleList;
in
recursiveUpdate cachixAttrs modulesAttrs;
genHomeActivationPackages = { self }:
let hmConfigs =
builtins.mapAttrs
(_: config: config.config.home-manager.users)
self.nixosConfigurations;
in
mapAttrs
(_: x: mapAttrs
(_: cfg: cfg.home.activationPackage)
x)
hmConfigs;
genPackages = { self, pkgs }:
let
inherit (self) overlay overlays;
packagesNames = attrNames (overlay null null)
++ attrNames (fold
(attr: sum: recursiveUpdate sum attr)
{ }
(attrValues
(mapAttrs (_: v: v null null) overlays)
)
);
in
fold
(key: sum: recursiveUpdate sum {
${key} = pkgs.${key};
})
{ }
packagesNames;
}