···

       
14
       
14
       
 
       
    builtins.map

     

       
15
       
15
       
 
       
      (subsetname: {

     

       
16
       
16
       
 
       
        subsetname = subsetname;

     

       
17
       
17
       
-
       
        functions = libDefPos toplib."${subsetname}";

     

       
17
       
17
       
+
       
        functions = libDefPos toplib.${subsetname};

     

       
18
       
18
       
 
       
      })

     

       
19
       
19
       
 
       
      (builtins.filter

     

       
20
       
20
       
-
       
        (name: builtins.isAttrs toplib."${name}")

     

       
20
       
20
       
+
       
        (name: builtins.isAttrs toplib.${name})

     

       
21
       
21
       
 
       
        (builtins.attrNames toplib));

     

       
22
       
22
       
 
       


     

       
23
       
23
       
 
       
  nixpkgsLib = pkgs.lib;

     

···

       
446
       
446
       
 
       
      if length list < 2

     

       
447
       
447
       
 
       
      then # finish

     

       
448
       
448
       
 
       
           { result =  list; }

     

       
449
       
449
       
-
       
      else if dfsthis ? "cycle"

     

       
449
       
449
       
+
       
      else if dfsthis ? cycle

     

       
450
       
450
       
 
       
           then # there's a cycle, starting from the current vertex, return it

     

       
451
       
451
       
 
       
                { cycle = reverseList ([ dfsthis.cycle ] ++ dfsthis.visited);

     

       
452
       
452
       
 
       
                  inherit (dfsthis) loops; }

     

       
453
       
453
       
-
       
           else if toporest ? "cycle"

     

       
453
       
453
       
+
       
           else if toporest ? cycle

     

       
454
       
454
       
 
       
                then # there's a cycle somewhere else in the graph, return it

     

       
455
       
455
       
 
       
                     toporest

     

       
456
       
456
       
 
       
                # Slow, but short. Can be made a bit faster with an explicit stack.

     

···

       
58
       
58
       
 
       
      uname = {

     

       
59
       
59
       
 
       
        # uname -s

     

       
60
       
60
       
 
       
        system = {

     

       
61
       
61
       
-
       
          "linux" = "Linux";

     

       
62
       
62
       
-
       
          "windows" = "Windows";

     

       
63
       
63
       
-
       
          "darwin" = "Darwin";

     

       
64
       
64
       
-
       
          "netbsd" = "NetBSD";

     

       
65
       
65
       
-
       
          "freebsd" = "FreeBSD";

     

       
66
       
66
       
-
       
          "openbsd" = "OpenBSD";

     

       
67
       
67
       
-
       
          "wasi" = "Wasi";

     

       
61
       
61
       
+
       
          linux = "Linux";

     

       
62
       
62
       
+
       
          windows = "Windows";

     

       
63
       
63
       
+
       
          darwin = "Darwin";

     

       
64
       
64
       
+
       
          netbsd = "NetBSD";

     

       
65
       
65
       
+
       
          freebsd = "FreeBSD";

     

       
66
       
66
       
+
       
          openbsd = "OpenBSD";

     

       
67
       
67
       
+
       
          wasi = "Wasi";

     

       
68
       
68
       
 
       
        }.${final.parsed.kernel.name} or null;

     

       
69
       
69
       
 
       


     

       
70
       
70
       
 
       
         # uname -p

     
···

       
86
       
86
       
 
       
        else if final.isx86_64 then "x86_64"

     

       
87
       
87
       
 
       
        else if final.isx86 then "i386"

     

       
88
       
88
       
 
       
        else {

     

       
89
       
89
       
-
       
          "powerpc" = "ppc";

     

       
90
       
90
       
-
       
          "powerpcle" = "ppc";

     

       
91
       
91
       
-
       
          "powerpc64" = "ppc64";

     

       
92
       
92
       
-
       
          "powerpc64le" = "ppc64le";

     

       
89
       
89
       
+
       
          powerpc = "ppc";

     

       
90
       
90
       
+
       
          powerpcle = "ppc";

     

       
91
       
91
       
+
       
          powerpc64 = "ppc64";

     

       
92
       
92
       
+
       
          powerpc64le = "ppc64le";

     

       
93
       
93
       
 
       
        }.${final.parsed.cpu.name} or final.parsed.cpu.name;

     

       
94
       
94
       
 
       


     

       
95
       
95
       
 
       
      emulator = pkgs: let

     

···

       
456
       
456
       
 
       
  };

     

       
457
       
457
       
 
       


     

       
458
       
458
       
 
       
  selectBySystem = system: {

     

       
459
       
459
       
-
       
      "i486-linux" = pc32;

     

       
460
       
460
       
-
       
      "i586-linux" = pc32;

     

       
461
       
461
       
-
       
      "i686-linux" = pc32;

     

       
462
       
462
       
-
       
      "x86_64-linux" = pc64;

     

       
463
       
463
       
-
       
      "armv5tel-linux" = sheevaplug;

     

       
464
       
464
       
-
       
      "armv6l-linux" = raspberrypi;

     

       
465
       
465
       
-
       
      "armv7a-linux" = armv7l-hf-multiplatform;

     

       
466
       
466
       
-
       
      "armv7l-linux" = armv7l-hf-multiplatform;

     

       
467
       
467
       
-
       
      "aarch64-linux" = aarch64-multiplatform;

     

       
468
       
468
       
-
       
      "mipsel-linux" = fuloong2f_n32;

     

       
469
       
469
       
-
       
      "powerpc64le-linux" = powernv;

     

       
459
       
459
       
+
       
      i486-linux = pc32;

     

       
460
       
460
       
+
       
      i586-linux = pc32;

     

       
461
       
461
       
+
       
      i686-linux = pc32;

     

       
462
       
462
       
+
       
      x86_64-linux = pc64;

     

       
463
       
463
       
+
       
      armv5tel-linux = sheevaplug;

     

       
464
       
464
       
+
       
      armv6l-linux = raspberrypi;

     

       
465
       
465
       
+
       
      armv7a-linux = armv7l-hf-multiplatform;

     

       
466
       
466
       
+
       
      armv7l-linux = armv7l-hf-multiplatform;

     

       
467
       
467
       
+
       
      aarch64-linux = aarch64-multiplatform;

     

       
468
       
468
       
+
       
      mipsel-linux = fuloong2f_n32;

     

       
469
       
469
       
+
       
      powerpc64le-linux = powernv;

     

       
470
       
470
       
 
       
    }.${system} or pcBase;

     

       
471
       
471
       
 
       
}

     

···

       
42
       
42
       
 
       
  # Default type functor

     

       
43
       
43
       
 
       
  defaultFunctor = name: {

     

       
44
       
44
       
 
       
    inherit name;

     

       
45
       
45
       
-
       
    type    = types."${name}" or null;

     

       
45
       
45
       
+
       
    type    = types.${name} or null;

     

       
46
       
46
       
 
       
    wrapped = null;

     

       
47
       
47
       
 
       
    payload = null;

     

       
48
       
48
       
 
       
    binOp   = a: b: null;

     

···

       
17
       
17
       
 
       
        else throw "Unknown QEMU serial device for system '${pkgs.stdenv.hostPlatform.system}'";

     

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
  qemuBinary = qemuPkg: {

     

       
20
       
20
       
-
       
    "x86_64-linux" = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";

     

       
21
       
21
       
-
       
    "armv7l-linux" = "${qemuPkg}/bin/qemu-system-arm -enable-kvm -machine virt -cpu host";

     

       
22
       
22
       
-
       
    "aarch64-linux" = "${qemuPkg}/bin/qemu-system-aarch64 -enable-kvm -machine virt,gic-version=host -cpu host";

     

       
23
       
23
       
-
       
    "x86_64-darwin" = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";

     

       
20
       
20
       
+
       
    x86_64-linux = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";

     

       
21
       
21
       
+
       
    armv7l-linux = "${qemuPkg}/bin/qemu-system-arm -enable-kvm -machine virt -cpu host";

     

       
22
       
22
       
+
       
    aarch64-linux = "${qemuPkg}/bin/qemu-system-aarch64 -enable-kvm -machine virt,gic-version=host -cpu host";

     

       
23
       
23
       
+
       
    x86_64-darwin = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";

     

       
24
       
24
       
 
       
  }.${pkgs.stdenv.hostPlatform.system} or "${qemuPkg}/bin/qemu-kvm";

     

       
25
       
25
       
 
       
}

     

···

       
35
       
35
       
 
       
                  then "fontconfig"

     

       
36
       
36
       
 
       
                  else "fontconfig_${version}";

     

       
37
       
37
       
 
       
      makeCache = fontconfig: pkgs.makeFontsCache { inherit fontconfig; fontDirectories = config.fonts.fonts; };

     

       
38
       
38
       
-
       
      cache     = makeCache pkgs."${fcPackage}";

     

       
39
       
39
       
-
       
      cache32   = makeCache pkgs.pkgsi686Linux."${fcPackage}";

     

       
38
       
38
       
+
       
      cache     = makeCache pkgs.${fcPackage};

     

       
39
       
39
       
+
       
      cache32   = makeCache pkgs.pkgsi686Linux.${fcPackage};

     

       
40
       
40
       
 
       
    in

     

       
41
       
41
       
 
       
    pkgs.writeText "fc-00-nixos-cache.conf" ''

     

       
42
       
42
       
 
       
      <?xml version='1.0'?>

     

···

       
79
       
79
       
 
       
  config = mkIf (config.fonts.fontconfig.enable && cfg.enable) {

     

       
80
       
80
       
 
       


     

       
81
       
81
       
 
       
    fonts.fontconfig.confPackages = [ confPkg ];

     

       
82
       
82
       
-
       
    environment.variables."INFINALITY_FT" = cfg.preset;

     

       
82
       
82
       
+
       
    environment.variables.INFINALITY_FT = cfg.preset;

     

       
83
       
83
       
 
       


     

       
84
       
84
       
 
       
  };

     

       
85
       
85
       
 
       


     

···

       
50
       
50
       
 
       
                    then "fontconfig"

     

       
51
       
51
       
 
       
                    else "fontconfig_${version}";

     

       
52
       
52
       
 
       
        makeCache = fontconfig: pkgs.makeFontsCache { inherit fontconfig; fontDirectories = config.fonts.fonts; };

     

       
53
       
53
       
-
       
        cache     = makeCache pkgs."${fcPackage}";

     

       
54
       
54
       
-
       
        cache32   = makeCache pkgs.pkgsi686Linux."${fcPackage}";

     

       
53
       
53
       
+
       
        cache     = makeCache pkgs.${fcPackage};

     

       
54
       
54
       
+
       
        cache32   = makeCache pkgs.pkgsi686Linux.${fcPackage};

     

       
55
       
55
       
 
       
      in

     

       
56
       
56
       
 
       
      pkgs.writeText "fc-00-nixos-cache.conf" ''

     

       
57
       
57
       
 
       
        <?xml version='1.0'?>

     

···

       
15
       
15
       
 
       
    realms = optionalAttrs (lib.all (value: value != null) [

     

       
16
       
16
       
 
       
      cfg.defaultRealm cfg.kdc cfg.kerberosAdminServer

     

       
17
       
17
       
 
       
    ]) {

     

       
18
       
18
       
-
       
      "${cfg.defaultRealm}" = {

     

       
18
       
18
       
+
       
      ${cfg.defaultRealm} = {

     

       
19
       
19
       
 
       
        kdc = cfg.kdc;

     

       
20
       
20
       
 
       
        admin_server = cfg.kerberosAdminServer;

     

       
21
       
21
       
 
       
      };

     
···

       
25
       
25
       
 
       
      cfg.domainRealm cfg.defaultRealm

     

       
26
       
26
       
 
       
    ]) {

     

       
27
       
27
       
 
       
      ".${cfg.domainRealm}" = cfg.defaultRealm;

     

       
28
       
28
       
-
       
      "${cfg.domainRealm}" = cfg.defaultRealm;

     

       
28
       
28
       
+
       
      ${cfg.domainRealm} = cfg.defaultRealm;

     

       
29
       
29
       
 
       
    };

     

       
30
       
30
       
 
       
  };

     

       
31
       
31
       
 
       


     

···

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
  # The set of alternative malloc(3) providers.

     

       
8
       
8
       
 
       
  providers = {

     

       
9
       
9
       
-
       
    "graphene-hardened" = rec {

     

       
9
       
9
       
+
       
    graphene-hardened = rec {

     

       
10
       
10
       
 
       
      libPath = "${pkgs.graphene-hardened-malloc}/lib/libhardened_malloc.so";

     

       
11
       
11
       
 
       
      description = ''

     

       
12
       
12
       
 
       
        An allocator designed to mitigate memory corruption attacks, such as

     
···

       
14
       
14
       
 
       
      '';

     

       
15
       
15
       
 
       
    };

     

       
16
       
16
       
 
       


     

       
17
       
17
       
-
       
    "jemalloc" = {

     

       
17
       
17
       
+
       
    jemalloc = {

     

       
18
       
18
       
 
       
      libPath = "${pkgs.jemalloc}/lib/libjemalloc.so";

     

       
19
       
19
       
 
       
      description = ''

     

       
20
       
20
       
 
       
        A general purpose allocator that emphasizes fragmentation avoidance

     
···

       
22
       
22
       
 
       
      '';

     

       
23
       
23
       
 
       
    };

     

       
24
       
24
       
 
       


     

       
25
       
25
       
-
       
    "scudo" = {

     

       
25
       
25
       
+
       
    scudo = {

     

       
26
       
26
       
 
       
      libPath = "${pkgs.llvmPackages.compiler-rt}/lib/linux/libclang_rt.scudo-x86_64.so";

     

       
27
       
27
       
 
       
      description = ''

     

       
28
       
28
       
 
       
        A user-mode allocator based on LLVM Sanitizer’s CombinedAllocator,

     
···

       
32
       
32
       
 
       
    };

     

       
33
       
33
       
 
       
  };

     

       
34
       
34
       
 
       


     

       
35
       
35
       
-
       
  providerConf = providers."${cfg.provider}";

     

       
35
       
35
       
+
       
  providerConf = providers.${cfg.provider};

     

       
36
       
36
       
 
       


     

       
37
       
37
       
 
       
  # An output that contains only the shared library, to avoid

     

       
38
       
38
       
 
       
  # needlessly bloating the system closure

     

···

       
171
       
171
       
 
       


     

       
172
       
172
       
 
       
    environment.etc =

     

       
173
       
173
       
 
       
      { # /etc/services: TCP/UDP port assignments.

     

       
174
       
174
       
-
       
        "services".source = pkgs.iana-etc + "/etc/services";

     

       
174
       
174
       
+
       
        services.source = pkgs.iana-etc + "/etc/services";

     

       
175
       
175
       
 
       


     

       
176
       
176
       
 
       
        # /etc/protocols: IP protocol numbers.

     

       
177
       
177
       
-
       
        "protocols".source  = pkgs.iana-etc + "/etc/protocols";

     

       
177
       
177
       
+
       
        protocols.source  = pkgs.iana-etc + "/etc/protocols";

     

       
178
       
178
       
 
       


     

       
179
       
179
       
 
       
        # /etc/hosts: Hostname-to-IP mappings.

     

       
180
       
180
       
-
       
        "hosts".text = let

     

       
180
       
180
       
+
       
        hosts.text = let

     

       
181
       
181
       
 
       
          oneToString = set: ip: ip + " " + concatStringsSep " " set.${ip};

     

       
182
       
182
       
 
       
          allToString = set: concatMapStringsSep "\n" (oneToString set) (attrNames set);

     

       
183
       
183
       
 
       
        in ''

     
···

       
190
       
190
       
 
       


     

       
191
       
191
       
 
       
      } // optionalAttrs (pkgs.stdenv.hostPlatform.libc == "glibc") {

     

       
192
       
192
       
 
       
        # /etc/rpc: RPC program numbers.

     

       
193
       
193
       
-
       
        "rpc".source = pkgs.glibc.out + "/etc/rpc";

     

       
193
       
193
       
+
       
        rpc.source = pkgs.glibc.out + "/etc/rpc";

     

       
194
       
194
       
 
       
      };

     

       
195
       
195
       
 
       


     

       
196
       
196
       
 
       
      networking.proxy.envVars =

     

···

       
78
       
78
       
 
       
    };

     

       
79
       
79
       
 
       


     

       
80
       
80
       
 
       
    # Service executed before suspending/hibernating.

     

       
81
       
81
       
-
       
    systemd.services."pre-sleep" =

     

       
81
       
81
       
+
       
    systemd.services.pre-sleep =

     

       
82
       
82
       
 
       
      { description = "Pre-Sleep Actions";

     

       
83
       
83
       
 
       
        wantedBy = [ "sleep.target" ];

     

       
84
       
84
       
 
       
        before = [ "sleep.target" ];

     
···

       
89
       
89
       
 
       
        serviceConfig.Type = "oneshot";

     

       
90
       
90
       
 
       
      };

     

       
91
       
91
       
 
       


     

       
92
       
92
       
-
       
    systemd.services."post-resume" =

     

       
92
       
92
       
+
       
    systemd.services.post-resume =

     

       
93
       
93
       
 
       
      { description = "Post-Resume Actions";

     

       
94
       
94
       
 
       
        after = [ "suspend.target" "hibernate.target" "hybrid-sleep.target" ];

     

       
95
       
95
       
 
       
        script =

     

···

       
163
       
163
       
 
       
      l  = "ls -alh";

     

       
164
       
164
       
 
       
    };

     

       
165
       
165
       
 
       


     

       
166
       
166
       
-
       
    environment.etc."shells".text =

     

       
166
       
166
       
+
       
    environment.etc.shells.text =

     

       
167
       
167
       
 
       
      ''

     

       
168
       
168
       
 
       
        ${concatStringsSep "\n" (map utils.toShellPath cfg.shells)}

     

       
169
       
169
       
 
       
        /bin/sh

     
···

       
171
       
171
       
 
       


     

       
172
       
172
       
 
       
    # For resetting environment with `. /etc/set-environment` when needed

     

       
173
       
173
       
 
       
    # and discoverability (see motivation of #30418).

     

       
174
       
174
       
-
       
    environment.etc."set-environment".source = config.system.build.setEnvironment;

     

       
174
       
174
       
+
       
    environment.etc.set-environment.source = config.system.build.setEnvironment;

     

       
175
       
175
       
 
       


     

       
176
       
176
       
 
       
    system.build.setEnvironment = pkgs.writeText "set-environment"

     

       
177
       
177
       
 
       
      ''

     

···

       
8
       
8
       
 
       
      "/share/terminfo"

     

       
9
       
9
       
 
       
    ];

     

       
10
       
10
       
 
       


     

       
11
       
11
       
-
       
    environment.etc."terminfo" = {

     

       
11
       
11
       
+
       
    environment.etc.terminfo = {

     

       
12
       
12
       
 
       
      source = "${config.system.path}/share/terminfo";

     

       
13
       
13
       
 
       
    };

     

       
14
       
14
       
 
       


     

···

       
546
       
546
       
 
       
    environment.systemPackages = systemShells;

     

       
547
       
547
       
 
       


     

       
548
       
548
       
 
       
    environment.etc = {

     

       
549
       
549
       
-
       
      "subuid" = {

     

       
549
       
549
       
+
       
      subuid = {

     

       
550
       
550
       
 
       
        text = subuidFile;

     

       
551
       
551
       
 
       
        mode = "0644";

     

       
552
       
552
       
 
       
      };

     

       
553
       
553
       
-
       
      "subgid" = {

     

       
553
       
553
       
+
       
      subgid = {

     

       
554
       
554
       
 
       
        text = subgidFile;

     

       
555
       
555
       
 
       
        mode = "0644";

     

       
556
       
556
       
 
       
      };

     

···

       
36
       
36
       
 
       
        { inherit (cfg) group; }

     

       
37
       
37
       
 
       
      ))

     

       
38
       
38
       
 
       
    ];

     

       
39
       
39
       
-
       
    users.groups."${cfg.group}" = {};

     

       
39
       
39
       
+
       
    users.groups.${cfg.group} = {};

     

       
40
       
40
       
 
       
  };

     

       
41
       
41
       
 
       
}

     

···

       
33
       
33
       
 
       


     

       
34
       
34
       
 
       
    boot.blacklistedKernelModules = [ "radeon" ];

     

       
35
       
35
       
 
       


     

       
36
       
36
       
-
       
    environment.etc."ati".source = "${ati_x11}/etc/ati";

     

       
36
       
36
       
+
       
    environment.etc.ati.source = "${ati_x11}/etc/ati";

     

       
37
       
37
       
 
       


     

       
38
       
38
       
 
       
  };

     

       
39
       
39
       
 
       


     

···

       
85
       
85
       
 
       
    # Generate /etc/os-release.  See

     

       
86
       
86
       
 
       
    # https://www.freedesktop.org/software/systemd/man/os-release.html for the

     

       
87
       
87
       
 
       
    # format.

     

       
88
       
88
       
-
       
    environment.etc."os-release".text =

     

       
88
       
88
       
+
       
    environment.etc.os-release.text =

     

       
89
       
89
       
 
       
      ''

     

       
90
       
90
       
 
       
        NAME=NixOS

     

       
91
       
91
       
 
       
        ID=nixos

     

···

       
30
       
30
       
 
       
  };

     

       
31
       
31
       
 
       


     

       
32
       
32
       
 
       
  config = mkIf (cfg.settings != {}) {

     

       
33
       
33
       
-
       
    environment.etc."atoprc".text =

     

       
33
       
33
       
+
       
    environment.etc.atoprc.text =

     

       
34
       
34
       
 
       
      concatStrings (mapAttrsToList (n: v: "${n} ${toString v}\n") cfg.settings);

     

       
35
       
35
       
 
       
  };

     

       
36
       
36
       
 
       
}

     

···

       
159
       
159
       
 
       


     

       
160
       
160
       
 
       
    };

     

       
161
       
161
       
 
       


     

       
162
       
162
       
-
       
    environment.etc."profile".text =

     

       
162
       
162
       
+
       
    environment.etc.profile.text =

     

       
163
       
163
       
 
       
      ''

     

       
164
       
164
       
 
       
        # /etc/profile: DO NOT EDIT -- this file has been generated automatically.

     

       
165
       
165
       
 
       
        # This file is read for login shells.

     
···

       
184
       
184
       
 
       
        fi

     

       
185
       
185
       
 
       
      '';

     

       
186
       
186
       
 
       


     

       
187
       
187
       
-
       
    environment.etc."bashrc".text =

     

       
187
       
187
       
+
       
    environment.etc.bashrc.text =

     

       
188
       
188
       
 
       
      ''

     

       
189
       
189
       
 
       
        # /etc/bashrc: DO NOT EDIT -- this file has been generated automatically.

     

       
190
       
190
       
 
       


     
···

       
212
       
212
       
 
       


     

       
213
       
213
       
 
       
    # Configuration for readline in bash. We use "option default"

     

       
214
       
214
       
 
       
    # priority to allow user override using both .text and .source.

     

       
215
       
215
       
-
       
    environment.etc."inputrc".source = mkOptionDefault ./inputrc;

     

       
215
       
215
       
+
       
    environment.etc.inputrc.source = mkOptionDefault ./inputrc;

     

       
216
       
216
       
 
       


     

       
217
       
217
       
 
       
    users.defaultUserShell = mkDefault pkgs.bashInteractive;

     

       
218
       
218
       
 
       


     

···

       
54
       
54
       
 
       
        type = types.attrsOf types.str;

     

       
55
       
55
       
 
       
        default = {};

     

       
56
       
56
       
 
       
        example = {

     

       
57
       
57
       
-
       
          "h" = "noaction 5\e(";

     

       
58
       
58
       
-
       
          "l" = "noaction 5\e)";

     

       
57
       
57
       
+
       
          h = "noaction 5\e(";

     

       
58
       
58
       
+
       
          l = "noaction 5\e)";

     

       
59
       
59
       
 
       
        };

     

       
60
       
60
       
 
       
        description = "Defines new command keys.";

     

       
61
       
61
       
 
       
      };

     
···

       
74
       
74
       
 
       
        type = types.attrsOf types.str;

     

       
75
       
75
       
 
       
        default = {};

     

       
76
       
76
       
 
       
        example = {

     

       
77
       
77
       
-
       
          "\e" = "abort";

     

       
77
       
77
       
+
       
          e = "abort";

     

       
78
       
78
       
 
       
        };

     

       
79
       
79
       
 
       
        description = "Defines new line-editing keys.";

     

       
80
       
80
       
 
       
      };

     
···

       
111
       
111
       
 
       
    environment.systemPackages = [ pkgs.less ];

     

       
112
       
112
       
 
       


     

       
113
       
113
       
 
       
    environment.variables = {

     

       
114
       
114
       
-
       
      "LESSKEY_SYSTEM" = toString lessKey;

     

       
114
       
114
       
+
       
      LESSKEY_SYSTEM = toString lessKey;

     

       
115
       
115
       
 
       
    } // optionalAttrs (cfg.lessopen != null) {

     

       
116
       
116
       
-
       
      "LESSOPEN" = cfg.lessopen;

     

       
116
       
116
       
+
       
      LESSOPEN = cfg.lessopen;

     

       
117
       
117
       
 
       
    } // optionalAttrs (cfg.lessclose != null) {

     

       
118
       
118
       
-
       
      "LESSCLOSE" = cfg.lessclose;

     

       
118
       
118
       
+
       
      LESSCLOSE = cfg.lessclose;

     

       
119
       
119
       
 
       
    };

     

       
120
       
120
       
 
       


     

       
121
       
121
       
 
       
    warnings = optional (

     

···

       
35
       
35
       
 
       
  ###### implementation

     

       
36
       
36
       
 
       


     

       
37
       
37
       
 
       
  config = lib.mkIf (cfg.nanorc != "" || cfg.syntaxHighlight) {

     

       
38
       
38
       
-
       
    environment.etc."nanorc".text = lib.concatStrings [ cfg.nanorc

     

       
38
       
38
       
+
       
    environment.etc.nanorc.text = lib.concatStrings [ cfg.nanorc

     

       
39
       
39
       
 
       
      (lib.optionalString cfg.syntaxHighlight ''${LF}include "${pkgs.nano}/share/nano/*.nanorc"'') ];

     

       
40
       
40
       
 
       
  };

     

       
41
       
41
       
 
       


     

···

       
36
       
36
       
 
       
  ###### implementation

     

       
37
       
37
       
 
       


     

       
38
       
38
       
 
       
  config = lib.mkIf cfg.enable {

     

       
39
       
39
       
-
       
    environment.etc."npmrc".text = cfg.npmrc;

     

       
39
       
39
       
+
       
    environment.etc.npmrc.text = cfg.npmrc;

     

       
40
       
40
       
 
       


     

       
41
       
41
       
 
       
    environment.variables.NPM_CONFIG_GLOBALCONFIG = "/etc/npmrc";

     

       
42
       
42
       
 
       


     

···

       
24
       
24
       
 
       
  ###### implementation

     

       
25
       
25
       
 
       


     

       
26
       
26
       
 
       
  config = mkIf (cfg.screenrc != "") {

     

       
27
       
27
       
-
       
    environment.etc."screenrc".text = cfg.screenrc;

     

       
27
       
27
       
+
       
    environment.etc.screenrc.text = cfg.screenrc;

     

       
28
       
28
       
 
       


     

       
29
       
29
       
 
       
    environment.systemPackages = [ pkgs.screen ];

     

       
30
       
30
       
 
       
  };

     

···

       
61
       
61
       
 
       
        description = "Setup of xfs_quota projects. Make sure the filesystem is mounted with the pquota option.";

     

       
62
       
62
       
 
       


     

       
63
       
63
       
 
       
        example = {

     

       
64
       
64
       
-
       
          "projname" = {

     

       
64
       
64
       
+
       
          projname = {

     

       
65
       
65
       
 
       
            id = 50;

     

       
66
       
66
       
 
       
            path = "/xfsprojects/projname";

     

       
67
       
67
       
 
       
            sizeHardLimit = "50g";

     

···

       
45
       
45
       
 
       


     

       
46
       
46
       
 
       
  config = mkIf cfg.enable {

     

       
47
       
47
       
 
       


     

       
48
       
48
       
-
       
    environment.etc."xonshrc".text = cfg.config;

     

       
48
       
48
       
+
       
    environment.etc.xonshrc.text = cfg.config;

     

       
49
       
49
       
 
       


     

       
50
       
50
       
 
       
    environment.systemPackages = [ cfg.package ];

     

       
51
       
51
       
 
       


     

···

       
135
       
135
       
 
       


     

       
136
       
136
       
 
       
    programs.zsh.shellAliases = mapAttrs (name: mkDefault) cfge.shellAliases;

     

       
137
       
137
       
 
       


     

       
138
       
138
       
-
       
    environment.etc."zshenv".text =

     

       
138
       
138
       
+
       
    environment.etc.zshenv.text =

     

       
139
       
139
       
 
       
      ''

     

       
140
       
140
       
 
       
        # /etc/zshenv: DO NOT EDIT -- this file has been generated automatically.

     

       
141
       
141
       
 
       
        # This file is read for all shells.

     
···

       
159
       
159
       
 
       
        fi

     

       
160
       
160
       
 
       
      '';

     

       
161
       
161
       
 
       


     

       
162
       
162
       
-
       
    environment.etc."zprofile".text =

     

       
162
       
162
       
+
       
    environment.etc.zprofile.text =

     

       
163
       
163
       
 
       
      ''

     

       
164
       
164
       
 
       
        # /etc/zprofile: DO NOT EDIT -- this file has been generated automatically.

     

       
165
       
165
       
 
       
        # This file is read for login shells.

     
···

       
178
       
178
       
 
       
        fi

     

       
179
       
179
       
 
       
      '';

     

       
180
       
180
       
 
       


     

       
181
       
181
       
-
       
    environment.etc."zshrc".text =

     

       
181
       
181
       
+
       
    environment.etc.zshrc.text =

     

       
182
       
182
       
 
       
      ''

     

       
183
       
183
       
 
       
        # /etc/zshrc: DO NOT EDIT -- this file has been generated automatically.

     

       
184
       
184
       
 
       
        # This file is read for interactive shells.

     
···

       
219
       
219
       
 
       
        fi

     

       
220
       
220
       
 
       
      '';

     

       
221
       
221
       
 
       


     

       
222
       
222
       
-
       
    environment.etc."zinputrc".source = ./zinputrc;

     

       
222
       
222
       
+
       
    environment.etc.zinputrc.source = ./zinputrc;

     

       
223
       
223
       
 
       


     

       
224
       
224
       
 
       
    environment.systemPackages = [ pkgs.zsh ]

     

       
225
       
225
       
 
       
      ++ optional cfg.enableCompletion pkgs.nix-zsh-completions;

     

···

       
378
       
378
       
 
       
        })

     

       
379
       
379
       
 
       
      );

     

       
380
       
380
       
 
       


     

       
381
       
381
       
-
       
      systemd.targets."acme-selfsigned-certificates" = mkIf cfg.preliminarySelfsigned {};

     

       
382
       
382
       
-
       
      systemd.targets."acme-certificates" = {};

     

       
381
       
381
       
+
       
      systemd.targets.acme-selfsigned-certificates = mkIf cfg.preliminarySelfsigned {};

     

       
382
       
382
       
+
       
      systemd.targets.acme-certificates = {};

     

       
383
       
383
       
 
       
    })

     

       
384
       
384
       
 
       


     

       
385
       
385
       
 
       
  ];

     

···

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
  config = mkIf cfg.enable {

     

       
26
       
26
       
 
       
    environment.systemPackages = [ sandbox ];

     

       
27
       
27
       
-
       
    security.wrappers."${sandbox.passthru.sandboxExecutableName}".source = "${sandbox}/bin/${sandbox.passthru.sandboxExecutableName}";

     

       
27
       
27
       
+
       
    security.wrappers.${sandbox.passthru.sandboxExecutableName}.source = "${sandbox}/bin/${sandbox.passthru.sandboxExecutableName}";

     

       
28
       
28
       
 
       
  };

     

       
29
       
29
       
 
       
}

     

···

       
85
       
85
       
 
       


     

       
86
       
86
       
 
       
    security.wrappers = {

     

       
87
       
87
       
 
       
      pkexec.source = "${pkgs.polkit.bin}/bin/pkexec";

     

       
88
       
88
       
-
       
      "polkit-agent-helper-1".source = "${pkgs.polkit.out}/lib/polkit-1/polkit-agent-helper-1";

     

       
88
       
88
       
+
       
      polkit-agent-helper-1.source = "${pkgs.polkit.out}/lib/polkit-1/polkit-agent-helper-1";

     

       
89
       
89
       
 
       
    };

     

       
90
       
90
       
 
       


     

       
91
       
91
       
 
       
    systemd.tmpfiles.rules = [

     

···

       
4
       
4
       
 
       


     

       
5
       
5
       
 
       
let

     

       
6
       
6
       
 
       
  cfg = config.services.prey;

     

       
7
       
7
       
-
       
  myPrey = pkgs."prey-bash-client".override {

     

       
7
       
7
       
+
       
  myPrey = pkgs.prey-bash-client.override {

     

       
8
       
8
       
 
       
    apiKey = cfg.apiKey;

     

       
9
       
9
       
 
       
    deviceKey = cfg.deviceKey;

     

       
10
       
10
       
 
       
  };

     

···

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
  programs =

     

       
9
       
9
       
 
       
    (lib.mapAttrsToList

     

       
10
       
10
       
-
       
      (n: v: (if v ? "program" then v else v // {program=n;}))

     

       
10
       
10
       
+
       
      (n: v: (if v ? program then v else v // {program=n;}))

     

       
11
       
11
       
 
       
      wrappers);

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
  securityWrapper = pkgs.stdenv.mkDerivation {

     
···

       
74
       
74
       
 
       


     

       
75
       
75
       
 
       
  mkWrappedPrograms =

     

       
76
       
76
       
 
       
    builtins.map

     

       
77
       
77
       
-
       
      (s: if (s ? "capabilities")

     

       
77
       
77
       
+
       
      (s: if (s ? capabilities)

     

       
78
       
78
       
 
       
          then mkSetcapProgram

     

       
79
       
79
       
 
       
                 ({ owner = "root";

     

       
80
       
80
       
 
       
                    group = "root";

     

       
81
       
81
       
 
       
                  } // s)

     

       
82
       
82
       
 
       
          else if

     

       
83
       
83
       
-
       
             (s ? "setuid" && s.setuid) ||

     

       
84
       
84
       
-
       
             (s ? "setgid" && s.setgid) ||

     

       
85
       
85
       
-
       
             (s ? "permissions")

     

       
83
       
83
       
+
       
             (s ? setuid && s.setuid) ||

     

       
84
       
84
       
+
       
             (s ? setgid && s.setgid) ||

     

       
85
       
85
       
+
       
             (s ? permissions)

     

       
86
       
86
       
 
       
          then mkSetuidProgram s

     

       
87
       
87
       
 
       
          else mkSetuidProgram

     

       
88
       
88
       
 
       
                 ({ owner  = "root";

     

···

       
99
       
99
       
 
       


     

       
100
       
100
       
 
       
    boot.kernelModules = optional config.sound.enableOSSEmulation "snd_pcm_oss";

     

       
101
       
101
       
 
       


     

       
102
       
102
       
-
       
    systemd.services."alsa-store" =

     

       
102
       
102
       
+
       
    systemd.services.alsa-store =

     

       
103
       
103
       
 
       
      { description = "Store Sound Card State";

     

       
104
       
104
       
 
       
        wantedBy = [ "multi-user.target" ];

     

       
105
       
105
       
 
       
        unitConfig.RequiresMountsFor = "/var/lib/alsa";

     

···

       
103
       
103
       
 
       
    }];

     

       
104
       
104
       
 
       


     

       
105
       
105
       
 
       
    systemd = {

     

       
106
       
106
       
-
       
      timers."mysql-backup" = {

     

       
106
       
106
       
+
       
      timers.mysql-backup = {

     

       
107
       
107
       
 
       
        description = "Mysql backup timer";

     

       
108
       
108
       
 
       
        wantedBy = [ "timers.target" ];

     

       
109
       
109
       
 
       
        timerConfig = {

     
···

       
112
       
112
       
 
       
          Unit = "mysql-backup.service";

     

       
113
       
113
       
 
       
        };

     

       
114
       
114
       
 
       
      };

     

       
115
       
115
       
-
       
      services."mysql-backup" = {

     

       
115
       
115
       
+
       
      services.mysql-backup = {

     

       
116
       
116
       
 
       
        description = "Mysql backup service";

     

       
117
       
117
       
 
       
        enable = true;

     

       
118
       
118
       
 
       
        serviceConfig = {

     

···

       
78
       
78
       
 
       
  config = mkIf cfg.enable {

     

       
79
       
79
       
 
       
    inherit assertions;

     

       
80
       
80
       
 
       
    programs.tsmClient.enable = true;

     

       
81
       
81
       
-
       
    programs.tsmClient.servers."${cfg.servername}".passwdDir =

     

       
81
       
81
       
+
       
    programs.tsmClient.servers.${cfg.servername}.passwdDir =

     

       
82
       
82
       
 
       
      mkDefault "/var/lib/tsm-backup/password";

     

       
83
       
83
       
 
       
    systemd.services.tsm-backup = {

     

       
84
       
84
       
 
       
      description = "IBM Spectrum Protect (Tivoli Storage Manager) Backup";

     

···

       
60
       
60
       
 
       
      pkgs.lz4

     

       
61
       
61
       
 
       
    ];

     

       
62
       
62
       
 
       


     

       
63
       
63
       
-
       
    systemd.services."zfs-replication" = {

     

       
63
       
63
       
+
       
    systemd.services.zfs-replication = {

     

       
64
       
64
       
 
       
      after = [

     

       
65
       
65
       
 
       
        "zfs-snapshot-daily.service"

     

       
66
       
66
       
 
       
        "zfs-snapshot-frequent.service"

     

···

       
361
       
361
       
 
       
    environment.systemPackages = [ pkgs.znapzend ];

     

       
362
       
362
       
 
       


     

       
363
       
363
       
 
       
    systemd.services = {

     

       
364
       
364
       
-
       
      "znapzend" = {

     

       
364
       
364
       
+
       
      znapzend = {

     

       
365
       
365
       
 
       
        description = "ZnapZend - ZFS Backup System";

     

       
366
       
366
       
 
       
        wantedBy    = [ "zfs.target" ];

     

       
367
       
367
       
 
       
        after       = [ "zfs.target" ];

     

···

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
  config = mkMerge [

     

       
26
       
26
       
 
       
    (mkIf cfg.hdfs.namenode.enabled {

     

       
27
       
27
       
-
       
      systemd.services."hdfs-namenode" = {

     

       
27
       
27
       
+
       
      systemd.services.hdfs-namenode = {

     

       
28
       
28
       
 
       
        description = "Hadoop HDFS NameNode";

     

       
29
       
29
       
 
       
        wantedBy = [ "multi-user.target" ];

     

       
30
       
30
       
 
       


     
···

       
44
       
44
       
 
       
      };

     

       
45
       
45
       
 
       
    })

     

       
46
       
46
       
 
       
    (mkIf cfg.hdfs.datanode.enabled {

     

       
47
       
47
       
-
       
      systemd.services."hdfs-datanode" = {

     

       
47
       
47
       
+
       
      systemd.services.hdfs-datanode = {

     

       
48
       
48
       
 
       
        description = "Hadoop HDFS DataNode";

     

       
49
       
49
       
 
       
        wantedBy = [ "multi-user.target" ];

     

       
50
       
50
       
 
       


     

···

       
35
       
35
       
 
       
    })

     

       
36
       
36
       
 
       


     

       
37
       
37
       
 
       
    (mkIf cfg.yarn.resourcemanager.enabled {

     

       
38
       
38
       
-
       
      systemd.services."yarn-resourcemanager" = {

     

       
38
       
38
       
+
       
      systemd.services.yarn-resourcemanager = {

     

       
39
       
39
       
 
       
        description = "Hadoop YARN ResourceManager";

     

       
40
       
40
       
 
       
        wantedBy = [ "multi-user.target" ];

     

       
41
       
41
       
 
       


     
···

       
53
       
53
       
 
       
    })

     

       
54
       
54
       
 
       


     

       
55
       
55
       
 
       
    (mkIf cfg.yarn.nodemanager.enabled {

     

       
56
       
56
       
-
       
      systemd.services."yarn-nodemanager" = {

     

       
56
       
56
       
+
       
      systemd.services.yarn-nodemanager = {

     

       
57
       
57
       
 
       
        description = "Hadoop YARN NodeManager";

     

       
58
       
58
       
 
       
        wantedBy = [ "multi-user.target" ];

     

       
59
       
59
       
 
       


     

···

       
74
       
74
       
 
       
        spec = {

     

       
75
       
75
       
 
       
          replicas = 1;

     

       
76
       
76
       
 
       
          revisionHistoryLimit = 10;

     

       
77
       
77
       
-
       
          selector.matchLabels."k8s-app" = "kubernetes-dashboard";

     

       
77
       
77
       
+
       
          selector.matchLabels.k8s-app = "kubernetes-dashboard";

     

       
78
       
78
       
 
       
          template = {

     

       
79
       
79
       
 
       
            metadata = {

     

       
80
       
80
       
 
       
              labels = {

     

···

       
73
       
73
       
 
       
        metadata = {

     

       
74
       
74
       
 
       
          labels = {

     

       
75
       
75
       
 
       
            "addonmanager.kubernetes.io/mode" = "Reconcile";

     

       
76
       
76
       
-
       
            "k8s-app" = "kube-dns";

     

       
76
       
76
       
+
       
            k8s-app = "kube-dns";

     

       
77
       
77
       
 
       
            "kubernetes.io/cluster-service" = "true";

     

       
78
       
78
       
 
       
            "kubernetes.io/bootstrapping" = "rbac-defaults";

     

       
79
       
79
       
 
       
          };

     
···

       
102
       
102
       
 
       
          };

     

       
103
       
103
       
 
       
          labels = {

     

       
104
       
104
       
 
       
            "addonmanager.kubernetes.io/mode" = "Reconcile";

     

       
105
       
105
       
-
       
            "k8s-app" = "kube-dns";

     

       
105
       
105
       
+
       
            k8s-app = "kube-dns";

     

       
106
       
106
       
 
       
            "kubernetes.io/cluster-service" = "true";

     

       
107
       
107
       
 
       
            "kubernetes.io/bootstrapping" = "rbac-defaults";

     

       
108
       
108
       
 
       
          };

     
···

       
130
       
130
       
 
       
        metadata = {

     

       
131
       
131
       
 
       
          labels = {

     

       
132
       
132
       
 
       
            "addonmanager.kubernetes.io/mode" = "Reconcile";

     

       
133
       
133
       
-
       
            "k8s-app" = "kube-dns";

     

       
133
       
133
       
+
       
            k8s-app = "kube-dns";

     

       
134
       
134
       
 
       
            "kubernetes.io/cluster-service" = "true";

     

       
135
       
135
       
 
       
          };

     

       
136
       
136
       
 
       
          name = "coredns";

     
···

       
144
       
144
       
 
       
        metadata = {

     

       
145
       
145
       
 
       
          labels = {

     

       
146
       
146
       
 
       
            "addonmanager.kubernetes.io/mode" = cfg.reconcileMode;

     

       
147
       
147
       
-
       
            "k8s-app" = "kube-dns";

     

       
147
       
147
       
+
       
            k8s-app = "kube-dns";

     

       
148
       
148
       
 
       
            "kubernetes.io/cluster-service" = "true";

     

       
149
       
149
       
 
       
          };

     

       
150
       
150
       
 
       
          name = "coredns";

     
···

       
175
       
175
       
 
       
        metadata = {

     

       
176
       
176
       
 
       
          labels = {

     

       
177
       
177
       
 
       
            "addonmanager.kubernetes.io/mode" = cfg.reconcileMode;

     

       
178
       
178
       
-
       
            "k8s-app" = "kube-dns";

     

       
178
       
178
       
+
       
            k8s-app = "kube-dns";

     

       
179
       
179
       
 
       
            "kubernetes.io/cluster-service" = "true";

     

       
180
       
180
       
 
       
            "kubernetes.io/name" = "CoreDNS";

     

       
181
       
181
       
 
       
          };

     
···

       
301
       
301
       
 
       
          };

     

       
302
       
302
       
 
       
          labels = {

     

       
303
       
303
       
 
       
            "addonmanager.kubernetes.io/mode" = "Reconcile";

     

       
304
       
304
       
-
       
            "k8s-app" = "kube-dns";

     

       
304
       
304
       
+
       
            k8s-app = "kube-dns";

     

       
305
       
305
       
 
       
            "kubernetes.io/cluster-service" = "true";

     

       
306
       
306
       
 
       
            "kubernetes.io/name" = "CoreDNS";

     

       
307
       
307
       
 
       
          };

     

···

       
397
       
397
       
 
       
        }

     

       
398
       
398
       
 
       
      ];

     

       
399
       
399
       
 
       
    users = mkIf (cfg.user == defaultUser) {

     

       
400
       
400
       
-
       
      extraUsers."${defaultUser}" =

     

       
400
       
400
       
+
       
      extraUsers.${defaultUser} =

     

       
401
       
401
       
 
       
        {  group = cfg.group;

     

       
402
       
402
       
 
       
           home = cfg.homeDir;

     

       
403
       
403
       
 
       
           createHome = true;

     

       
404
       
404
       
 
       
           uid = config.ids.uids.cassandra;

     

       
405
       
405
       
 
       
           description = "Cassandra service user";

     

       
406
       
406
       
 
       
        };

     

       
407
       
407
       
-
       
      extraGroups."${defaultUser}".gid = config.ids.gids.cassandra;

     

       
407
       
407
       
+
       
      extraGroups.${defaultUser}.gid = config.ids.gids.cassandra;

     

       
408
       
408
       
 
       
    };

     

       
409
       
409
       
 
       


     

       
410
       
410
       
 
       
    systemd.services.cassandra =

     

···

       
59
       
59
       
 
       
      type = types.attrsOf types.str;

     

       
60
       
60
       
 
       
      default = {};

     

       
61
       
61
       
 
       
      example = {

     

       
62
       
62
       
-
       
        "nuc-server"  = "hostaddr=192.168.0.100 port=5432 dbname=postgres";

     

       
63
       
63
       
-
       
        "mini-server" = "hostaddr=127.0.0.1 port=5432 dbname=postgres sslmode=require";

     

       
62
       
62
       
+
       
        nuc-server  = "hostaddr=192.168.0.100 port=5432 dbname=postgres";

     

       
63
       
63
       
+
       
        mini-server = "hostaddr=127.0.0.1 port=5432 dbname=postgres sslmode=require";

     

       
64
       
64
       
 
       
      };

     

       
65
       
65
       
 
       
      description = ''

     

       
66
       
66
       
 
       
        pgmanage requires at least one PostgreSQL server be defined.

     
···

       
192
       
192
       
 
       
      };

     

       
193
       
193
       
 
       
    };

     

       
194
       
194
       
 
       
    users = {

     

       
195
       
195
       
-
       
      users."${pgmanage}" = {

     

       
195
       
195
       
+
       
      users.${pgmanage} = {

     

       
196
       
196
       
 
       
        name  = pgmanage;

     

       
197
       
197
       
 
       
        group = pgmanage;

     

       
198
       
198
       
 
       
        home  = cfg.sqlRoot;

     

       
199
       
199
       
 
       
        createHome = true;

     

       
200
       
200
       
 
       
      };

     

       
201
       
201
       
-
       
      groups."${pgmanage}" = {

     

       
201
       
201
       
+
       
      groups.${pgmanage} = {

     

       
202
       
202
       
 
       
        name = pgmanage;

     

       
203
       
203
       
 
       
      };

     

       
204
       
204
       
 
       
    };

     

···

       
202
       
202
       
 
       
    ];

     

       
203
       
203
       
 
       


     

       
204
       
204
       
 
       
    # restart geoclue service when the configuration changes

     

       
205
       
205
       
-
       
    systemd.services."geoclue".restartTriggers = [

     

       
205
       
205
       
+
       
    systemd.services.geoclue.restartTriggers = [

     

       
206
       
206
       
 
       
      config.environment.etc."geoclue/geoclue.conf".source

     

       
207
       
207
       
 
       
    ];

     

       
208
       
208
       
 
       


     

       
209
       
209
       
 
       
    # this needs to run as a user service, since it's associated with the

     

       
210
       
210
       
 
       
    # user who is making the requests

     

       
211
       
211
       
 
       
    systemd.user.services = mkIf cfg.enableDemoAgent {

     

       
212
       
212
       
-
       
      "geoclue-agent" = {

     

       
212
       
212
       
+
       
      geoclue-agent = {

     

       
213
       
213
       
 
       
        description = "Geoclue agent";

     

       
214
       
214
       
 
       
        script = "${package}/libexec/geoclue-2.0/demos/agent";

     

       
215
       
215
       
 
       
        # this should really be `partOf = [ "geoclue.service" ]`, but

     
···

       
219
       
219
       
 
       
      };

     

       
220
       
220
       
 
       
    };

     

       
221
       
221
       
 
       


     

       
222
       
222
       
-
       
    services.geoclue2.appConfig."epiphany" = {

     

       
222
       
222
       
+
       
    services.geoclue2.appConfig.epiphany = {

     

       
223
       
223
       
 
       
      isAllowed = true;

     

       
224
       
224
       
 
       
      isSystem = false;

     

       
225
       
225
       
 
       
    };

     

       
226
       
226
       
 
       


     

       
227
       
227
       
-
       
    services.geoclue2.appConfig."firefox" = {

     

       
227
       
227
       
+
       
    services.geoclue2.appConfig.firefox = {

     

       
228
       
228
       
 
       
      isAllowed = true;

     

       
229
       
229
       
 
       
      isSystem = false;

     

       
230
       
230
       
 
       
    };

     

···

       
4
       
4
       
 
       


     

       
5
       
5
       
 
       
let

     

       
6
       
6
       
 
       
  cfg   = config.services.terraria;

     

       
7
       
7
       
-
       
  worldSizeMap = { "small" = 1; "medium" = 2; "large" = 3; };

     

       
7
       
7
       
+
       
  worldSizeMap = { small = 1; medium = 2; large = 3; };

     

       
8
       
8
       
 
       
  valFlag = name: val: optionalString (val != null) "-${name} \"${escape ["\\" "\""] (toString val)}\"";

     

       
9
       
9
       
 
       
  boolFlag = name: val: optionalString val "-${name}";

     

       
10
       
10
       
 
       
  flags = [ 

     

···

       
124
       
124
       
 
       
      environment.sessionVariables = env;

     

       
125
       
125
       
 
       
      services.udev.packages = backends;

     

       
126
       
126
       
 
       


     

       
127
       
127
       
-
       
      users.groups."scanner".gid = config.ids.gids.scanner;

     

       
127
       
127
       
+
       
      users.groups.scanner.gid = config.ids.gids.scanner;

     

       
128
       
128
       
 
       
    })

     

       
129
       
129
       
 
       


     

       
130
       
130
       
 
       
    (mkIf config.services.saned.enable {

     
···

       
152
       
152
       
 
       
        };

     

       
153
       
153
       
 
       
      };

     

       
154
       
154
       
 
       


     

       
155
       
155
       
-
       
      users.users."scanner" = {

     

       
155
       
155
       
+
       
      users.users.scanner = {

     

       
156
       
156
       
 
       
        uid = config.ids.uids.scanner;

     

       
157
       
157
       
 
       
        group = "scanner";

     

       
158
       
158
       
 
       
      };

     

···

       
20
       
20
       
 
       
  config = mkIf cfg.enable {

     

       
21
       
21
       
 
       
    systemd.packages = [ pkgs.throttled ];

     

       
22
       
22
       
 
       
    # The upstream package has this in Install, but that's not enough, see the NixOS manual

     

       
23
       
23
       
-
       
    systemd.services."lenovo_fix".wantedBy = [ "multi-user.target" ];

     

       
23
       
23
       
+
       
    systemd.services.lenovo_fix.wantedBy = [ "multi-user.target" ];

     

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
    environment.etc."lenovo_fix.conf".source =

     

       
26
       
26
       
 
       
      if cfg.extraConfig != ""

     

···

       
60
       
60
       
 
       
    powerManagement.cpufreq.max = null;

     

       
61
       
61
       
 
       
    powerManagement.cpufreq.min = null;

     

       
62
       
62
       
 
       


     

       
63
       
63
       
-
       
    systemd.sockets."systemd-rfkill".enable = false;

     

       
63
       
63
       
+
       
    systemd.sockets.systemd-rfkill.enable = false;

     

       
64
       
64
       
 
       


     

       
65
       
65
       
 
       
    systemd.services = {

     

       
66
       
66
       
 
       
      "systemd-rfkill@".enable = false;

     

       
67
       
67
       
-
       
      "systemd-rfkill".enable = false;

     

       
67
       
67
       
+
       
      systemd-rfkill.enable = false;

     

       
68
       
68
       
 
       


     

       
69
       
69
       
 
       
      tlp = {

     

       
70
       
70
       
 
       
        description = "TLP system startup/shutdown";

     

···

       
23
       
23
       
 
       
  flags = "-r ${rulesDir} -c ${configFile} -L ${logFiles} -${levelFlag} -m ${cfg.mailTo}";

     

       
24
       
24
       
 
       


     

       
25
       
25
       
 
       
  levelFlag = getAttrFromPath [cfg.level]

     

       
26
       
26
       
-
       
    { "paranoid"    = "p";

     

       
27
       
27
       
-
       
      "server"      = "s";

     

       
28
       
28
       
-
       
      "workstation" = "w";

     

       
26
       
26
       
+
       
    { paranoid    = "p";

     

       
27
       
27
       
+
       
      server      = "s";

     

       
28
       
28
       
+
       
      workstation = "w";

     

       
29
       
29
       
 
       
    };

     

       
30
       
30
       
 
       


     

       
31
       
31
       
 
       
  cronJob = ''

     

···

       
137
       
137
       
 
       
          ${pkgs.postfix}/bin/postmap ${stateDir}/transports

     

       
138
       
138
       
 
       
      '';

     

       
139
       
139
       
 
       


     

       
140
       
140
       
-
       
    systemd.services."mlmmj-maintd" = {

     

       
140
       
140
       
+
       
    systemd.services.mlmmj-maintd = {

     

       
141
       
141
       
 
       
      description = "mlmmj maintenance daemon";

     

       
142
       
142
       
 
       
      serviceConfig = {

     

       
143
       
143
       
 
       
        User = cfg.user;

     
···

       
146
       
146
       
 
       
      };

     

       
147
       
147
       
 
       
    };

     

       
148
       
148
       
 
       


     

       
149
       
149
       
-
       
    systemd.timers."mlmmj-maintd" = {

     

       
149
       
149
       
+
       
    systemd.timers.mlmmj-maintd = {

     

       
150
       
150
       
 
       
      description = "mlmmj maintenance timer";

     

       
151
       
151
       
 
       
      timerConfig.OnUnitActiveSec = cfg.maintInterval;

     

       
152
       
152
       
 
       
      wantedBy = [ "timers.target" ];

     

···

       
40
       
40
       
 
       
      systemPackages = [ pkgs.pfixtools ];

     

       
41
       
41
       
 
       
    };

     

       
42
       
42
       
 
       


     

       
43
       
43
       
-
       
    systemd.services."pfix-srsd" = {

     

       
43
       
43
       
+
       
    systemd.services.pfix-srsd = {

     

       
44
       
44
       
 
       
      description = "Postfix sender rewriting scheme daemon";

     

       
45
       
45
       
 
       
      before = [ "postfix.service" ];

     

       
46
       
46
       
 
       
      #note that we use requires rather than wants because postfix

     

···

       
877
       
877
       
 
       
    }

     

       
878
       
878
       
 
       


     

       
879
       
879
       
 
       
    (mkIf haveAliases {

     

       
880
       
880
       
-
       
      services.postfix.aliasFiles."aliases" = aliasesFile;

     

       
880
       
880
       
+
       
      services.postfix.aliasFiles.aliases = aliasesFile;

     

       
881
       
881
       
 
       
    })

     

       
882
       
882
       
 
       
    (mkIf haveTransport {

     

       
883
       
883
       
-
       
      services.postfix.mapFiles."transport" = transportFile;

     

       
883
       
883
       
+
       
      services.postfix.mapFiles.transport = transportFile;

     

       
884
       
884
       
 
       
    })

     

       
885
       
885
       
 
       
    (mkIf haveVirtual {

     

       
886
       
886
       
-
       
      services.postfix.mapFiles."virtual" = virtualFile;

     

       
886
       
886
       
+
       
      services.postfix.mapFiles.virtual = virtualFile;

     

       
887
       
887
       
 
       
    })

     

       
888
       
888
       
 
       
    (mkIf haveLocalRecipients {

     

       
889
       
889
       
-
       
      services.postfix.mapFiles."local_recipients" = localRecipientMapFile;

     

       
889
       
889
       
+
       
      services.postfix.mapFiles.local_recipients = localRecipientMapFile;

     

       
890
       
890
       
 
       
    })

     

       
891
       
891
       
 
       
    (mkIf cfg.enableHeaderChecks {

     

       
892
       
892
       
-
       
      services.postfix.mapFiles."header_checks" = headerChecksFile;

     

       
892
       
892
       
+
       
      services.postfix.mapFiles.header_checks = headerChecksFile;

     

       
893
       
893
       
 
       
    })

     

       
894
       
894
       
 
       
    (mkIf (cfg.dnsBlacklists != []) {

     

       
895
       
895
       
-
       
      services.postfix.mapFiles."client_access" = checkClientAccessFile;

     

       
895
       
895
       
+
       
      services.postfix.mapFiles.client_access = checkClientAccessFile;

     

       
896
       
896
       
 
       
    })

     

       
897
       
897
       
 
       
  ]);

     

       
898
       
898
       
 
       
}

     

···

       
7
       
7
       
 
       
  natural = with types; addCheck int (x: x >= 0);

     

       
8
       
8
       
 
       
  natural' = with types; addCheck int (x: x > 0);

     

       
9
       
9
       
 
       


     

       
10
       
10
       
-
       
  socket = with types; addCheck (either (submodule unixSocket) (submodule inetSocket)) (x: x ? "path" || x ? "port");

     

       
10
       
10
       
+
       
  socket = with types; addCheck (either (submodule unixSocket) (submodule inetSocket)) (x: x ? path || x ? port);

     

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
  inetSocket = with types; {

     

       
13
       
13
       
 
       
    options = {

     
···

       
151
       
151
       
 
       
    };

     

       
152
       
152
       
 
       


     

       
153
       
153
       
 
       
    systemd.services.postgrey = let

     

       
154
       
154
       
-
       
      bind-flag = if cfg.socket ? "path" then

     

       
154
       
154
       
+
       
      bind-flag = if cfg.socket ? path then

     

       
155
       
155
       
 
       
        ''--unix=${cfg.socket.path} --socketmode=${cfg.socket.mode}''

     

       
156
       
156
       
 
       
      else

     

       
157
       
157
       
 
       
        ''--inet=${optionalString (cfg.socket.addr != null) (cfg.socket.addr + ":")}${toString cfg.socket.port}'';

     

···

       
387
       
387
       
 
       
      gid = config.ids.gids.rspamd;

     

       
388
       
388
       
 
       
    };

     

       
389
       
389
       
 
       


     

       
390
       
390
       
-
       
    environment.etc."rspamd".source = rspamdDir;

     

       
390
       
390
       
+
       
    environment.etc.rspamd.source = rspamdDir;

     

       
391
       
391
       
 
       


     

       
392
       
392
       
 
       
    systemd.services.rspamd = {

     

       
393
       
393
       
 
       
      description = "Rspamd Service";

     

···

       
138
       
138
       
 
       


     

       
139
       
139
       
 
       
    services.nginx = mkIf (cfg.virtualHost != null) {

     

       
140
       
140
       
 
       
      enable = true;

     

       
141
       
141
       
-
       
      virtualHosts."${cfg.virtualHost}" = {

     

       
142
       
142
       
-
       
        locations."${cfg.contextPath}".proxyPass = "http://${cfg.listenAddress}:${toString cfg.port}";

     

       
141
       
141
       
+
       
      virtualHosts.${cfg.virtualHost} = {

     

       
142
       
142
       
+
       
        locations.${cfg.contextPath}.proxyPass = "http://${cfg.listenAddress}:${toString cfg.port}";

     

       
143
       
143
       
 
       
      };

     

       
144
       
144
       
 
       
    };

     

       
145
       
145
       
 
       


     

···

       
8
       
8
       
 
       
  printProperties = properties:

     

       
9
       
9
       
 
       
    concatMapStrings (propertyName:

     

       
10
       
10
       
 
       
      let

     

       
11
       
11
       
-
       
        property = properties."${propertyName}";

     

       
11
       
11
       
+
       
        property = properties.${propertyName};

     

       
12
       
12
       
 
       
      in

     

       
13
       
13
       
-
       
      if isList property then "${propertyName}=(${lib.concatMapStrings (elem: "\"${toString elem}\" ") (properties."${propertyName}")})\n"

     

       
13
       
13
       
+
       
      if isList property then "${propertyName}=(${lib.concatMapStrings (elem: "\"${toString elem}\" ") (properties.${propertyName})})\n"

     

       
14
       
14
       
 
       
      else "${propertyName}=\"${toString property}\"\n"

     

       
15
       
15
       
 
       
    ) (builtins.attrNames properties);

     

       
16
       
16
       
 
       


     
···

       
31
       
31
       
 
       


     

       
32
       
32
       
 
       
      ${concatMapStrings (containerName:

     

       
33
       
33
       
 
       
        let

     

       
34
       
34
       
-
       
          containerProperties = cfg.containers."${containerName}";

     

       
34
       
34
       
+
       
          containerProperties = cfg.containers.${containerName};

     

       
35
       
35
       
 
       
        in

     

       
36
       
36
       
 
       
        ''

     

       
37
       
37
       
 
       
          cat > ${containerName} <<EOF

     
···

       
49
       
49
       
 
       


     

       
50
       
50
       
 
       
      ${concatMapStrings (componentName:

     

       
51
       
51
       
 
       
        let

     

       
52
       
52
       
-
       
          component = cfg.components."${containerName}"."${componentName}";

     

       
52
       
52
       
+
       
          component = cfg.components.${containerName}.${componentName};

     

       
53
       
53
       
 
       
        in

     

       
54
       
54
       
 
       
        "ln -s ${component} ${containerName}/${componentName}\n"

     

       
55
       
55
       
-
       
      ) (builtins.attrNames (cfg.components."${containerName}" or {}))}

     

       
55
       
55
       
+
       
      ) (builtins.attrNames (cfg.components.${containerName} or {}))}

     

       
56
       
56
       
 
       
    '';

     

       
57
       
57
       
 
       


     

       
58
       
58
       
 
       
  componentsDir = pkgs.stdenv.mkDerivation {

     

···

       
58
       
58
       
 
       
    };

     

       
59
       
59
       
 
       
  };

     

       
60
       
60
       
 
       
  cliOptions = concatStringsSep " " (mapAttrsToList (k: v: "--${k} ${v}") (filterAttrs (k: v: v != null && v != "") (cliOptionsCommon //

     

       
61
       
61
       
-
       
               cliOptionsPerConfig."${cfg.configType}" //

     

       
61
       
61
       
+
       
               cliOptionsPerConfig.${cfg.configType} //

     

       
62
       
62
       
 
       
               s3CommonOptions //

     

       
63
       
63
       
 
       
               optionalAttrs cfg.s3Backup { s3backup = "true"; } //

     

       
64
       
64
       
 
       
               optionalAttrs cfg.fileSystemBackup { filesystembackup = "true"; }

     

···

       
147
       
147
       
 
       
      group           = cfg.group;

     

       
148
       
148
       
 
       
      useDefaultShell = true;

     

       
149
       
149
       
 
       
    };

     

       
150
       
150
       
-
       
    users.groups."${cfg.group}".gid = config.ids.gids.gitolite;

     

       
150
       
150
       
+
       
    users.groups.${cfg.group}.gid = config.ids.gids.gitolite;

     

       
151
       
151
       
 
       


     

       
152
       
152
       
 
       
    systemd.tmpfiles.rules = [

     

       
153
       
153
       
 
       
      "d '${cfg.dataDir}' 0750 ${cfg.user} ${cfg.group} - -"

     
···

       
157
       
157
       
 
       
      "Z ${cfg.dataDir} 0750 ${cfg.user} ${cfg.group} - -"

     

       
158
       
158
       
 
       
    ];

     

       
159
       
159
       
 
       


     

       
160
       
160
       
-
       
    systemd.services."gitolite-init" = {

     

       
160
       
160
       
+
       
    systemd.services.gitolite-init = {

     

       
161
       
161
       
 
       
      description = "Gitolite initialization";

     

       
162
       
162
       
 
       
      wantedBy    = [ "multi-user.target" ];

     

       
163
       
163
       
 
       
      unitConfig.RequiresMountsFor = cfg.dataDir;

     

···

       
374
       
374
       
 
       
            user = cfg.database_user;

     

       
375
       
375
       
 
       
            database = cfg.database_name;

     

       
376
       
376
       
 
       
          };

     

       
377
       
377
       
-
       
        }."${cfg.database_type}";

     

       
377
       
377
       
+
       
        }.${cfg.database_type};

     

       
378
       
378
       
 
       
        description = ''

     

       
379
       
379
       
 
       
          Arguments to pass to the engine.

     

       
380
       
380
       
 
       
        '';

     

···

       
495
       
495
       
 
       
      optionals (pkgs.stdenv.isx86_64 && pkgs.hostPlatform.platform ? gcc.arch) (

     

       
496
       
496
       
 
       
        # a x86_64 builder can run code for `platform.gcc.arch` and minor architectures:

     

       
497
       
497
       
 
       
        [ "gccarch-${pkgs.hostPlatform.platform.gcc.arch}" ] ++ {

     

       
498
       
498
       
-
       
          "sandybridge"    = [ "gccarch-westmere" ];

     

       
499
       
499
       
-
       
          "ivybridge"      = [ "gccarch-westmere" "gccarch-sandybridge" ];

     

       
500
       
500
       
-
       
          "haswell"        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" ];

     

       
501
       
501
       
-
       
          "broadwell"      = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" ];

     

       
502
       
502
       
-
       
          "skylake"        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" ];

     

       
503
       
503
       
-
       
          "skylake-avx512" = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" "gccarch-skylake" ];

     

       
498
       
498
       
+
       
          sandybridge    = [ "gccarch-westmere" ];

     

       
499
       
499
       
+
       
          ivybridge      = [ "gccarch-westmere" "gccarch-sandybridge" ];

     

       
500
       
500
       
+
       
          haswell        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" ];

     

       
501
       
501
       
+
       
          broadwell      = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" ];

     

       
502
       
502
       
+
       
          skylake        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" ];

     

       
503
       
503
       
+
       
          skylake-avx512 = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" "gccarch-skylake" ];

     

       
504
       
504
       
 
       
        }.${pkgs.hostPlatform.platform.gcc.arch} or []

     

       
505
       
505
       
 
       
      )

     

       
506
       
506
       
 
       
    );

     

···

       
54
       
54
       
 
       
    (mkIf (cfg.showManual && cfgd.enable && cfgd.nixos.enable) {

     

       
55
       
55
       
 
       
      boot.extraTTYs = [ "tty${toString cfg.ttyNumber}" ];

     

       
56
       
56
       
 
       


     

       
57
       
57
       
-
       
      systemd.services."nixos-manual" = {

     

       
57
       
57
       
+
       
      systemd.services.nixos-manual = {

     

       
58
       
58
       
 
       
        description = "NixOS Manual";

     

       
59
       
59
       
 
       
        wantedBy = [ "multi-user.target" ];

     

       
60
       
60
       
 
       
        serviceConfig = {

     

···

       
44
       
44
       
 
       
    configs = mkOption {

     

       
45
       
45
       
 
       
      default = { };

     

       
46
       
46
       
 
       
      example = literalExample {

     

       
47
       
47
       
-
       
        "home" = {

     

       
47
       
47
       
+
       
        home = {

     

       
48
       
48
       
 
       
          subvolume = "/home";

     

       
49
       
49
       
 
       
          extraConfig = ''

     

       
50
       
50
       
 
       
            ALLOW_USERS="alice"

     

···

       
83
       
83
       
 
       


     

       
84
       
84
       
 
       
  config = mkMerge [

     

       
85
       
85
       
 
       
    (mkIf cfgC.enable {

     

       
86
       
86
       
-
       
      systemd.user.services."synergy-client" = {

     

       
86
       
86
       
+
       
      systemd.user.services.synergy-client = {

     

       
87
       
87
       
 
       
        after = [ "network.target" "graphical-session.target" ];

     

       
88
       
88
       
 
       
        description = "Synergy client";

     

       
89
       
89
       
 
       
        wantedBy = optional cfgC.autoStart "graphical-session.target";

     
···

       
93
       
93
       
 
       
      };

     

       
94
       
94
       
 
       
    })

     

       
95
       
95
       
 
       
    (mkIf cfgS.enable {

     

       
96
       
96
       
-
       
      systemd.user.services."synergy-server" = {

     

       
96
       
96
       
+
       
      systemd.user.services.synergy-server = {

     

       
97
       
97
       
 
       
        after = [ "network.target" "graphical-session.target" ];

     

       
98
       
98
       
 
       
        description = "Synergy server";

     

       
99
       
99
       
 
       
        wantedBy = optional cfgS.autoStart "graphical-session.target";

     

···

       
10
       
10
       
 
       
  group = {

     

       
11
       
11
       
 
       
    nginx = config.services.nginx.group;

     

       
12
       
12
       
 
       
    none  = user;

     

       
13
       
13
       
-
       
  }."${cfg.webserver}";

     

       
13
       
13
       
+
       
  }.${cfg.webserver};

     

       
14
       
14
       
 
       


     

       
15
       
15
       
 
       
  useNginx = cfg.webserver == "nginx";

     

       
16
       
16
       
 
       


     
···

       
223
       
223
       
 
       
      nginx = lib.mkIf useNginx {

     

       
224
       
224
       
 
       
        enable = true;

     

       
225
       
225
       
 
       
        virtualHosts = {

     

       
226
       
226
       
-
       
          "${cfg.hostname}" = {

     

       
226
       
226
       
+
       
          ${cfg.hostname} = {

     

       
227
       
227
       
 
       
            default = true;

     

       
228
       
228
       
 
       
            root = "${pkg}/share/zoneminder/www";

     

       
229
       
229
       
 
       
            listen = [ { addr = "0.0.0.0"; inherit (cfg) port; } ];

     
···

       
357
       
357
       
 
       
      };

     

       
358
       
358
       
 
       
    };

     

       
359
       
359
       
 
       


     

       
360
       
360
       
-
       
    users.groups."${user}" = {

     

       
360
       
360
       
+
       
    users.groups.${user} = {

     

       
361
       
361
       
 
       
      gid = config.ids.gids.zoneminder;

     

       
362
       
362
       
 
       
    };

     

       
363
       
363
       
 
       


     

       
364
       
364
       
-
       
    users.users."${user}" = {

     

       
364
       
364
       
+
       
    users.users.${user} = {

     

       
365
       
365
       
 
       
      uid = config.ids.uids.zoneminder;

     

       
366
       
366
       
 
       
      group = user;

     

       
367
       
367
       
 
       
      inherit home;