324 lines
9.6 KiB
Nix
324 lines
9.6 KiB
Nix
{
|
|
core-inputs,
|
|
user-inputs,
|
|
snowfall-lib,
|
|
snowfall-config,
|
|
}: let
|
|
inherit (builtins) dirOf baseNameOf;
|
|
inherit (core-inputs.nixpkgs.lib) assertMsg fix hasInfix concatMap foldl optionals singleton;
|
|
|
|
virtual-systems = import ./virtual-systems.nix;
|
|
|
|
user-systems-root = snowfall-lib.fs.get-snowfall-file "systems";
|
|
user-modules-root = snowfall-lib.fs.get-snowfall-file "modules";
|
|
in {
|
|
system = rec {
|
|
## Get the name of a system based on its file path.
|
|
## Example Usage:
|
|
## ```nix
|
|
## get-inferred-system-name "/systems/my-system/default.nix"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## "my-system"
|
|
## ```
|
|
#@ Path -> String
|
|
get-inferred-system-name = path:
|
|
if snowfall-lib.path.has-file-extension "nix" path
|
|
then snowfall-lib.path.get-parent-directory path
|
|
else baseNameOf path;
|
|
|
|
## Check whether a named system is macOS.
|
|
## Example Usage:
|
|
## ```nix
|
|
## is-darwin "x86_64-linux"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## false
|
|
## ```
|
|
#@ String -> Bool
|
|
is-darwin = hasInfix "darwin";
|
|
|
|
## Check whether a named system is Linux.
|
|
## Example Usage:
|
|
## ```nix
|
|
## is-linux "x86_64-linux"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## false
|
|
## ```
|
|
#@ String -> Bool
|
|
is-linux = hasInfix "linux";
|
|
|
|
## Check whether a named system is virtual.
|
|
## Example Usage:
|
|
## ```nix
|
|
## is-virtual "x86_64-iso"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## true
|
|
## ```
|
|
#@ String -> Bool
|
|
is-virtual = target:
|
|
(get-virtual-system-type target) != "";
|
|
|
|
## Get the virtual system type of a system target.
|
|
## Example Usage:
|
|
## ```nix
|
|
## get-virtual-system-type "x86_64-iso"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## "iso"
|
|
## ```
|
|
#@ String -> String
|
|
get-virtual-system-type = target:
|
|
foldl
|
|
(
|
|
result: virtual-system:
|
|
if result == "" && hasInfix virtual-system target
|
|
then virtual-system
|
|
else result
|
|
)
|
|
""
|
|
virtual-systems;
|
|
|
|
## Get structured data about all systems for a given target.
|
|
## Example Usage:
|
|
## ```nix
|
|
## get-target-systems-metadata "x86_64-linux"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## [ { target = "x86_64-linux"; name = "my-machine"; path = "/systems/x86_64-linux/my-machine"; } ]
|
|
## ```
|
|
#@ String -> [Attrs]
|
|
get-target-systems-metadata = target: let
|
|
systems = snowfall-lib.fs.get-directories target;
|
|
existing-systems = builtins.filter (system: builtins.pathExists "${system}/default.nix") systems;
|
|
create-system-metadata = path: {
|
|
path = "${path}/default.nix";
|
|
# We are building flake outputs based on file contents. Nix doesn't like this
|
|
# so we have to explicitly discard the string's path context to allow us to
|
|
# use the name as a variable.
|
|
name = builtins.unsafeDiscardStringContext (builtins.baseNameOf path);
|
|
# We are building flake outputs based on file contents. Nix doesn't like this
|
|
# so we have to explicitly discard the string's path context to allow us to
|
|
# use the name as a variable.
|
|
target = builtins.unsafeDiscardStringContext (builtins.baseNameOf target);
|
|
};
|
|
system-configurations = builtins.map create-system-metadata existing-systems;
|
|
in
|
|
system-configurations;
|
|
|
|
## Get the system builder for a given target.
|
|
## Example Usage:
|
|
## ```nix
|
|
## get-system-builder "x86_64-iso"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## (args: <system>)
|
|
## ```
|
|
#@ String -> Function
|
|
get-system-builder = target: let
|
|
virtual-system-type = get-virtual-system-type target;
|
|
virtual-system-builder = args:
|
|
assert assertMsg (user-inputs ? nixos-generators) "In order to create virtual systems, you must include `nixos-generators` as a flake input.";
|
|
user-inputs.nixos-generators.nixosGenerate
|
|
(args
|
|
// {
|
|
format = virtual-system-type;
|
|
specialArgs =
|
|
args.specialArgs
|
|
// {
|
|
format = virtual-system-type;
|
|
};
|
|
modules =
|
|
args.modules
|
|
++ [
|
|
../../modules/nixos/user/default.nix
|
|
];
|
|
});
|
|
darwin-system-builder = args:
|
|
assert assertMsg (user-inputs ? darwin) "In order to create virtual systems, you must include `darwin` as a flake input.";
|
|
user-inputs.darwin.lib.darwinSystem
|
|
((builtins.removeAttrs args ["system" "modules"])
|
|
// {
|
|
specialArgs =
|
|
args.specialArgs
|
|
// {
|
|
format = "darwin";
|
|
};
|
|
modules =
|
|
args.modules
|
|
++ [
|
|
../../modules/darwin/user/default.nix
|
|
];
|
|
});
|
|
linux-system-builder = args:
|
|
core-inputs.nixpkgs.lib.nixosSystem
|
|
(args
|
|
// {
|
|
specialArgs =
|
|
args.specialArgs
|
|
// {
|
|
format = "linux";
|
|
};
|
|
modules =
|
|
args.modules
|
|
++ [
|
|
../../modules/nixos/user/default.nix
|
|
];
|
|
});
|
|
in
|
|
if virtual-system-type != ""
|
|
then virtual-system-builder
|
|
else if is-darwin target
|
|
then darwin-system-builder
|
|
else linux-system-builder;
|
|
|
|
## Get the flake output attribute for a system target.
|
|
## Example Usage:
|
|
## ```nix
|
|
## get-system-output "aarch64-darwin"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## "darwinConfigurations"
|
|
## ```
|
|
#@ String -> String
|
|
get-system-output = target: let
|
|
virtual-system-type = get-virtual-system-type target;
|
|
in
|
|
if virtual-system-type != ""
|
|
then "${virtual-system-type}Configurations"
|
|
else if is-darwin target
|
|
then "darwinConfigurations"
|
|
else "nixosConfigurations";
|
|
|
|
## Get the resolved (non-virtual) system target.
|
|
## Example Usage:
|
|
## ```nix
|
|
## get-resolved-system-target "x86_64-iso"
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## "x86_64-linux"
|
|
## ```
|
|
#@ String -> String
|
|
get-resolved-system-target = target: let
|
|
virtual-system-type = get-virtual-system-type target;
|
|
in
|
|
if virtual-system-type != ""
|
|
then builtins.replaceStrings [virtual-system-type] ["linux"] target
|
|
else target;
|
|
|
|
## Create a system.
|
|
## Example Usage:
|
|
## ```nix
|
|
## create-system { path = ./systems/my-system; }
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## <flake-utils-plus-system-configuration>
|
|
## ```
|
|
#@ Attrs -> Attrs
|
|
create-system = {
|
|
target ? "x86_64-linux",
|
|
system ? get-resolved-system-target target,
|
|
path,
|
|
name ? builtins.unsafeDiscardStringContext (get-inferred-system-name path),
|
|
modules ? [],
|
|
specialArgs ? {},
|
|
channelName ? "nixpkgs",
|
|
builder ? get-system-builder target,
|
|
output ? get-system-output target,
|
|
systems ? {},
|
|
homes ? {},
|
|
}: let
|
|
lib = snowfall-lib.internal.system-lib;
|
|
home-system-modules = snowfall-lib.home.create-home-system-modules homes;
|
|
home-manager-module =
|
|
if is-darwin system
|
|
then user-inputs.home-manager.darwinModules.home-manager
|
|
else user-inputs.home-manager.nixosModules.home-manager;
|
|
home-manager-modules = [home-manager-module] ++ home-system-modules;
|
|
in {
|
|
inherit channelName system builder output;
|
|
|
|
modules = [path] ++ modules ++ (optionals (user-inputs ? home-manager) home-manager-modules);
|
|
|
|
specialArgs =
|
|
specialArgs
|
|
// {
|
|
inherit target system systems lib;
|
|
host = name;
|
|
|
|
virtual = (get-virtual-system-type target) != "";
|
|
inputs = snowfall-lib.flake.without-src user-inputs;
|
|
};
|
|
};
|
|
|
|
## Create all available systems.
|
|
## Example Usage:
|
|
## ```nix
|
|
## create-systems { hosts.my-host.specialArgs.x = true; modules.nixos = [ my-shared-module ]; }
|
|
## ```
|
|
## Result:
|
|
## ```nix
|
|
## { my-host = <flake-utils-plus-system-configuration>; }
|
|
## ```
|
|
#@ Attrs -> Attrs
|
|
create-systems = {
|
|
systems ? {},
|
|
homes ? {},
|
|
}: let
|
|
targets = snowfall-lib.fs.get-directories user-systems-root;
|
|
target-systems-metadata = concatMap get-target-systems-metadata targets;
|
|
user-nixos-modules = snowfall-lib.module.create-modules {
|
|
src = "${user-modules-root}/nixos";
|
|
};
|
|
user-darwin-modules = snowfall-lib.module.create-modules {
|
|
src = "${user-modules-root}/darwin";
|
|
};
|
|
nixos-modules = systems.modules.nixos or [];
|
|
darwin-modules = systems.modules.darwin or [];
|
|
|
|
create-system' = created-systems: system-metadata: let
|
|
overrides = systems.hosts.${system-metadata.name} or {};
|
|
user-modules =
|
|
if is-darwin system-metadata.target
|
|
then user-darwin-modules
|
|
else user-nixos-modules;
|
|
user-modules-list = builtins.attrValues user-modules;
|
|
system-modules =
|
|
if is-darwin system-metadata.target
|
|
then darwin-modules
|
|
else nixos-modules;
|
|
in {
|
|
${system-metadata.name} = create-system (overrides
|
|
// system-metadata
|
|
// {
|
|
systems = created-systems;
|
|
modules = user-modules-list ++ (overrides.modules or []) ++ system-modules;
|
|
inherit homes;
|
|
});
|
|
};
|
|
created-systems = fix (
|
|
created-systems:
|
|
foldl
|
|
(
|
|
systems: system-metadata:
|
|
systems // (create-system' created-systems system-metadata)
|
|
)
|
|
{}
|
|
target-systems-metadata
|
|
);
|
|
in
|
|
created-systems;
|
|
};
|
|
}
|