dotfiles/flake.nix

248 lines
10 KiB
Nix
Raw Normal View History

{
description = "NixOS + Home Manager configuration of chayleaf";
inputs = {
2023-11-21 04:46:52 +07:00
#nixpkgs.url = "github:NixOS/nixpkgs/3dc2b4f8166f744c3b3e9ff8224e7c5d74a5424f";
# nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
2024-01-30 23:01:09 +07:00
nixpkgs.url = "github:chayleaf/nixpkgs";
nixos-hardware.url = "github:NixOS/nixos-hardware";
2023-12-25 03:40:33 +07:00
nix-index-database = {
url = "github:nix-community/nix-index-database";
inputs.nixpkgs.follows = "nixpkgs";
};
mobile-nixos = {
# url = "github:NixOS/mobile-nixos";
2023-12-19 11:12:34 +07:00
url = "github:chayleaf/mobile-nixos/fix-op6-modem";
flake = false;
};
impermanence.url = "github:nix-community/impermanence";
nur.url = "github:nix-community/NUR";
rust-overlay = {
url = "github:oxalica/rust-overlay";
inputs.nixpkgs.follows = "nixpkgs";
};
2023-11-27 00:20:43 +07:00
coop-ofd = {
url = "github:chayleaf/coop-ofd";
inputs.nixpkgs.follows = "nixpkgs";
};
home-manager = {
url = "github:nix-community/home-manager";
inputs.nixpkgs.follows = "nixpkgs";
};
nix-gaming = {
url = "github:fufexan/nix-gaming";
inputs.nixpkgs.follows = "nixpkgs";
};
notlua = {
url = "github:chayleaf/notlua";
inputs.nixpkgs.follows = "nixpkgs";
};
2023-06-24 07:12:11 +07:00
notnft = {
url = "github:chayleaf/notnft";
2023-06-24 07:12:11 +07:00
inputs.nixpkgs.follows = "nixpkgs";
};
nixos-router = {
url = "github:chayleaf/nixos-router";
2023-06-24 07:12:11 +07:00
inputs.nixpkgs.follows = "nixpkgs";
};
nixos-mailserver = {
url = "gitlab:simple-nixos-mailserver/nixos-mailserver";
inputs.nixpkgs.follows = "nixpkgs";
# prevent extra input from being in flake.lock
# (this doesn't affect any behavior)
inputs.nixpkgs-23_05.follows = "nixpkgs";
2024-01-27 03:57:21 +07:00
inputs.nixpkgs-23_11.follows = "nixpkgs";
};
flake-compat = {
url = "github:edolstra/flake-compat";
flake = false;
};
};
2023-12-18 08:48:49 +07:00
outputs = base-inputs@{ self, nixpkgs, ... }:
2023-05-25 05:09:17 +07:00
let
# --impure required for developing
# it takes the paths for modules from filesystem as opposed to flake inputs
2023-12-18 08:48:49 +07:00
dev = {
# coop-ofd = true;
2023-12-19 11:12:34 +07:00
# mobile-nixos = true;
# nixos-router = true;
# notnft = true;
2023-12-18 08:48:49 +07:00
};
2023-05-25 05:09:17 +07:00
# IRL-related stuff I'd rather not put into git
priv =
2023-12-18 08:48:49 +07:00
if builtins.pathExists ./private.nix then import ./private.nix { }
else if builtins.pathExists ./private/default.nix then import ./private { }
# workaround for git flakes not having access to non-checked out files
else if builtins?extraBuiltins.secrets then builtins.extraBuiltins.secrets
# yes, this is impure, this is a last ditch effort at getting access to secrets
else import /secrets/nixos { };
2023-06-24 07:12:11 +07:00
devPath = priv.devPath or ../.;
2023-12-18 08:48:49 +07:00
inputs = builtins.mapAttrs
(name: input:
if dev.${name} or false then
2023-12-19 11:12:34 +07:00
(if input._type or null == "flake"
then (import base-inputs.flake-compat { src = /${devPath}/${name}; }).defaultNix
2023-12-18 08:48:49 +07:00
else /${devPath}/${name})
else input)
base-inputs;
# if x has key s, get it. Otherwise return def
# All private config for hostname
getPriv = hostname: priv.${hostname} or { };
# Private NixOS config for hostname
getPrivSys = hostname: (getPriv hostname).system or { };
# Private home-manager config for hostname and username
getPrivUser = hostname: user: (getPriv hostname).${user} or { };
# extended lib
2023-12-18 08:48:49 +07:00
lib = nixpkgs.lib // import ./lib.nix { inherit (nixpkgs) lib; };
# can't use callPackage ./pkgs here, idk why; use import instead
overlay' = args: self: super: import ./pkgs ({
pkgs = super;
pkgs' = self;
lib = super.lib;
2023-12-18 08:48:49 +07:00
inherit inputs;
} // args);
overlay = overlay' { };
# I override some settings down the line, but overlays always stay the same
mkPkgs = config: import nixpkgs (config // {
overlays = config.overlays or [ ] ++ [ overlay ];
});
# this is actual config, it gets processed below
2023-07-28 12:02:37 +07:00
config = let
2023-07-28 14:20:39 +07:00
mkBpiR3 = args: config: config // {
2023-07-28 12:02:37 +07:00
system = "aarch64-linux";
modules = config.modules or [ ] ++ [ (import ./system/devices/bpi-r3-router.nix args) ];
2023-05-25 05:09:17 +07:00
};
2023-07-28 12:02:37 +07:00
routerConfig = rec {
2023-05-25 05:09:17 +07:00
system = "aarch64-linux";
modules = [
{
2023-12-18 08:48:49 +07:00
_module.args.server-config = self.nixosConfigurations.server.config;
_module.args.notnft = inputs.notnft.lib.${system};
2023-07-28 14:20:39 +07:00
}
2023-12-18 08:48:49 +07:00
inputs.nixos-router.nixosModules.default
2023-07-28 14:20:39 +07:00
];
};
2023-12-18 08:48:49 +07:00
in {
2023-07-28 12:02:37 +07:00
router-emmc = mkBpiR3 "emmc" routerConfig;
router-sd = mkBpiR3 "sd" routerConfig;
server = {
2023-09-13 17:20:18 +07:00
system = "aarch64-linux";
2023-06-12 17:07:38 +07:00
modules = [
2023-12-18 08:48:49 +07:00
{ _module.args.router-config = self.nixosConfigurations.router-emmc.config; }
2023-09-13 17:20:18 +07:00
./system/devices/radxa-rock5a-server.nix
2023-05-25 05:09:17 +07:00
];
};
nixmsi = rec {
system = "x86_64-linux";
2023-12-18 08:48:49 +07:00
modules = [ ./system/devices/msi-delta-15-workstation.nix ];
home.common.extraSpecialArgs = {
2023-12-18 08:48:49 +07:00
notlua = inputs.notlua.lib.${system};
};
2023-12-18 08:48:49 +07:00
home.user = [ ./home/hosts/nixmsi.nix ];
};
2023-12-24 14:27:43 +07:00
phone = rec {
system = "aarch64-linux";
2023-12-19 11:12:34 +07:00
modules = [ ./system/devices/oneplus-6-phone.nix ];
2023-12-24 14:27:43 +07:00
home.common.extraSpecialArgs = {
notlua = inputs.notlua.lib.${system};
};
home.user = [ ./home/hosts/phone.nix ];
};
2023-12-18 08:48:49 +07:00
};
in {
overlays.default = overlay;
packages = lib.genAttrs [
"x86_64-linux"
"aarch64-linux"
] (system: let self = overlay' { isOverlay = false; } (mkPkgs { inherit system; } // self) (import nixpkgs { inherit system; }); in self);
nixosImages.router = let pkgs = mkPkgs { inherit (config.router-emmc) system; }; in {
emmcImage = pkgs.callPackage ./system/hardware/bpi-r3/image.nix {
inherit (self.nixosConfigurations.router-emmc) config;
rootfsImage = self.nixosConfigurations.router-emmc.config.system.build.rootfsImage;
bpiR3Stuff = pkgs.bpiR3StuffEmmc;
};
sdImage = pkgs.callPackage ./system/hardware/bpi-r3/image.nix {
inherit (self.nixosConfigurations.router-sd) config;
rootfsImage = self.nixosConfigurations.router-sd.config.system.build.rootfsImage;
bpiR3Stuff = pkgs.bpiR3StuffSd;
};
};
hydraJobs = {
server.${config.server.system} = self.nixosConfigurations.server.config.system.build.toplevel;
router.${config.router-emmc.system} = self.nixosConfigurations.router-emmc.config.system.build.toplevel;
2023-12-24 14:27:43 +07:00
phone.${config.phone.system} = self.nixosConfigurations.phone.config.system.build.toplevel;
phone-home.${config.phone.system} = self.homeConfigurations."user@phone".activation-script;
workstation.${config.nixmsi.system} = self.nixosConfigurations.nixmsi.config.system.build.toplevel;
2023-12-18 08:48:49 +07:00
workstation-home.${config.nixmsi.system} = self.homeConfigurations."user@nixmsi".activation-script;
2023-05-25 05:09:17 +07:00
};
# this is the system config processing part
2023-12-18 08:48:49 +07:00
nixosConfigurations = lib.flip builtins.mapAttrs config (hostname: args @ { modules, nixpkgs ? {}, home ? {}, ... }:
lib.nixosSystem {
inherit (args) system;
# allow modules to access nixpkgs directly, use customized lib,
# and pass nixos-harware to let hardware modules import parts of nixos-hardware
specialArgs = {
2023-12-18 08:48:49 +07:00
inherit inputs lib;
hardware = inputs.nixos-hardware.nixosModules;
} // args.specialArgs or { };
modules = args.modules or [ ]
++ [
(getPrivSys hostname)
2023-12-18 08:48:49 +07:00
{ networking.hostName = lib.mkDefault hostname;
nixpkgs.overlays = [ overlay ]; }
inputs.impermanence.nixosModule
]
2023-12-18 08:48:49 +07:00
++ map (x: ./system/modules/${x}) (builtins.attrNames (builtins.readDir ./system/modules))
# the following is NixOS home-manager module configuration. Currently unused, but I might start using it for some hosts later.
2023-12-18 08:48:49 +07:00
++ lib.optionals (home != { } && home.common.enableNixosModule or false) [
inputs.home-manager.nixosModules.home-manager
{ home-manager = builtins.removeAttrs (home.common or { }) [ "nixpkgs" "nix" "enableNixosModule" ]; }
{ # set both to false to match behavior with standalone home-manager
home-manager.useGlobalPkgs = false;
home-manager.useUserPackages = false;
home-manager.users = builtins.mapAttrs (username: modules: {
imports = modules ++ [
2023-12-18 08:48:49 +07:00
{ nixpkgs = home.common.nixpkgs or { };
nix = home.common.nix or { }; }
({ config, pkgs, lib, ...}: {
nixpkgs.overlays = [ overlay ];
2023-12-18 08:48:49 +07:00
nix.package = lib.mkDefault pkgs.nixForNixPlugins; })
(getPrivUser hostname username)
];
2023-12-18 08:48:49 +07:00
}) (builtins.removeAttrs home [ "common" ]); }
];
});
# for each hostname, for each user, generate an attribute "${user}@${hostname}"
2023-05-25 05:09:17 +07:00
homeConfigurations =
2023-12-18 08:48:49 +07:00
builtins.listToAttrs (builtins.concatLists
(lib.flip lib.mapAttrsToList config
(hostname: { system, home ? {}, ... }:
let
common' = builtins.removeAttrs (home.common or { }) [ "nix" "nixpkgs" "enableNixosModule" ];
pkgs = mkPkgs ({ inherit system; } // home.common.nixpkgs or { });
common = common' // { inherit pkgs; };
in
lib.flip lib.mapAttrsToList (builtins.removeAttrs home [ "common" ])
# this is where actual config takes place
(user: homeConfig: lib.nameValuePair "${user}@${hostname}"
(inputs.home-manager.lib.homeManagerConfiguration (common // {
extraSpecialArgs = (common.extraSpecialArgs or { }) // { inherit inputs; };
modules =
homeConfig
++ common.modules or [ ]
++ [
(getPrivUser hostname user)
({ pkgs, lib, ... }: {
nixpkgs.overlays = [ overlay ];
nix.package = lib.mkDefault pkgs.nixForNixPlugins;
})
];
}))))));
2023-05-25 05:09:17 +07:00
};
}