mirror of
https://github.com/nix-community/disko.git
synced 2024-09-17 09:37:17 +03:00
1546 lines
52 KiB
Nix
1546 lines
52 KiB
Nix
{ lib }:
|
||
with lib;
|
||
with builtins;
|
||
|
||
rec {
|
||
|
||
diskoLib = {
|
||
# like types.oneOf but instead of a list takes an attrset
|
||
# uses the field "type" to find the correct type in the attrset
|
||
subType = typeAttr: mkOptionType rec {
|
||
name = "subType";
|
||
description = "one of ${concatStringsSep "," (attrNames typeAttr)}";
|
||
check = x: if x ? type then typeAttr.${x.type}.check x else throw "No type option set in:\n${generators.toPretty {} x}";
|
||
merge = loc: defs:
|
||
foldl' (res: def: typeAttr.${def.value.type}.merge loc [def]) {} defs;
|
||
nestedTypes = typeAttr;
|
||
};
|
||
|
||
# option for valid contents of partitions (basically like devices, but without tables)
|
||
partitionType = mkOption {
|
||
type = types.nullOr (diskoLib.subType { inherit btrfs filesystem zfs mdraid luks lvm_pv swap; });
|
||
default = null;
|
||
description = "The type of partition";
|
||
};
|
||
|
||
# option for valid contents of devices
|
||
deviceType = mkOption {
|
||
type = types.nullOr (diskoLib.subType { inherit table btrfs filesystem zfs mdraid luks lvm_pv swap; });
|
||
default = null;
|
||
description = "The type of device";
|
||
};
|
||
|
||
/* deepMergeMap takes a function and a list of attrsets and deep merges them
|
||
|
||
deepMergeMap :: -> (AttrSet -> AttrSet ) -> [ AttrSet ] -> Attrset
|
||
|
||
Example:
|
||
deepMergeMap (x: x.t = "test") [ { x = { y = 1; z = 3; }; } { x = { bla = 234; }; } ]
|
||
=> { x = { y = 1; z = 3; bla = 234; t = "test"; }; }
|
||
*/
|
||
deepMergeMap = f: listOfAttrs:
|
||
foldr (attr: acc: (recursiveUpdate acc (f attr))) {} listOfAttrs;
|
||
|
||
/* get a device and an index to get the matching device name
|
||
|
||
deviceNumbering :: str -> int -> str
|
||
|
||
Example:
|
||
deviceNumbering "/dev/sda" 3
|
||
=> "/dev/sda3"
|
||
|
||
deviceNumbering "/dev/disk/by-id/xxx" 2
|
||
=> "/dev/disk/by-id/xxx-part2"
|
||
*/
|
||
deviceNumbering = dev: index:
|
||
if match "/dev/[vs]d.+" dev != null then
|
||
dev + toString index # /dev/{s,v}da style
|
||
else if match "/dev/disk/.+" dev != null then
|
||
"${dev}-part${toString index}" # /dev/disk/by-id/xxx style
|
||
else if match "/dev/(nvme|md/|mmcblk).+" dev != null then
|
||
"${dev}p${toString index}" # /dev/nvme0n1p1 style
|
||
else
|
||
abort "${dev} seems not to be a supported disk format";
|
||
|
||
/* A nix option type representing a json datastructure, vendored from nixpkgs to avoid dependency on pkgs */
|
||
jsonType = let
|
||
valueType = types.nullOr (types.oneOf [
|
||
types.bool
|
||
types.int
|
||
types.float
|
||
types.str
|
||
types.path
|
||
(types.attrsOf valueType)
|
||
(types.listOf valueType)
|
||
]) // {
|
||
description = "JSON value";
|
||
};
|
||
in valueType;
|
||
|
||
/* Given a attrset of deviceDependencies and a devices attrset
|
||
returns a sorted list by deviceDependencies. aborts if a loop is found
|
||
|
||
sortDevicesByDependencies :: AttrSet -> AttrSet -> [ [ str str ] ]
|
||
*/
|
||
sortDevicesByDependencies = deviceDependencies: devices:
|
||
let
|
||
dependsOn = a: b:
|
||
elem a (attrByPath b [] deviceDependencies);
|
||
maybeSortedDevices = toposort dependsOn (diskoLib.deviceList devices);
|
||
in
|
||
if (hasAttr "cycle" maybeSortedDevices) then
|
||
abort "detected a cycle in your disk setup: ${maybeSortedDevices.cycle}"
|
||
else
|
||
maybeSortedDevices.result;
|
||
|
||
/* Takes a devices attrSet and returns it as a list
|
||
|
||
deviceList :: AttrSet -> [ [ str str ] ]
|
||
|
||
Example:
|
||
deviceList { zfs.pool1 = {}; zfs.pool2 = {}; mdadm.raid1 = {}; }
|
||
=> [ [ "zfs" "pool1" ] [ "zfs" "pool2" ] [ "mdadm" "raid1" ] ]
|
||
*/
|
||
deviceList = devices:
|
||
concatLists (mapAttrsToList (n: v: (map (x: [ n x ]) (attrNames v))) devices);
|
||
|
||
/* Takes either a string or null and returns the string or an empty string
|
||
|
||
maybeStr :: Either (str null) -> str
|
||
|
||
Example:
|
||
maybeStr null
|
||
=> ""
|
||
maybeSTr "hello world"
|
||
=> "hello world"
|
||
*/
|
||
maybeStr = x: optionalString (!isNull x) x;
|
||
|
||
/* Takes a Submodules config and options argument and returns a serializable
|
||
subset of config variables as a shell script snippet.
|
||
*/
|
||
defineHookVariables = {config, options}:
|
||
let
|
||
sanitizeName = lib.replaceStrings ["-"] ["_"];
|
||
isAttrsOfSubmodule = o: o.type.name == "attrsOf" && o.type.nestedTypes.elemType.name == "submodule";
|
||
isSerializable = n: o: !(
|
||
lib.hasPrefix "_" n
|
||
|| lib.hasSuffix "Hook" n
|
||
|| isAttrsOfSubmodule o
|
||
# TODO don't hardcode diskoLib.subType options.
|
||
|| n == "content" || n == "partitions");
|
||
in
|
||
lib.toShellVars
|
||
(lib.mapAttrs'
|
||
(n: o: lib.nameValuePair (sanitizeName n) o.value)
|
||
(lib.filterAttrs isSerializable options));
|
||
|
||
hookMixin = { config, options,... }: {
|
||
options = let
|
||
mkHook = default: mkOption {
|
||
type = types.str;
|
||
default = default;
|
||
};
|
||
in {
|
||
preCreateHook = mkHook "echo 'DEBUG preCreate: ${config.type}'";
|
||
postCreateHook = mkHook "echo 'DEBUG postCreate: ${config.type}'";
|
||
preMountHook = mkHook "echo 'DEBUG preMount: ${config.type}'";
|
||
postMountHook = mkHook "echo 'DEBUG postMount: ${config.type}'";
|
||
};
|
||
};
|
||
|
||
mkCreateOption = { config, options, default }@attrs:
|
||
mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo types.str;
|
||
default = args:
|
||
let name = "format";
|
||
test = lib.optionalString (config ? name) "${config.${name}}";
|
||
in
|
||
''
|
||
function { # ${config.type} ${concatMapStringsSep " " (n: toString (config.${n} or "")) ["name" "device" "format" "mountpoint"]}
|
||
${diskoLib.defineHookVariables { inherit config options; }}
|
||
${config.preCreateHook}
|
||
${attrs.default args}
|
||
${config.postCreateHook}
|
||
}
|
||
'';
|
||
description = "Creation script";
|
||
};
|
||
|
||
mkMountOption = { config, options, default }@attrs:
|
||
mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = args: let v = attrs.default args; in lib.traceSeqN 3 [(config.name or "unnamed") (v.fs or "")] v;
|
||
description = "Mount script";
|
||
};
|
||
|
||
|
||
/* Takes a disko device specification, returns an attrset with metadata
|
||
|
||
meta :: types.devices -> AttrSet
|
||
*/
|
||
meta = devices: diskoLib.deepMergeMap (dev: dev._meta) (flatten (map attrValues (attrValues devices)));
|
||
|
||
/* Takes a disko device specification and returns a string which formats the disks
|
||
|
||
create :: types.devices -> str
|
||
*/
|
||
create = devices: let
|
||
sortedDeviceList = diskoLib.sortDevicesByDependencies ((diskoLib.meta devices).deviceDependencies or {}) devices;
|
||
in ''
|
||
set -efux
|
||
${concatMapStrings (dev: (attrByPath (dev ++ [ "_create" ]) ({}: {}) devices) {}) sortedDeviceList}
|
||
'';
|
||
/* Takes a disko device specification and returns a string which mounts the disks
|
||
|
||
mount :: types.devices -> str
|
||
*/
|
||
mount = devices: let
|
||
fsMounts = diskoLib.deepMergeMap (dev: (dev._mount {}).fs or {}) (flatten (map attrValues (attrValues devices)));
|
||
sortedDeviceList = diskoLib.sortDevicesByDependencies ((diskoLib.meta devices).deviceDependencies or {}) devices;
|
||
in ''
|
||
set -efux
|
||
# first create the necessary devices
|
||
${concatMapStrings (dev: ((attrByPath (dev ++ [ "_mount" ]) "" devices) {}).dev ) sortedDeviceList}
|
||
|
||
# and then mount the filesystems in alphabetical order
|
||
${concatStrings (attrValues fsMounts)}
|
||
'';
|
||
|
||
/* takes a disko device specification and returns a string which unmounts, destroys all disks and then runs create and mount
|
||
|
||
zapCreateMount :: types.devices -> str
|
||
*/
|
||
zapCreateMount = devices: ''
|
||
set -efux
|
||
umount -Rv /mnt || :
|
||
|
||
for dev in ${toString (lib.catAttrs "device" (lib.attrValues devices.disk))}; do
|
||
${./disk-deactivate}/disk-deactivate "$dev" | bash -x
|
||
done
|
||
|
||
echo 'creating partitions...'
|
||
${diskoLib.create devices}
|
||
echo 'mounting partitions...'
|
||
${diskoLib.mount devices}
|
||
'';
|
||
/* Takes a disko device specification and returns a nixos configuration
|
||
|
||
config :: types.devices -> nixosConfig
|
||
*/
|
||
config = devices: flatten (map (dev: dev._config) (flatten (map attrValues (attrValues devices))));
|
||
/* Takes a disko device specification and returns a function to get the needed packages to format/mount the disks
|
||
|
||
packages :: types.devices -> pkgs -> [ derivation ]
|
||
*/
|
||
packages = devices: pkgs: unique (flatten (map (dev: dev._pkgs pkgs) (flatten (map attrValues (attrValues devices)))));
|
||
};
|
||
|
||
optionTypes = rec {
|
||
# POSIX.1‐2017, 3.281 Portable Filename
|
||
filename = mkOptionType {
|
||
name = "POSIX portable filename";
|
||
check = x: isString x && builtins.match "[0-9A-Za-z._][0-9A-Za-z._-]*" x != null;
|
||
merge = mergeOneOption;
|
||
description = "A filename";
|
||
};
|
||
|
||
# POSIX.1‐2017, 3.2 Absolute Pathname
|
||
absolute-pathname = mkOptionType {
|
||
name = "POSIX absolute pathname";
|
||
check = x: isString x && substring 0 1 x == "/" && pathname.check x;
|
||
merge = mergeOneOption;
|
||
description = "An absolute path";
|
||
};
|
||
|
||
# POSIX.1-2017, 3.271 Pathname
|
||
pathname = mkOptionType {
|
||
name = "POSIX pathname";
|
||
check = x:
|
||
let
|
||
# The filter is used to normalize paths, i.e. to remove duplicated and
|
||
# trailing slashes. It also removes leading slashes, thus we have to
|
||
# check for "/" explicitly below.
|
||
xs = filter (s: stringLength s > 0) (splitString "/" x);
|
||
in
|
||
isString x && (x == "/" || (length xs > 0 && all filename.check xs));
|
||
merge = mergeOneOption;
|
||
description = "A path name";
|
||
};
|
||
};
|
||
|
||
/* topLevel type of the disko config, takes attrsets of disks, mdadms, zpools, nodevs, and lvm vgs.
|
||
*/
|
||
devices = types.submodule {
|
||
options = {
|
||
disk = mkOption {
|
||
type = types.attrsOf disk;
|
||
default = {};
|
||
description = "Block device";
|
||
};
|
||
mdadm = mkOption {
|
||
type = types.attrsOf mdadm;
|
||
default = {};
|
||
description = "mdadm device";
|
||
};
|
||
zpool = mkOption {
|
||
type = types.attrsOf zpool;
|
||
default = {};
|
||
description = "ZFS pool device";
|
||
};
|
||
lvm_vg = mkOption {
|
||
type = types.attrsOf lvm_vg;
|
||
default = {};
|
||
description = "LVM VG device";
|
||
};
|
||
nodev = mkOption {
|
||
type = types.attrsOf nodev;
|
||
default = {};
|
||
description = "A non-block device";
|
||
};
|
||
};
|
||
};
|
||
|
||
nodev = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "nodev" ];
|
||
default = "nodev";
|
||
internal = true;
|
||
description = "Device type";
|
||
};
|
||
fsType = mkOption {
|
||
type = types.str;
|
||
description = "File system type";
|
||
};
|
||
device = mkOption {
|
||
type = types.str;
|
||
default = "none";
|
||
description = "Device to use";
|
||
};
|
||
mountpoint = mkOption {
|
||
type = optionTypes.absolute-pathname;
|
||
default = config._module.args.name;
|
||
description = "Location to mount the file system at";
|
||
};
|
||
mountOptions = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [ "defaults" ];
|
||
description = "Options to pass to mount";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = diskoLib.jsonType;
|
||
default = {
|
||
};
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {}: "";
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {}: {
|
||
fs.${config.mountpoint} = ''
|
||
if ! findmnt ${config.fsType} "/mnt${config.mountpoint}" > /dev/null 2>&1; then
|
||
mount -t ${config.fsType} ${config.device} "/mnt${config.mountpoint}" \
|
||
${concatMapStringsSep " " (opt: "-o ${opt}") config.mountOptions} \
|
||
-o X-mount.mkdir
|
||
fi
|
||
'';
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = [{
|
||
fileSystems.${config.mountpoint} = {
|
||
device = config.device;
|
||
fsType = config.fsType;
|
||
options = config.mountOptions;
|
||
};
|
||
}];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [];
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
btrfs = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "btrfs" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
extraArgs = mkOption {
|
||
type = types.str;
|
||
default = "";
|
||
description = "Arguments to pass to BTRFS";
|
||
};
|
||
mountOptions = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [ "defaults" ];
|
||
description = "A list of options to pass to mount.";
|
||
};
|
||
subvolumes = mkOption {
|
||
type = types.attrsOf btrfs_subvol;
|
||
default = {};
|
||
description = "Subvolumes to define for BTRFS.";
|
||
};
|
||
mountpoint = mkOption {
|
||
type = types.nullOr optionTypes.absolute-pathname;
|
||
default = null;
|
||
description = "A path to mount the BTRFS filesystem to.";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev:
|
||
diskoLib.deepMergeMap (subvol: subvol._meta dev) (attrValues config.subvolumes);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
mkfs.btrfs ${dev} ${config.extraArgs}
|
||
${concatMapStrings (subvol: subvol._create { inherit dev; }) (attrValues config.subvolumes)}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}:
|
||
let
|
||
subvolMounts = diskoLib.deepMergeMap (subvol: subvol._mount {inherit dev; parent = config.mountpoint;}) (attrValues config.subvolumes);
|
||
in {
|
||
fs = subvolMounts.fs // optionalAttrs (!isNull config.mountpoint) {
|
||
${config.mountpoint} = ''
|
||
if ! findmnt ${dev} "/mnt${config.mountpoint}" > /dev/null 2>&1; then
|
||
mount ${dev} "/mnt${config.mountpoint}" \
|
||
${concatMapStringsSep " " (opt: "-o ${opt}") config.mountOptions} \
|
||
-o X-mount.mkdir
|
||
fi
|
||
'';
|
||
};
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev: [
|
||
(map (subvol: subvol._config dev config.mountpoint) (attrValues config.subvolumes))
|
||
(optional (!isNull config.mountpoint) {
|
||
fileSystems.${config.mountpoint} = {
|
||
device = dev;
|
||
fsType = "btrfs";
|
||
options = config.mountOptions;
|
||
};
|
||
})
|
||
];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs:
|
||
[ pkgs.btrfs-progs ] ++ flatten (map (subvolume: subvolume._pkgs pkgs) (attrValues config.subvolumes));
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
btrfs_subvol = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
name = mkOption {
|
||
type = types.str;
|
||
default = config._module.args.name;
|
||
description = "Name of the BTRFS subvolume.";
|
||
};
|
||
type = mkOption {
|
||
type = types.enum [ "btrfs_subvol" ];
|
||
default = "btrfs_subvol";
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
extraArgs = mkOption {
|
||
type = types.str;
|
||
default = "";
|
||
description = "Extra arguments to pass";
|
||
};
|
||
mountOptions = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [ "defaults" ];
|
||
description = "Options to pass to mount";
|
||
};
|
||
mountpoint = mkOption {
|
||
type = types.nullOr optionTypes.absolute-pathname;
|
||
default = null;
|
||
description = "Location to mount the subvolume to.";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev: {
|
||
};
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
MNTPOINT=$(mktemp -d)
|
||
(
|
||
mount ${dev} "$MNTPOINT" -o subvol=/
|
||
trap 'umount $MNTPOINT; rm -rf $MNTPOINT' EXIT
|
||
btrfs subvolume create "$MNTPOINT"/${config.name} ${config.extraArgs}
|
||
)
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev, parent}: let
|
||
mountpoint = if (!isNull config.mountpoint) then config.mountpoint
|
||
else if (isNull parent) then config.name
|
||
else null;
|
||
in optionalAttrs (!isNull mountpoint) {
|
||
fs.${mountpoint} = ''
|
||
if ! findmnt ${dev} "/mnt${mountpoint}" > /dev/null 2>&1; then
|
||
mount ${dev} "/mnt${mountpoint}" \
|
||
${concatMapStringsSep " " (opt: "-o ${opt}") (config.mountOptions ++ [ "subvol=${config.name}" ])} \
|
||
-o X-mount.mkdir
|
||
fi
|
||
'';
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev: parent: let
|
||
mountpoint = if (!isNull config.mountpoint) then config.mountpoint
|
||
else if (isNull parent) then config.name
|
||
else null;
|
||
in optional (!isNull mountpoint) {
|
||
fileSystems.${mountpoint} = {
|
||
device = dev;
|
||
fsType = "btrfs";
|
||
options = config.mountOptions ++ [ "subvol=${config.name}" ];
|
||
};
|
||
};
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.coreutils ];
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
filesystem = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "filesystem" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
extraArgs = mkOption {
|
||
type = types.str;
|
||
default = "";
|
||
description = "Arguments to pass";
|
||
};
|
||
mountOptions = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [ "defaults" ];
|
||
description = "Options to pass to mount";
|
||
};
|
||
mountpoint = mkOption {
|
||
type = optionTypes.absolute-pathname;
|
||
description = "Path to mount the filesystem to";
|
||
};
|
||
format = mkOption {
|
||
type = types.str;
|
||
description = "Format of the filesystem";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev: {
|
||
};
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
mkfs.${config.format} \
|
||
${config.extraArgs} \
|
||
${dev}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}: {
|
||
fs.${config.mountpoint} = ''
|
||
if ! findmnt ${dev} "/mnt${config.mountpoint}" > /dev/null 2>&1; then
|
||
mount ${dev} "/mnt${config.mountpoint}" \
|
||
-t "${config.format}" \
|
||
${concatMapStringsSep " " (opt: "-o ${opt}") config.mountOptions} \
|
||
-o X-mount.mkdir
|
||
fi
|
||
'';
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev: [{
|
||
fileSystems.${config.mountpoint} = {
|
||
device = dev;
|
||
fsType = config.format;
|
||
options = config.mountOptions;
|
||
};
|
||
}];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
# type = types.functionTo (types.listOf types.package);
|
||
default = pkgs:
|
||
[ pkgs.util-linux ] ++ (
|
||
# TODO add many more
|
||
if (config.format == "xfs") then [ pkgs.xfsprogs ]
|
||
else if (config.format == "btrfs") then [ pkgs.btrfs-progs ]
|
||
else if (config.format == "vfat") then [ pkgs.dosfstools ]
|
||
else if (config.format == "ext2") then [ pkgs.e2fsprogs ]
|
||
else if (config.format == "ext3") then [ pkgs.e2fsprogs ]
|
||
else if (config.format == "ext4") then [ pkgs.e2fsprogs ]
|
||
else if (config.format == "bcachefs") then [ pkgs.bcachefs-tools ]
|
||
else []
|
||
);
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
table = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "table" ];
|
||
internal = true;
|
||
description = "Partition table";
|
||
};
|
||
format = mkOption {
|
||
type = types.enum [ "gpt" "msdos" ];
|
||
default = "gpt";
|
||
description = "The kind of partition table";
|
||
};
|
||
partitions = mkOption {
|
||
type = types.listOf partition;
|
||
default = [];
|
||
description = "List of partitions to add to the partition table";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev:
|
||
diskoLib.deepMergeMap (partition: partition._meta dev) config.partitions;
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
parted -s ${dev} -- mklabel ${config.format}
|
||
${concatMapStrings (partition: partition._create {inherit dev; type = config.format;} ) config.partitions}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}:
|
||
let
|
||
partMounts = diskoLib.deepMergeMap (partition: partition._mount {inherit dev;}) config.partitions;
|
||
in {
|
||
dev = ''
|
||
${concatMapStrings (x: x.dev or "") (attrValues partMounts)}
|
||
'';
|
||
fs = partMounts.fs or {};
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev:
|
||
map (partition: partition._config dev) config.partitions;
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs:
|
||
[ pkgs.parted pkgs.systemdMinimal ] ++ flatten (map (partition: partition._pkgs pkgs) config.partitions);
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
partition = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "partition" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
part-type = mkOption {
|
||
type = types.enum [ "primary" "logical" "extended" ];
|
||
default = "primary";
|
||
description = "Partition type";
|
||
};
|
||
fs-type = mkOption {
|
||
type = types.nullOr (types.enum [ "btrfs" "ext2" "ext3" "ext4" "fat16" "fat32" "hfs" "hfs+" "linux-swap" "ntfs" "reiserfs" "udf" "xfs" ]);
|
||
default = null;
|
||
description = "Filesystem type to use";
|
||
};
|
||
name = mkOption {
|
||
type = types.nullOr types.str;
|
||
description = "Name of the partition";
|
||
};
|
||
start = mkOption {
|
||
type = types.str;
|
||
default = "0%";
|
||
description = "Start of the partition";
|
||
};
|
||
end = mkOption {
|
||
type = types.str;
|
||
default = "100%";
|
||
description = "End of the partition";
|
||
};
|
||
index = mkOption {
|
||
type = types.int;
|
||
# TODO find a better way to get the index
|
||
default = toInt (head (match ".*entry ([[:digit:]]+)]" config._module.args.name));
|
||
description = "Index of the partition";
|
||
};
|
||
flags = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [];
|
||
description = "Partition flags";
|
||
};
|
||
bootable = mkOption {
|
||
type = types.bool;
|
||
default = false;
|
||
description = "Whether to make the partition bootable";
|
||
};
|
||
content = diskoLib.partitionType;
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev:
|
||
optionalAttrs (!isNull config.content) (config.content._meta dev);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev, type}: ''
|
||
${optionalString (type == "gpt") ''
|
||
parted -s ${dev} -- mkpart ${config.name} ${diskoLib.maybeStr config.fs-type} ${config.start} ${config.end}
|
||
''}
|
||
${optionalString (type == "msdos") ''
|
||
parted -s ${dev} -- mkpart ${config.part-type} ${diskoLib.maybeStr config.fs-type} ${diskoLib.maybeStr config.fs-type} ${config.start} ${config.end}
|
||
''}
|
||
# ensure /dev/disk/by-path/..-partN exists before continuing
|
||
udevadm trigger --subsystem-match=block; udevadm settle
|
||
${optionalString (config.bootable) ''
|
||
parted -s ${dev} -- set ${toString config.index} boot on
|
||
''}
|
||
${concatMapStringsSep "" (flag: ''
|
||
parted -s ${dev} -- set ${toString config.index} ${flag} on
|
||
'') config.flags}
|
||
# ensure further operations can detect new partitions
|
||
udevadm trigger --subsystem-match=block; udevadm settle
|
||
${optionalString (!isNull config.content) (config.content._create {dev = (diskoLib.deviceNumbering dev config.index);})}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}:
|
||
optionalAttrs (!isNull config.content) (config.content._mount {dev = (diskoLib.deviceNumbering dev config.index);});
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev:
|
||
optional (!isNull config.content) (config.content._config (diskoLib.deviceNumbering dev config.index));
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: optionals (!isNull config.content) (config.content._pkgs pkgs);
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
swap = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "swap" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
randomEncryption = mkOption {
|
||
type = types.bool;
|
||
default = false;
|
||
description = "Whether to randomly encrypt the swap";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev: {
|
||
};
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
mkswap ${dev}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}: {
|
||
fs.${dev} = ''
|
||
if ! swapon --show | grep -q '^${dev} '; then
|
||
swapon ${dev}
|
||
fi
|
||
'';
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev: [{
|
||
swapDevices = [{
|
||
device = dev;
|
||
randomEncryption = config.randomEncryption;
|
||
}];
|
||
}];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.gnugrep pkgs.util-linux ];
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
lvm_pv = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "lvm_pv" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
vg = mkOption {
|
||
type = types.str;
|
||
description = "Volume group";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev: {
|
||
deviceDependencies.lvm_vg.${config.vg} = [ dev ];
|
||
};
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
pvcreate ${dev}
|
||
LVMDEVICES_${config.vg}="''${LVMDEVICES_${config.vg}:-}${dev} "
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}:
|
||
{};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev: [];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.lvm2 ];
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
lvm_vg = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
name = mkOption {
|
||
type = types.str;
|
||
default = config._module.args.name;
|
||
description = "Name of the volume gorup";
|
||
};
|
||
type = mkOption {
|
||
type = types.enum [ "lvm_vg" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
lvs = mkOption {
|
||
type = types.attrsOf lvm_lv;
|
||
default = {};
|
||
description = "LVS for the volume group";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = diskoLib.jsonType;
|
||
default =
|
||
diskoLib.deepMergeMap (lv: lv._meta [ "lvm_vg" config.name ]) (attrValues config.lvs);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {}: ''
|
||
vgcreate ${config.name} $LVMDEVICES_${config.name}
|
||
${concatMapStrings (lv: lv._create {vg = config.name; }) (attrValues config.lvs)}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {}: let
|
||
lvMounts = diskoLib.deepMergeMap (lv: lv._mount {vg = config.name;}) (attrValues config.lvs);
|
||
in {
|
||
dev = ''
|
||
vgchange -a y
|
||
${concatMapStrings (x: x.dev or "") (attrValues lvMounts)}
|
||
'';
|
||
fs = lvMounts.fs;
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default =
|
||
map (lv: lv._config config.name) (attrValues config.lvs);
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: flatten (map (lv: lv._pkgs pkgs) (attrValues config.lvs));
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
lvm_lv = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
name = mkOption {
|
||
type = types.str;
|
||
default = config._module.args.name;
|
||
description = "Name of the logical volume";
|
||
};
|
||
type = mkOption {
|
||
type = types.enum [ "lvm_lv" ];
|
||
default = "lvm_lv";
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
size = mkOption {
|
||
type = types.str; # TODO lvm size type
|
||
description = "Size of the logical volume";
|
||
};
|
||
lvm_type = mkOption {
|
||
type = types.nullOr (types.enum [ "mirror" "raid0" "raid1" ]); # TODO add all types
|
||
default = null; # maybe there is always a default type?
|
||
description = "LVM type";
|
||
};
|
||
extraArgs = mkOption {
|
||
type = types.str;
|
||
default = "";
|
||
description = "Extra arguments";
|
||
};
|
||
content = diskoLib.partitionType;
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev:
|
||
optionalAttrs (!isNull config.content) (config.content._meta dev);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {vg}: ''
|
||
lvcreate \
|
||
--yes \
|
||
${if hasInfix "%" config.size then "-l" else "-L"} ${config.size} \
|
||
-n ${config.name} \
|
||
${optionalString (!isNull config.lvm_type) "--type=${config.lvm_type}"} \
|
||
${config.extraArgs} \
|
||
${vg}
|
||
${optionalString (!isNull config.content) (config.content._create {dev = "/dev/${vg}/${config.name}";})}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {vg}:
|
||
optionalAttrs (!isNull config.content) (config.content._mount {dev = "/dev/${vg}/${config.name}";});
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = vg:
|
||
[
|
||
(optional (!isNull config.content) (config.content._config "/dev/${vg}/${config.name}"))
|
||
(optional (!isNull config.lvm_type) {
|
||
boot.initrd.kernelModules = [ "dm-${config.lvm_type}" ];
|
||
})
|
||
];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: lib.optionals (!isNull config.content) (config.content._pkgs pkgs);
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
zfs = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "zfs" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
pool = mkOption {
|
||
type = types.str;
|
||
description = "Name of the ZFS pool";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev: {
|
||
deviceDependencies.zpool.${config.pool} = [ dev ];
|
||
};
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
ZFSDEVICES_${config.pool}="''${ZFSDEVICES_${config.pool}:-}${dev} "
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}:
|
||
{};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev: [];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.zfs ];
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
zpool = types.submodule [diskoLib.hookMixin ({ config, options, ... }:
|
||
{
|
||
options = {
|
||
name = mkOption {
|
||
type = types.str;
|
||
default = config._module.args.name;
|
||
description = "Name of the ZFS pool";
|
||
};
|
||
type = mkOption {
|
||
type = types.enum [ "zpool" ];
|
||
default = "zpool";
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
mode = mkOption {
|
||
type = types.str; # TODO zfs modes
|
||
default = "";
|
||
description = "Mode of the ZFS pool";
|
||
};
|
||
options = mkOption {
|
||
type = types.attrsOf types.str;
|
||
default = {};
|
||
description = "Options for the ZFS pool";
|
||
};
|
||
rootFsOptions = mkOption {
|
||
type = types.attrsOf types.str;
|
||
default = {};
|
||
description = "Options for the root filesystem";
|
||
};
|
||
mountpoint = mkOption {
|
||
type = types.nullOr optionTypes.absolute-pathname;
|
||
default = null;
|
||
description = "The mountpoint of the pool";
|
||
};
|
||
mountOptions = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [ "defaults" ];
|
||
description = "Options to pass to mount";
|
||
};
|
||
datasets = mkOption {
|
||
type = types.attrsOf zfs_dataset;
|
||
description = "List of datasets to define";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = diskoLib.jsonType;
|
||
default =
|
||
diskoLib.deepMergeMap (dataset: dataset._meta [ "zpool" config.name ]) (attrValues config.datasets);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {}: ''
|
||
zpool create ${config.name} \
|
||
${config.mode} \
|
||
${concatStringsSep " " (mapAttrsToList (n: v: "-o ${n}=${v}") config.options)} \
|
||
${concatStringsSep " " (mapAttrsToList (n: v: "-O ${n}=${v}") config.rootFsOptions)} \
|
||
''${ZFSDEVICES_${config.name}}
|
||
${concatMapStrings (dataset: dataset._create {zpool = config.name;}) (attrValues config.datasets)}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {}: let
|
||
datasetMounts = diskoLib.deepMergeMap (dataset: dataset._mount {zpool = config.name;}) (attrValues config.datasets);
|
||
in {
|
||
dev = ''
|
||
zpool list '${config.name}' >/dev/null 2>/dev/null || zpool import '${config.name}'
|
||
${concatMapStrings (x: x.dev or "") (attrValues datasetMounts)}
|
||
'';
|
||
fs = datasetMounts.fs // optionalAttrs (!isNull config.mountpoint) {
|
||
${config.mountpoint} = ''
|
||
if ! findmnt ${config.name} "/mnt${config.mountpoint}" > /dev/null 2>&1; then
|
||
mount ${config.name} "/mnt${config.mountpoint}" \
|
||
${optionalString ((config.options.mountpoint or "") != "legacy") "-o zfsutil"} \
|
||
${concatMapStringsSep " " (opt: "-o ${opt}") config.mountOptions} \
|
||
-o X-mount.mkdir \
|
||
-t zfs
|
||
fi
|
||
'';
|
||
};
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = [
|
||
(map (dataset: dataset._config config.name) (attrValues config.datasets))
|
||
(optional (!isNull config.mountpoint) {
|
||
fileSystems.${config.mountpoint} = {
|
||
device = config.name;
|
||
fsType = "zfs";
|
||
options = config.mountOptions ++ lib.optional ((config.options.mountpoint or "") != "legacy") "zfsutil";
|
||
};
|
||
})
|
||
];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.util-linux ] ++ flatten (map (dataset: dataset._pkgs pkgs) (attrValues config.datasets));
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
zfs_dataset = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
name = mkOption {
|
||
type = types.str;
|
||
default = config._module.args.name;
|
||
description = "Name of the dataset";
|
||
};
|
||
type = mkOption {
|
||
type = types.enum [ "zfs_dataset" ];
|
||
default = "zfs_dataset";
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
zfs_type = mkOption {
|
||
type = types.enum [ "filesystem" "volume" ];
|
||
description = "The type of the dataset";
|
||
};
|
||
options = mkOption {
|
||
type = types.attrsOf types.str;
|
||
default = {};
|
||
description = "Options to set for the dataset";
|
||
};
|
||
mountOptions = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [ "defaults" ];
|
||
description = "Mount options";
|
||
};
|
||
|
||
# filesystem options
|
||
mountpoint = mkOption {
|
||
type = types.nullOr optionTypes.absolute-pathname;
|
||
default = null;
|
||
description = "Path to mount the dataset to";
|
||
};
|
||
|
||
# volume options
|
||
size = mkOption {
|
||
type = types.nullOr types.str; # TODO size
|
||
default = null;
|
||
description = "Size of the dataset";
|
||
};
|
||
|
||
content = diskoLib.partitionType;
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev:
|
||
optionalAttrs (!isNull config.content) (config.content._meta dev);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {zpool}: ''
|
||
zfs create ${zpool}/${config.name} \
|
||
${concatStringsSep " " (mapAttrsToList (n: v: "-o ${n}=${v}") config.options)} \
|
||
${optionalString (config.zfs_type == "volume") "-V ${config.size}"}
|
||
${optionalString (config.zfs_type == "volume") ''
|
||
udevadm trigger --subsystem-match=block; udevadm settle
|
||
${optionalString (!isNull config.content) (config.content._create {dev = "/dev/zvol/${zpool}/${config.name}";})}
|
||
''}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {zpool}:
|
||
optionalAttrs (config.zfs_type == "volume" && !isNull config.content) (config.content._mount {dev = "/dev/zvol/${zpool}/${config.name}";}) //
|
||
optionalAttrs (config.zfs_type == "filesystem" && config.options.mountpoint or "" != "none") { fs.${config.mountpoint} = ''
|
||
if ! findmnt ${zpool}/${config.name} "/mnt${config.mountpoint}" > /dev/null 2>&1; then
|
||
mount ${zpool}/${config.name} "/mnt${config.mountpoint}" \
|
||
-o X-mount.mkdir \
|
||
${concatMapStringsSep " " (opt: "-o ${opt}") config.mountOptions} \
|
||
${optionalString ((config.options.mountpoint or "") != "legacy") "-o zfsutil"} \
|
||
-t zfs
|
||
fi
|
||
''; };
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = zpool:
|
||
(optional (config.zfs_type == "volume" && !isNull config.content) (config.content._config "/dev/zvol/${zpool}/${config.name}")) ++
|
||
(optional (config.zfs_type == "filesystem" && config.options.mountpoint or "" != "none") {
|
||
fileSystems.${config.mountpoint} = {
|
||
device = "${zpool}/${config.name}";
|
||
fsType = "zfs";
|
||
options = config.mountOptions ++ lib.optional ((config.options.mountpoint or "") != "legacy") "zfsutil";
|
||
};
|
||
});
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.util-linux ] ++ lib.optionals (!isNull config.content) (config.content._pkgs pkgs);
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
mdadm = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
name = mkOption {
|
||
type = types.str;
|
||
default = config._module.args.name;
|
||
description = "Name";
|
||
};
|
||
type = mkOption {
|
||
type = types.enum [ "mdadm" ];
|
||
default = "mdadm";
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
level = mkOption {
|
||
type = types.int;
|
||
default = 1;
|
||
description = "mdadm level";
|
||
};
|
||
metadata = mkOption {
|
||
type = types.enum [ "1" "1.0" "1.1" "1.2" "default" "ddf" "imsm" ];
|
||
default = "default";
|
||
description = "Metadata";
|
||
};
|
||
content = diskoLib.deviceType;
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = diskoLib.jsonType;
|
||
default =
|
||
optionalAttrs (!isNull config.content) (config.content._meta [ "mdadm" config.name ]);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {}: ''
|
||
echo 'y' | mdadm --create /dev/md/${config.name} \
|
||
--level=${toString config.level} \
|
||
--raid-devices=''${RAIDDEVICES_N_${config.name}} \
|
||
--metadata=${config.metadata} \
|
||
--force \
|
||
--homehost=any \
|
||
''${RAIDDEVICES_${config.name}}
|
||
udevadm trigger --subsystem-match=block; udevadm settle
|
||
${optionalString (!isNull config.content) (config.content._create {dev = "/dev/md/${config.name}";})}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {}:
|
||
optionalAttrs (!isNull config.content) (config.content._mount {dev = "/dev/md/${config.name}";});
|
||
# TODO we probably need to assemble the mdadm somehow
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default =
|
||
optional (!isNull config.content) (config.content._config "/dev/md/${config.name}");
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: (lib.optionals (!isNull config.content) (config.content._pkgs pkgs));
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
mdraid = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "mdraid" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
|
||
name = mkOption {
|
||
type = types.str;
|
||
description = "Name";
|
||
};
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev: {
|
||
deviceDependencies.mdadm.${config.name} = [ dev ];
|
||
};
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
RAIDDEVICES_N_${config.name}=$((''${RAIDDEVICES_N_${config.name}:-0}+1))
|
||
RAIDDEVICES_${config.name}="''${RAIDDEVICES_${config.name}:-}${dev} "
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}:
|
||
{};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev: [];
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.mdadm ];
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
luks = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
type = mkOption {
|
||
type = types.enum [ "luks" ];
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
name = mkOption {
|
||
type = types.str;
|
||
description = "Name of the LUKS";
|
||
};
|
||
keyFile = mkOption {
|
||
type = types.nullOr optionTypes.absolute-pathname;
|
||
default = null;
|
||
description = "Path to the key for encryption";
|
||
};
|
||
extraArgs = mkOption {
|
||
type = types.listOf types.str;
|
||
default = [];
|
||
description = "Extra arguments";
|
||
};
|
||
content = diskoLib.deviceType;
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo diskoLib.jsonType;
|
||
default = dev:
|
||
optionalAttrs (!isNull config.content) (config.content._meta dev);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {dev}: ''
|
||
cryptsetup -q luksFormat ${dev} ${diskoLib.maybeStr config.keyFile} ${toString config.extraArgs}
|
||
cryptsetup luksOpen ${dev} ${config.name} ${optionalString (!isNull config.keyFile) "--key-file ${config.keyFile}"}
|
||
${optionalString (!isNull config.content) (config.content._create {dev = "/dev/mapper/${config.name}";})}
|
||
'';
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {dev}:
|
||
let
|
||
contentMount = config.content._mount {dev = "/dev/mapper/${config.name}";};
|
||
in
|
||
{
|
||
dev = ''
|
||
cryptsetup status ${config.name} >/dev/null 2>/dev/null ||
|
||
cryptsetup luksOpen ${dev} ${config.name} ${optionalString (!isNull config.keyFile) "--key-file ${config.keyFile}"}
|
||
${optionalString (!isNull config.content) contentMount.dev or ""}
|
||
'';
|
||
fs = optionalAttrs (!isNull config.content) contentMount.fs or {};
|
||
};
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default = dev:
|
||
[
|
||
# TODO do we need this always in initrd and only there?
|
||
{ boot.initrd.luks.devices.${config.name}.device = dev; }
|
||
] ++ (optional (!isNull config.content) (config.content._config "/dev/mapper/${config.name}"));
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.cryptsetup ] ++ (lib.optionals (!isNull config.content) (config.content._pkgs pkgs));
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
|
||
disk = types.submodule [diskoLib.hookMixin ({ config, options, ... }: {
|
||
options = {
|
||
name = mkOption {
|
||
type = types.str;
|
||
default = config._module.args.name;
|
||
description = "Device name";
|
||
};
|
||
type = mkOption {
|
||
type = types.enum [ "disk" ];
|
||
default = "disk";
|
||
internal = true;
|
||
description = "Type";
|
||
};
|
||
device = mkOption {
|
||
type = optionTypes.absolute-pathname; # TODO check if subpath of /dev ? - No! eg: /.swapfile
|
||
description = "Device path";
|
||
};
|
||
content = diskoLib.deviceType;
|
||
_meta = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = diskoLib.jsonType;
|
||
default =
|
||
optionalAttrs (!isNull config.content) (config.content._meta [ "disk" config.device ]);
|
||
description = "Metadata";
|
||
};
|
||
_create = diskoLib.mkCreateOption {
|
||
inherit config options;
|
||
default = {}: config.content._create {dev = config.device;};
|
||
};
|
||
_mount = diskoLib.mkMountOption {
|
||
inherit config options;
|
||
default = {}:
|
||
optionalAttrs (!isNull config.content) (config.content._mount {dev = config.device;});
|
||
};
|
||
_config = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
default =
|
||
optional (!isNull config.content) (config.content._config config.device);
|
||
description = "NixOS configuration";
|
||
};
|
||
_pkgs = mkOption {
|
||
internal = true;
|
||
readOnly = true;
|
||
type = types.functionTo (types.listOf types.package);
|
||
default = pkgs: [ pkgs.jq ] ++ lib.optionals (!isNull config.content) (config.content._pkgs pkgs);
|
||
description = "Packages";
|
||
};
|
||
};
|
||
})];
|
||
}
|