commit b4674b39c1928f05118ea0c1c4fb8ab66190edd6 · pyrox.dev/nixpkgs

+2 -3

nixos/modules/hardware/brillo.nix

···

       8
       8
        
         options = {

     

       9
       9
        
           hardware.brillo = {

     

       10
       10
        
             enable = mkEnableOption (lib.mdDoc ''

     

       11
       11
       -
               Enable brillo in userspace.

     

       12
       12
       -
               This will allow brightness control from users in the video group.

     

       11
       11
       +
               brillo in userspace.

     

       12
       12
       +
               This will allow brightness control from users in the video group

     

       13
       13
        
             '');

     

       14
       14
        
           };

     

       15
       15
        
         };

     

       16
       16
       -
       

     

       17
       16
        
       

     

       18
       17
        
         config = mkIf cfg.enable {

     

       19
       18
        
           services.udev.packages = [ pkgs.brillo ];

+1 -1

nixos/modules/hardware/ubertooth.nix

···

       10
       10
        
         };

     

       11
       11
        
       in {

     

       12
       12
        
         options.hardware.ubertooth = {

     

       13
       13
       -
           enable = mkEnableOption (lib.mdDoc "Enable the Ubertooth software and its udev rules.");

     

       13
       13
       +
           enable = mkEnableOption (lib.mdDoc "Ubertooth software and its udev rules");

     

       14
       14
        
       

     

       15
       15
        
           group = mkOption {

     

       16
       16
        
             type = types.str;

+1 -1

nixos/modules/hardware/wooting.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       {

     

       5
       5
        
         options.hardware.wooting.enable =

     

       6
       6
       -
           mkEnableOption (lib.mdDoc "Enable support for Wooting keyboards");

     

       6
       6
       +
           mkEnableOption (lib.mdDoc "support for Wooting keyboards");

     

       7
       7
        
       

     

       8
       8
        
         config = mkIf config.hardware.wooting.enable {

     

       9
       9
        
           environment.systemPackages = [ pkgs.wootility ];

+1 -1

nixos/modules/programs/kclock.nix

···

       4
       4
        
         cfg = config.programs.kclock;

     

       5
       5
        
         kclockPkg = pkgs.libsForQt5.kclock;

     

       6
       6
        
       in {

     

       7
       7
       -
         options.programs.kclock = { enable = mkEnableOption (lib.mdDoc "Enable KClock"); };

     

       7
       7
       +
         options.programs.kclock = { enable = mkEnableOption (lib.mdDoc "KClock"); };

     

       8
       8
        
       

     

       9
       9
        
         config = mkIf cfg.enable {

     

       10
       10
        
           services.dbus.packages = [ kclockPkg ];

+1 -1

nixos/modules/services/cluster/kubernetes/flannel.nix

···

       12
       12
        
       {

     

       13
       13
        
         ###### interface

     

       14
       14
        
         options.services.kubernetes.flannel = {

     

       15
       15
       -
           enable = mkEnableOption (lib.mdDoc "enable flannel networking");

     

       15
       15
       +
           enable = mkEnableOption (lib.mdDoc "flannel networking");

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         ###### implementation

+1 -1

nixos/modules/services/computing/foldingathome/client.nix

···

       18
       18
        
           '')

     

       19
       19
        
         ];

     

       20
       20
        
         options.services.foldingathome = {

     

       21
       21
       -
           enable = mkEnableOption (lib.mdDoc "Enable the Folding@home client");

     

       21
       21
       +
           enable = mkEnableOption (lib.mdDoc "Folding@home client");

     

       22
       22
        
       

     

       23
       23
        
           package = mkOption {

     

       24
       24
        
             type = types.package;

+1 -7

nixos/modules/services/databases/couchdb.nix

···

       34
       34
        
       

     

       35
       35
        
           services.couchdb = {

     

       36
       36
        
       

     

       37
       37
       -
             enable = mkOption {

     

       38
       38
       -
               type = types.bool;

     

       39
       39
       -
               default = false;

     

       40
       40
       -
               description = lib.mdDoc ''

     

       41
       41
       -
                 Whether to run CouchDB Server.

     

       42
       42
       -
               '';

     

       43
       43
       -
             };

     

       37
       37
       +
             enable = mkEnableOption (lib.mdDoc "CouchDB Server");

     

       44
       38
        
       

     

       45
       39
        
             package = mkOption {

     

       46
       40
        
               type = types.package;

+1 -7

nixos/modules/services/databases/opentsdb.nix

···

       15
       15
        
       

     

       16
       16
        
           services.opentsdb = {

     

       17
       17
        
       

     

       18
       18
       -
             enable = mkOption {

     

       19
       19
       -
               type = types.bool;

     

       20
       20
       -
               default = false;

     

       21
       21
       -
               description = lib.mdDoc ''

     

       22
       22
       -
                 Whether to run OpenTSDB.

     

       23
       23
       -
               '';

     

       24
       24
       -
             };

     

       18
       18
       +
             enable = mkEnableOption (lib.mdDoc "OpenTSDB");

     

       25
       19
        
       

     

       26
       20
        
             package = mkOption {

     

       27
       21
        
               type = types.package;

+1 -1

nixos/modules/services/home-automation/zigbee2mqtt.nix

···

       18
       18
        
         ];

     

       19
       19
        
       

     

       20
       20
        
         options.services.zigbee2mqtt = {

     

       21
       21
       -
           enable = mkEnableOption (lib.mdDoc "enable zigbee2mqtt service");

     

       21
       21
       +
           enable = mkEnableOption (lib.mdDoc "zigbee2mqtt service");

     

       22
       22
        
       

     

       23
       23
        
           package = mkOption {

     

       24
       24
        
             description = lib.mdDoc "Zigbee2mqtt package to use";

+1 -5

nixos/modules/services/logging/fluentd.nix

···

       12
       12
        
         options = {

     

       13
       13
        
       

     

       14
       14
        
           services.fluentd = {

     

       15
       15
       -
             enable = mkOption {

     

       16
       16
       -
               type = types.bool;

     

       17
       17
       -
               default = false;

     

       18
       18
       -
               description = lib.mdDoc "Whether to enable fluentd.";

     

       19
       19
       -
             };

     

       15
       15
       +
             enable = mkEnableOption (lib.mdDoc "fluentd");

     

       20
       16
        
       

     

       21
       17
        
             config = mkOption {

     

       22
       18
        
               type = types.lines;

+1 -7

nixos/modules/services/logging/logcheck.nix

···

       109
       109
        
       {

     

       110
       110
        
         options = {

     

       111
       111
        
           services.logcheck = {

     

       112
       112
       -
             enable = mkOption {

     

       113
       113
       -
               default = false;

     

       114
       114
       -
               type = types.bool;

     

       115
       115
       -
               description = lib.mdDoc ''

     

       116
       116
       -
                 Enable the logcheck cron job.

     

       117
       117
       -
               '';

     

       118
       118
       -
             };

     

       112
       112
       +
             enable = mkEnableOption (lib.mdDoc "logcheck cron job");

     

       119
       113
        
       

     

       120
       114
        
             user = mkOption {

     

       121
       115
        
               default = "logcheck";

+2 -7

nixos/modules/services/misc/exhibitor.nix

···

       68
       68
        
       {

     

       69
       69
        
         options = {

     

       70
       70
        
           services.exhibitor = {

     

       71
       71
       -
             enable = mkOption {

     

       72
       72
       -
               type = types.bool;

     

       73
       73
       -
               default = false;

     

       74
       74
       -
               description = lib.mdDoc ''

     

       75
       75
       -
                 Whether to enable the exhibitor server.

     

       76
       76
       -
               '';

     

       77
       77
       -
             };

     

       71
       71
       +
             enable = mkEnableOption (lib.mdDoc "exhibitor server");

     

       72
       72
       +
       

     

       78
       73
        
             # See https://github.com/soabase/exhibitor/wiki/Running-Exhibitor for what these mean

     

       79
       74
        
             # General options for any type of config

     

       80
       75
        
             port = mkOption {

+1 -5

nixos/modules/services/misc/gollum.nix

···

       8
       8
        
       

     

       9
       9
        
       {

     

       10
       10
        
         options.services.gollum = {

     

       11
       11
       -
           enable = mkOption {

     

       12
       12
       -
             type = types.bool;

     

       13
       13
       -
             default = false;

     

       14
       14
       -
             description = lib.mdDoc "Enable the Gollum service.";

     

       15
       15
       -
           };

     

       11
       11
       +
           enable = mkEnableOption (lib.mdDoc "Gollum service");

     

       16
       12
        
       

     

       17
       13
        
           address = mkOption {

     

       18
       14
        
             type = types.str;

+1 -5

nixos/modules/services/misc/zookeeper.nix

···

       24
       24
        
       in {

     

       25
       25
        
       

     

       26
       26
        
         options.services.zookeeper = {

     

       27
       27
       -
           enable = mkOption {

     

       28
       28
       -
             description = lib.mdDoc "Whether to enable Zookeeper.";

     

       29
       29
       -
             default = false;

     

       30
       30
       -
             type = types.bool;

     

       31
       31
       -
           };

     

       27
       27
       +
           enable = mkEnableOption (lib.mdDoc "Zookeeper");

     

       32
       28
        
       

     

       33
       29
        
           port = mkOption {

     

       34
       30
        
             description = lib.mdDoc "Zookeeper Client port.";

+1 -7

nixos/modules/services/monitoring/arbtt.nix

···

       7
       7
        
       in {

     

       8
       8
        
         options = {

     

       9
       9
        
           services.arbtt = {

     

       10
       10
       -
             enable = mkOption {

     

       11
       11
       -
               type = types.bool;

     

       12
       12
       -
               default = false;

     

       13
       13
       -
               description = lib.mdDoc ''

     

       14
       14
       -
                 Enable the arbtt statistics capture service.

     

       15
       15
       -
               '';

     

       16
       16
       -
             };

     

       10
       10
       +
             enable = mkEnableOption (lib.mdDoc "Arbtt statistics capture service");

     

       17
       11
        
       

     

       18
       12
        
             package = mkOption {

     

       19
       13
        
               type = types.package;

+1 -7

nixos/modules/services/monitoring/bosun.nix

···

       22
       22
        
       

     

       23
       23
        
           services.bosun = {

     

       24
       24
        
       

     

       25
       25
       -
             enable = mkOption {

     

       26
       26
       -
               type = types.bool;

     

       27
       27
       -
               default = false;

     

       28
       28
       -
               description = lib.mdDoc ''

     

       29
       29
       -
                 Whether to run bosun.

     

       30
       30
       -
               '';

     

       31
       31
       -
             };

     

       25
       25
       +
             enable = mkEnableOption (lib.mdDoc "bosun");

     

       32
       26
        
       

     

       33
       27
        
             package = mkOption {

     

       34
       28
        
               type = types.package;

+1 -5

nixos/modules/services/monitoring/cadvisor.nix

···

       8
       8
        
       in {

     

       9
       9
        
         options = {

     

       10
       10
        
           services.cadvisor = {

     

       11
       11
       -
             enable = mkOption {

     

       12
       12
       -
               default = false;

     

       13
       13
       -
               type = types.bool;

     

       14
       14
       -
               description = lib.mdDoc "Whether to enable cadvisor service.";

     

       15
       15
       -
             };

     

       11
       11
       +
             enable = mkEnableOption (lib.mdDoc "Cadvisor service");

     

       16
       12
        
       

     

       17
       13
        
             listenAddress = mkOption {

     

       18
       14
        
               default = "127.0.0.1";

+1 -7

nixos/modules/services/monitoring/datadog-agent.nix

···

       49
       49
        
         };

     

       50
       50
        
       in {

     

       51
       51
        
         options.services.datadog-agent = {

     

       52
       52
       -
           enable = mkOption {

     

       53
       53
       -
             description = lib.mdDoc ''

     

       54
       54
       -
               Whether to enable the datadog-agent v7 monitoring service

     

       55
       55
       -
             '';

     

       56
       56
       -
             default = false;

     

       57
       57
       -
             type = types.bool;

     

       58
       58
       -
           };

     

       52
       52
       +
           enable = mkEnableOption (lib.mdDoc "Datadog-agent v7 monitoring service");

     

       59
       53
        
       

     

       60
       54
        
           package = mkOption {

     

       61
       55
        
             default = pkgs.datadog-agent;

+1 -5

nixos/modules/services/monitoring/heapster.nix

···

       6
       6
        
         cfg = config.services.heapster;

     

       7
       7
        
       in {

     

       8
       8
        
         options.services.heapster = {

     

       9
       9
       -
           enable = mkOption {

     

       10
       10
       -
             description = lib.mdDoc "Whether to enable heapster monitoring";

     

       11
       11
       -
             default = false;

     

       12
       12
       -
             type = types.bool;

     

       13
       13
       -
           };

     

       9
       9
       +
           enable = mkEnableOption (lib.mdDoc "Heapster monitoring");

     

       14
       10
        
       

     

       15
       11
        
           source = mkOption {

     

       16
       12
        
             description = lib.mdDoc "Heapster metric source";

+1 -7

nixos/modules/services/monitoring/prometheus/default.nix

···

       1563
       1563
        
       

     

       1564
       1564
        
         options.services.prometheus = {

     

       1565
       1565
        
       

     

       1566
       1566
       -
           enable = mkOption {

     

       1567
       1567
       -
             type = types.bool;

     

       1568
       1568
       -
             default = false;

     

       1569
       1569
       -
             description = lib.mdDoc ''

     

       1570
       1570
       -
               Enable the Prometheus monitoring daemon.

     

       1571
       1571
       -
             '';

     

       1572
       1572
       -
           };

     

       1566
       1566
       +
           enable = mkEnableOption (lib.mdDoc "Prometheus monitoring daemon");

     

       1573
       1567
        
       

     

       1574
       1568
        
           package = mkOption {

     

       1575
       1569
        
             type = types.package;

+2 -7

nixos/modules/services/monitoring/riemann.nix

···

       27
       27
        
         options = {

     

       28
       28
        
       

     

       29
       29
        
           services.riemann = {

     

       30
       30
       -
             enable = mkOption {

     

       31
       31
       -
               type = types.bool;

     

       32
       32
       -
               default = false;

     

       33
       33
       -
               description = lib.mdDoc ''

     

       34
       34
       -
                 Enable the Riemann network monitoring daemon.

     

       35
       35
       -
               '';

     

       36
       36
       -
             };

     

       30
       30
       +
             enable = mkEnableOption (lib.mdDoc "Riemann network monitoring daemon");

     

       31
       31
       +
       

     

       37
       32
        
             config = mkOption {

     

       38
       33
        
               type = types.lines;

     

       39
       34
        
               description = lib.mdDoc ''

+1 -1

nixos/modules/services/network-filesystems/samba-wsdd.nix

···

       9
       9
        
         options = {

     

       10
       10
        
           services.samba-wsdd = {

     

       11
       11
        
             enable = mkEnableOption (lib.mdDoc ''

     

       12
       12
       -
               Enable Web Services Dynamic Discovery host daemon. This enables (Samba) hosts, like your local NAS device,

     

       12
       12
       +
               Web Services Dynamic Discovery host daemon. This enables (Samba) hosts, like your local NAS device,

     

       13
       13
        
               to be found by Web Service Discovery Clients like Windows.

     

       14
       14
        
       

     

       15
       15
        
               ::: {.note}

+1 -1

nixos/modules/services/networking/magic-wormhole-mailbox-server.nix

···

       9
       9
        
       in

     

       10
       10
        
       {

     

       11
       11
        
         options.services.magic-wormhole-mailbox-server = {

     

       12
       12
       -
           enable = mkEnableOption (lib.mdDoc "Enable Magic Wormhole Mailbox Server");

     

       12
       12
       +
           enable = mkEnableOption (lib.mdDoc "Magic Wormhole Mailbox Server");

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         config = mkIf cfg.enable {

+2 -7

nixos/modules/services/networking/mozillavpn.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
        
       {

     

       4
       4
       -
         options.services.mozillavpn.enable = lib.mkOption {

     

       5
       5
       -
           type = lib.types.bool;

     

       6
       6
       -
           default = false;

     

       7
       7
       -
           description = lib.mdDoc ''

     

       8
       8
       -
             Enable the Mozilla VPN daemon.

     

       9
       9
       -
           '';

     

       10
       10
       -
         };

     

       4
       4
       +
         options.services.mozillavpn.enable =

     

       5
       5
       +
           lib.mkEnableOption (lib.mdDoc "Mozilla VPN daemon");

     

       11
       6
        
       

     

       12
       7
        
         config = lib.mkIf config.services.mozillavpn.enable {

     

       13
       8
        
           environment.systemPackages = [ pkgs.mozillavpn ];

+1 -1

nixos/modules/services/networking/networkmanager.nix

···

       365
       365
        
                 If you enable this option the

     

       366
       366
        
                 `networkmanager_strongswan` plugin will be added to

     

       367
       367
        
                 the {option}`networking.networkmanager.plugins` option

     

       368
       368
       -
                 so you don't need to to that yourself.

     

       368
       368
       +
                 so you don't need to do that yourself.

     

       369
       369
        
               '';

     

       370
       370
        
             };

     

       371
       371

+1 -5

nixos/modules/services/networking/onedrive.nix

···

       26
       26
        
         ### Interface

     

       27
       27
        
       

     

       28
       28
        
         options.services.onedrive = {

     

       29
       29
       -
           enable = lib.mkOption {

     

       30
       30
       -
             type = lib.types.bool;

     

       31
       31
       -
             default = false;

     

       32
       32
       -
             description = lib.mdDoc "Enable OneDrive service";

     

       33
       33
       -
           };

     

       29
       29
       +
            enable = lib.mkEnableOption (lib.mdDoc "OneDrive service");

     

       34
       30
        
       

     

       35
       31
        
            package = lib.mkOption {

     

       36
       32
        
              type = lib.types.package;

+1 -1

nixos/modules/services/networking/owamp.nix

···

       10
       10
        
         ###### interface

     

       11
       11
        
       

     

       12
       12
        
         options = {

     

       13
       13
       -
           services.owamp.enable = mkEnableOption (lib.mdDoc "Enable OWAMP server");

     

       13
       13
       +
           services.owamp.enable = mkEnableOption (lib.mdDoc "OWAMP server");

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16

+1 -5

nixos/modules/services/networking/polipo.nix

···

       23
       23
        
       

     

       24
       24
        
           services.polipo = {

     

       25
       25
        
       

     

       26
       26
       -
             enable = mkOption {

     

       27
       27
       -
               type = types.bool;

     

       28
       28
       -
               default = false;

     

       29
       29
       -
               description = lib.mdDoc "Whether to run the polipo caching web proxy.";

     

       30
       30
       -
             };

     

       26
       26
       +
             enable = mkEnableOption (lib.mdDoc "polipo caching web proxy");

     

       31
       27
        
       

     

       32
       28
        
             proxyAddress = mkOption {

     

       33
       29
        
               type = types.str;

+2 -5

nixos/modules/services/networking/smokeping.nix

···

       49
       49
        
       {

     

       50
       50
        
         options = {

     

       51
       51
        
           services.smokeping = {

     

       52
       52
       -
             enable = mkOption {

     

       53
       53
       -
               type = types.bool;

     

       54
       54
       -
               default = false;

     

       55
       55
       -
               description = lib.mdDoc "Enable the smokeping service";

     

       56
       56
       -
             };

     

       52
       52
       +
             enable = mkEnableOption (lib.mdDoc "smokeping service");

     

       53
       53
       +
       

     

       57
       54
        
             alertConfig = mkOption {

     

       58
       55
        
               type = types.lines;

     

       59
       56
        
               default = ''

+1 -1

nixos/modules/services/web-apps/peertube.nix

···

       75
       75
        
       

     

       76
       76
        
       in {

     

       77
       77
        
         options.services.peertube = {

     

       78
       78
       -
           enable = lib.mkEnableOption (lib.mdDoc "Enable Peertube’s service");

     

       78
       78
       +
           enable = lib.mkEnableOption (lib.mdDoc "Peertube");

     

       79
       79
        
       

     

       80
       80
        
           user = lib.mkOption {

     

       81
       81
        
             type = lib.types.str;

+1 -7

nixos/modules/services/x11/clight.nix

···

       28
       28
        
             cfg.settings));

     

       29
       29
        
       in {

     

       30
       30
        
         options.services.clight = {

     

       31
       31
       -
           enable = mkOption {

     

       32
       32
       -
             type = types.bool;

     

       33
       33
       -
             default = false;

     

       34
       34
       -
             description = lib.mdDoc ''

     

       35
       35
       -
               Whether to enable clight or not.

     

       36
       36
       -
             '';

     

       37
       37
       -
           };

     

       31
       31
       +
           enable = mkEnableOption (lib.mdDoc "clight");

     

       38
       32
        
       

     

       39
       33
        
           temperature = {

     

       40
       34
        
             day = mkOption {