snowfield/default.nix at main · JulienMalka/snowfield · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
let
  inputs = import ./lon.nix;
  inputs_final = inputs;
  dnsLib = (import inputs.dns).lib;
  lib = (import "${inputs.nixpkgs}/lib").extend (import ./lib inputs_final self.profiles dnsLib);
  mkLibForMachine =
    machine:
    (import "${lib.snowfield.${machine}.nixpkgs_version}/lib").extend (
      import ./lib inputs_final self.profiles dnsLib
    );
  machines_plats = lib.lists.unique (
    lib.mapAttrsToList (_name: value: value.arch) (
      lib.filterAttrs (_n: v: builtins.hasAttr "arch" v) lib.snowfield
    )
  );

  nixpkgs_plats = builtins.listToAttrs (
    builtins.map (plat: {
      name = plat;
      value = import inputs.nixpkgs { system = plat; };
    }) machines_plats
  );
  self = rec {

    inherit lib;

    nixosModules = builtins.listToAttrs (
      map (x: {
        name = x;
        value = import (./modules + "/${x}");
      }) (builtins.attrNames (builtins.readDir ./modules))
    );

    profiles = builtins.listToAttrs (
      map (x: {
        name = lib.strings.removeSuffix ".nix" x;
        value = import (./profiles + "/${x}");
      }) (builtins.attrNames (builtins.readDir ./profiles))
    );

    nixosConfigurations = builtins.mapAttrs (
      name: value:
      (lib.mkMachine {
        inherit name self dnsLib;
        host-config = value;
        modules = builtins.attrValues nixosModules ++ lib.snowfield.${name}.profiles;
        nixpkgs = lib.snowfield.${name}.nixpkgs_version;
        system = lib.snowfield.${name}.arch;
        home-manager = lib.snowfield.${name}.hm_version;
      })
    ) (lib.importConfig ./machines);

    colmena = {
      meta = {
        nodeNixpkgs = builtins.mapAttrs (
          n: _: import lib.snowfield.${n}.nixpkgs_version
        ) nixosConfigurations;
        nodeSpecialArgs = builtins.mapAttrs (
          n: v: v._module.specialArgs // { lib = mkLibForMachine n; }
        ) nixosConfigurations;
      };
    }
    // builtins.mapAttrs (_: v: { imports = v._module.args.modules; }) nixosConfigurations;

    all_secrets_nixos = lib.foldl (acc: v: lib.deepMerge acc v) { } (
      lib.attrValues (
        lib.mapAttrs (
          n: v:
          lib.mapAttrs' (
            _: j: lib.nameValuePair (builtins.toString j.file) (j // { targets = [ n ]; })
          ) v.config.age.secrets
        ) nixosConfigurations
      )
    );

    all_secrets_hm = lib.foldl (acc: v: lib.deepMerge acc v) { } (
      lib.attrValues (
        lib.mapAttrs (
          n: v:
          lib.mapAttrs' (
            _: j: lib.nameValuePair (builtins.toString j.file) (j // { targets = [ "${n}_home" ]; })
          ) v.config.home-manager.users.julien.age.secrets
        ) nixosConfigurations
      )
    );

    all_secrets = all_secrets_nixos // all_secrets_hm;

    packages = builtins.listToAttrs (
      builtins.map (plat: {
        name = plat;
        value =
          lib.filterAttrs
            (
              _name: value:
              (
                !lib.hasAttrByPath [
                  "meta"
                  "platforms"
                ] value
              )
              || builtins.elem plat value.meta.platforms
            )
            (
              builtins.listToAttrs (
                builtins.map (e: {
                  name = e;
                  value = nixpkgs_plats.${plat}.callPackage (./packages + "/${e}") { };
                }) (builtins.attrNames (builtins.readDir ./packages))
              )
            );
      }) machines_plats
    );

    # comin's nix executor appends both .toplevel and .config.services.comin.machineId
    # to systemAttr, so we need an attrset with both at the same level
    cominConfigurations = builtins.mapAttrs (
      _: v: v.config.system.build // { inherit (v) config; }
    ) nixosConfigurations;

    checks = {
      inherit packages;
      machines = lib.mapAttrs (_: v: v.config.system.build.toplevel) nixosConfigurations;
    };
  };
in
self