commit e920aed5214c6bf6a6e75bfd1b8fee2e8794e8ba · 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/audio/ympd.nix

···

       29
       29
        
               };

     

       30
       30
        
       

     

       31
       31
        
               port = mkOption {

     

       32
       32
       -
                 type = types.int;

     

       32
       32
       +
                 type = types.port;

     

       33
       33
        
                 default = config.services.mpd.network.port;

     

       34
       34
        
                 defaultText = literalExpression "config.services.mpd.network.port";

     

       35
       35
        
                 description = lib.mdDoc "The port where MPD is listening.";

+3 -3

nixos/modules/services/backup/bacula.nix

···

       314
       314
        
       

     

       315
       315
        
             port = mkOption {

     

       316
       316
        
               default = 9102;

     

       317
       317
       -
               type = types.int;

     

       317
       317
       +
               type = types.port;

     

       318
       318
        
               description = lib.mdDoc ''

     

       319
       319
        
                 This specifies the port number on which the Client listens for

     

       320
       320
        
                 Director connections. It must agree with the FDPort specified in

     
···

       374
       374
        
       

     

       375
       375
        
             port = mkOption {

     

       376
       376
        
               default = 9103;

     

       377
       377
       -
               type = types.int;

     

       377
       377
       +
               type = types.port;

     

       378
       378
        
               description = lib.mdDoc ''

     

       379
       379
        
                 Specifies port number on which the Storage daemon listens for

     

       380
       380
        
                 Director connections.

     
···

       451
       451
        
       

     

       452
       452
        
             port = mkOption {

     

       453
       453
        
               default = 9101;

     

       454
       454
       -
               type = types.int;

     

       454
       454
       +
               type = types.port;

     

       455
       455
        
               description = lib.mdDoc ''

     

       456
       456
        
                 Specify the port (a positive integer) on which the Director daemon

     

       457
       457
        
                 will listen for Bacula Console connections. This same port number

+1 -1

nixos/modules/services/backup/duplicati.nix

···

       12
       12
        
       

     

       13
       13
        
             port = mkOption {

     

       14
       14
        
               default = 8200;

     

       15
       15
       -
               type = types.int;

     

       15
       15
       +
               type = types.port;

     

       16
       16
        
               description = lib.mdDoc ''

     

       17
       17
        
                 Port serving the web interface

     

       18
       18
        
               '';

+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;

+2 -8

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;

     
···

       49
       43
        
             };

     

       50
       44
        
       

     

       51
       45
        
             port = mkOption {

     

       52
       52
       -
               type = types.int;

     

       46
       46
       +
               type = types.port;

     

       53
       47
        
               default = 4242;

     

       54
       48
        
               description = lib.mdDoc ''

     

       55
       49
        
                 Which port OpenTSDB listens on.

+1 -1

nixos/modules/services/databases/pgmanage.nix

···

       85
       85
        
           };

     

       86
       86
        
       

     

       87
       87
        
           port = mkOption {

     

       88
       88
       -
             type = types.int;

     

       88
       88
       +
             type = types.port;

     

       89
       89
        
             default = 8080;

     

       90
       90
        
             description = lib.mdDoc ''

     

       91
       91
        
               This tells pgmanage what port to listen on for browser requests.

+1 -1

nixos/modules/services/games/teeworlds.nix

···

       70
       70
        
             };

     

       71
       71
        
       

     

       72
       72
        
             port = mkOption {

     

       73
       73
       -
               type = types.int;

     

       73
       73
       +
               type = types.port;

     

       74
       74
        
               default = 8303;

     

       75
       75
        
               description = lib.mdDoc ''

     

       76
       76
        
                 Port the server will listen on.

+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";

+1 -1

nixos/modules/services/misc/airsonic.nix

···

       48
       48
        
             };

     

       49
       49
        
       

     

       50
       50
        
             port = mkOption {

     

       51
       51
       -
               type = types.int;

     

       51
       51
       +
               type = types.port;

     

       52
       52
        
               default = 4040;

     

       53
       53
        
               description = lib.mdDoc ''

     

       54
       54
        
                 The port on which Airsonic will listen for

+1 -1

nixos/modules/services/misc/ankisyncd.nix

···

       44
       44
        
             };

     

       45
       45
        
       

     

       46
       46
        
             port = mkOption {

     

       47
       47
       -
               type = types.int;

     

       47
       47
       +
               type = types.port;

     

       48
       48
        
               default = 27701;

     

       49
       49
        
               description = lib.mdDoc "ankisyncd port";

     

       50
       50
        
             };

+1 -1

nixos/modules/services/misc/apache-kafka.nix

···

       40
       40
        
           port = mkOption {

     

       41
       41
        
             description = lib.mdDoc "Port number the broker should listen on.";

     

       42
       42
        
             default = 9092;

     

       43
       43
       -
             type = types.int;

     

       43
       43
       +
             type = types.port;

     

       44
       44
        
           };

     

       45
       45
        
       

     

       46
       46
        
           hostname = mkOption {

+3 -8

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 {

     

       81
       81
       -
               type = types.int;

     

       76
       76
       +
               type = types.port;

     

       82
       77
        
               default = 8080;

     

       83
       78
        
               description = lib.mdDoc ''

     

       84
       79
        
                 The port for exhibitor to listen on and communicate with other exhibitors.

+2 -2

nixos/modules/services/misc/gogs.nix

···

       90
       90
        
               };

     

       91
       91
        
       

     

       92
       92
        
               port = mkOption {

     

       93
       93
       -
                 type = types.int;

     

       93
       93
       +
                 type = types.port;

     

       94
       94
        
                 default = 3306;

     

       95
       95
        
                 description = lib.mdDoc "Database host port.";

     

       96
       96
        
               };

     
···

       167
       167
        
             };

     

       168
       168
        
       

     

       169
       169
        
             httpPort = mkOption {

     

       170
       170
       -
               type = types.int;

     

       170
       170
       +
               type = types.port;

     

       171
       171
        
               default = 3000;

     

       172
       172
        
               description = lib.mdDoc "HTTP listen port.";

     

       173
       173
        
             };

+2 -6

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;

     
···

       21
       17
        
           };

     

       22
       18
        
       

     

       23
       19
        
           port = mkOption {

     

       24
       24
       -
             type = types.int;

     

       20
       20
       +
             type = types.port;

     

       25
       21
        
             default = 4567;

     

       26
       22
        
             description = lib.mdDoc "Port on which the web server will run.";

     

       27
       23
        
           };

+1 -1

nixos/modules/services/misc/parsoid.nix

···

       70
       70
        
             };

     

       71
       71
        
       

     

       72
       72
        
             port = mkOption {

     

       73
       73
       -
               type = types.int;

     

       73
       73
       +
               type = types.port;

     

       74
       74
        
               default = 8000;

     

       75
       75
        
               description = lib.mdDoc ''

     

       76
       76
        
                 Port to listen on.

+1 -1

nixos/modules/services/misc/pykms.nix

···

       28
       28
        
             };

     

       29
       29
        
       

     

       30
       30
        
             port = mkOption {

     

       31
       31
       -
               type = types.int;

     

       31
       31
       +
               type = types.port;

     

       32
       32
        
               default = 1688;

     

       33
       33
        
               description = lib.mdDoc "The port on which to listen.";

     

       34
       34
        
             };

+1 -1

nixos/modules/services/misc/redmine.nix

···

       161
       161
        
               };

     

       162
       162
        
       

     

       163
       163
        
               port = mkOption {

     

       164
       164
       -
                 type = types.int;

     

       164
       164
       +
                 type = types.port;

     

       165
       165
        
                 default = if cfg.database.type == "postgresql" then 5432 else 3306;

     

       166
       166
        
                 defaultText = literalExpression "3306";

     

       167
       167
        
                 description = lib.mdDoc "Database host port.";

+1 -1

nixos/modules/services/misc/rippled.nix

···

       98
       98
        
       

     

       99
       99
        
             port = mkOption {

     

       100
       100
        
               description = lib.mdDoc "Port where rippled listens.";

     

       101
       101
       -
               type = types.int;

     

       101
       101
       +
               type = types.port;

     

       102
       102
        
             };

     

       103
       103
        
       

     

       104
       104
        
             protocol = mkOption {

+1 -1

nixos/modules/services/misc/tautulli.nix

···

       27
       27
        
             };

     

       28
       28
        
       

     

       29
       29
        
             port = mkOption {

     

       30
       30
       -
               type = types.int;

     

       30
       30
       +
               type = types.port;

     

       31
       31
        
               default = 8181;

     

       32
       32
        
               description = lib.mdDoc "TCP port where Tautulli listens.";

     

       33
       33
        
             };

+1 -1

nixos/modules/services/misc/zoneminder.nix

···

       97
       97
        
             };

     

       98
       98
        
       

     

       99
       99
        
             port = mkOption {

     

       100
       100
       -
               type = types.int;

     

       100
       100
       +
               type = types.port;

     

       101
       101
        
               default = 8095;

     

       102
       102
        
               description = lib.mdDoc ''

     

       103
       103
        
                 The port on which to listen.

+2 -6

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.";

     

       35
       31
        
             default = 2181;

     

       36
       36
       -
             type = types.int;

     

       32
       32
       +
             type = types.port;

     

       37
       33
        
           };

     

       38
       34
        
       

     

       39
       35
        
           id = mkOption {

+1 -1

nixos/modules/services/monitoring/alerta.nix

···

       24
       24
        
           enable = mkEnableOption (lib.mdDoc "alerta");

     

       25
       25
        
       

     

       26
       26
        
           port = mkOption {

     

       27
       27
       -
             type = types.int;

     

       27
       27
       +
             type = types.port;

     

       28
       28
        
             default = 5000;

     

       29
       29
        
             description = lib.mdDoc "Port of Alerta";

     

       30
       30
        
           };

+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;

+2 -6

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";

     
···

       22
       18
        
       

     

       23
       19
        
             port = mkOption {

     

       24
       20
        
               default = 8080;

     

       25
       25
       -
               type = types.int;

     

       21
       21
       +
               type = types.port;

     

       26
       22
        
               description = lib.mdDoc "Cadvisor listening port";

     

       27
       23
        
             };

     

       28
       24

+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;

+2 -2

nixos/modules/services/monitoring/grafana-reporter.nix

···

       23
       23
        
             port = mkOption {

     

       24
       24
        
               description = lib.mdDoc "Grafana port.";

     

       25
       25
        
               default = 3000;

     

       26
       26
       -
               type = types.int;

     

       26
       26
       +
               type = types.port;

     

       27
       27
        
             };

     

       28
       28
        
       

     

       29
       29
        
           };

     
···

       36
       36
        
           port = mkOption {

     

       37
       37
        
             description = lib.mdDoc "Listening port.";

     

       38
       38
        
             default = 8686;

     

       39
       39
       -
             type = types.int;

     

       39
       39
       +
             type = types.port;

     

       40
       40
        
           };

     

       41
       41
        
       

     

       42
       42
        
           templateDir = mkOption {

+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;

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/mail.nix

···

       33
       33
        
             '';

     

       34
       34
        
           };

     

       35
       35
        
           port = mkOption {

     

       36
       36
       -
             type = types.int;

     

       36
       36
       +
             type = types.port;

     

       37
       37
        
             example = 587;

     

       38
       38
        
             description = lib.mdDoc ''

     

       39
       39
        
               Port to use for SMTP.

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/tor.nix

···

       17
       17
        
           };

     

       18
       18
        
       

     

       19
       19
        
           torControlPort = mkOption {

     

       20
       20
       -
             type = types.int;

     

       20
       20
       +
             type = types.port;

     

       21
       21
        
             default = 9051;

     

       22
       22
        
             description = lib.mdDoc ''

     

       23
       23
        
               Tor control port.

+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/monitoring/zabbix-server.nix

···

       94
       94
        
               };

     

       95
       95
        
       

     

       96
       96
        
               port = mkOption {

     

       97
       97
       -
                 type = types.int;

     

       97
       97
       +
                 type = types.port;

     

       98
       98
        
                 default = if cfg.database.type == "mysql" then mysql.port else pgsql.port;

     

       99
       99
        
                 defaultText = literalExpression ''

     

       100
       100
        
                   if config.${opt.database.type} == "mysql"

+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/bitlbee.nix

···

       68
       68
        
       

     

       69
       69
        
             portNumber = mkOption {

     

       70
       70
        
               default = 6667;

     

       71
       71
       -
               type = types.int;

     

       71
       71
       +
               type = types.port;

     

       72
       72
        
               description = lib.mdDoc ''

     

       73
       73
        
                 Number of the port BitlBee will be listening to.

     

       74
       74
        
               '';

+2 -2

nixos/modules/services/networking/dnscrypt-wrapper.nix

···

       135
       135
        
           };

     

       136
       136
        
       

     

       137
       137
        
           port = mkOption {

     

       138
       138
       -
             type = types.int;

     

       138
       138
       +
             type = types.port;

     

       139
       139
        
             default = 5353;

     

       140
       140
        
             description = lib.mdDoc ''

     

       141
       141
        
               The DNSCrypt wrapper will listen for DNS queries on this port.

     
···

       182
       182
        
           };

     

       183
       183
        
       

     

       184
       184
        
           upstream.port = mkOption {

     

       185
       185
       -
             type = types.int;

     

       185
       185
       +
             type = types.port;

     

       186
       186
        
             default = 53;

     

       187
       187
        
             description = lib.mdDoc ''

     

       188
       188
        
               The port of the upstream DNS server DNSCrypt will "wrap".

+1 -1

nixos/modules/services/networking/eternal-terminal.nix

···

       20
       20
        
       

     

       21
       21
        
             port = mkOption {

     

       22
       22
        
               default = 2022;

     

       23
       23
       -
               type = types.int;

     

       23
       23
       +
               type = types.port;

     

       24
       24
        
               description = lib.mdDoc ''

     

       25
       25
        
                 The port the server should listen on. Will use the server's default (2022) if not specified.

     

       26
       26

+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

+2 -2

nixos/modules/services/networking/nntp-proxy.nix

···

       71
       71
        
             };

     

       72
       72
        
       

     

       73
       73
        
             upstreamPort = mkOption {

     

       74
       74
       -
               type = types.int;

     

       74
       74
       +
               type = types.port;

     

       75
       75
        
               default = 563;

     

       76
       76
        
               description = lib.mdDoc ''

     

       77
       77
        
                 Upstream server port

     
···

       112
       112
        
             };

     

       113
       113
        
       

     

       114
       114
        
             port = mkOption {

     

       115
       115
       -
               type = types.int;

     

       115
       115
       +
               type = types.port;

     

       116
       116
        
               default = 5555;

     

       117
       117
        
               description = lib.mdDoc ''

     

       118
       118
        
                 Proxy listen port

+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/ostinato.nix

···

       29
       29
        
             enable = mkEnableOption (lib.mdDoc "Ostinato agent-controller (Drone)");

     

       30
       30
        
       

     

       31
       31
        
             port = mkOption {

     

       32
       32
       -
               type = types.int;

     

       32
       32
       +
               type = types.port;

     

       33
       33
        
               default = 7878;

     

       34
       34
        
               description = lib.mdDoc ''

     

       35
       35
        
                 Port to listen on.

+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

+2 -6

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;

     
···

       36
       32
        
             };

     

       37
       33
        
       

     

       38
       34
        
             proxyPort = mkOption {

     

       39
       39
       -
               type = types.int;

     

       35
       35
       +
               type = types.port;

     

       40
       36
        
               default = 8123;

     

       41
       37
        
               description = lib.mdDoc "TCP port on which Polipo will listen.";

     

       42
       38
        
             };

+1 -1

nixos/modules/services/networking/shadowsocks.nix

···

       48
       48
        
             };

     

       49
       49
        
       

     

       50
       50
        
             port = mkOption {

     

       51
       51
       -
               type = types.int;

     

       51
       51
       +
               type = types.port;

     

       52
       52
        
               default = 8388;

     

       53
       53
        
               description = lib.mdDoc ''

     

       54
       54
        
                 Port which the server uses.

+3 -6

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 = ''

     
···

       186
       183
        
               '';

     

       187
       184
        
             };

     

       188
       185
        
             port = mkOption {

     

       189
       189
       -
               type = types.int;

     

       186
       186
       +
               type = types.port;

     

       190
       187
        
               default = 8081;

     

       191
       188
        
               description = lib.mdDoc "TCP port to use for the web server.";

     

       192
       189
        
             };

+1 -1

nixos/modules/services/networking/sslh.nix

···

       70
       70
        
             };

     

       71
       71
        
       

     

       72
       72
        
             port = mkOption {

     

       73
       73
       -
               type = types.int;

     

       73
       73
       +
               type = types.port;

     

       74
       74
        
               default = 443;

     

       75
       75
        
               description = lib.mdDoc "Listening port.";

     

       76
       76
        
             };

+1 -1

nixos/modules/services/networking/teleport.nix

···

       65
       65
        
               };

     

       66
       66
        
       

     

       67
       67
        
               port = mkOption {

     

       68
       68
       -
                 type = int;

     

       68
       68
       +
                 type = port;

     

       69
       69
        
                 default = 3000;

     

       70
       70
        
                 description = lib.mdDoc "Metrics and diagnostics port.";

     

       71
       71
        
               };

+1 -1

nixos/modules/services/networking/tox-bootstrapd.nix

···

       29
       29
        
                 };

     

       30
       30
        
       

     

       31
       31
        
                 port = mkOption {

     

       32
       32
       -
                   type = types.int;

     

       32
       32
       +
                   type = types.port;

     

       33
       33
        
                   default = 33445;

     

       34
       34
        
                   description = lib.mdDoc "Listening port (UDP).";

     

       35
       35
        
                 };

+1 -1

nixos/modules/services/networking/toxvpn.nix

···

       14
       14
        
             };

     

       15
       15
        
       

     

       16
       16
        
             port = mkOption {

     

       17
       17
       -
               type        = types.int;

     

       17
       17
       +
               type        = types.port;

     

       18
       18
        
               default     = 33445;

     

       19
       19
        
               description = lib.mdDoc "udp port for toxcore, port-forward to help with connectivity if you run many nodes behind one NAT";

     

       20
       20
        
             };

+1 -1

nixos/modules/services/networking/xrdp.nix

···

       54
       54
        
             };

     

       55
       55
        
       

     

       56
       56
        
             port = mkOption {

     

       57
       57
       -
               type = types.int;

     

       57
       57
       +
               type = types.port;

     

       58
       58
        
               default = 3389;

     

       59
       59
        
               description = lib.mdDoc ''

     

       60
       60
        
                 Specifies on which port the xrdp daemon listens.

+1 -1

nixos/modules/services/networking/zerotierone.nix

···

       19
       19
        
       

     

       20
       20
        
         options.services.zerotierone.port = mkOption {

     

       21
       21
        
           default = 9993;

     

       22
       22
       -
           type = types.int;

     

       22
       22
       +
           type = types.port;

     

       23
       23
        
           description = lib.mdDoc ''

     

       24
       24
        
             Network port used by ZeroTier.

     

       25
       25
        
           '';

+1 -1

nixos/modules/services/search/solr.nix

···

       21
       21
        
             };

     

       22
       22
        
       

     

       23
       23
        
             port = mkOption {

     

       24
       24
       -
               type = types.int;

     

       24
       24
       +
               type = types.port;

     

       25
       25
        
               default = 8983;

     

       26
       26
        
               description = lib.mdDoc "Port on which Solr is ran.";

     

       27
       27
        
             };

+2 -2

nixos/modules/services/web-apps/atlassian/crowd.nix

···

       61
       61
        
             };

     

       62
       62
        
       

     

       63
       63
        
             listenPort = mkOption {

     

       64
       64
       -
               type = types.int;

     

       64
       64
       +
               type = types.port;

     

       65
       65
        
               default = 8092;

     

       66
       66
        
               description = lib.mdDoc "Port to listen on.";

     

       67
       67
        
             };

     
···

       95
       95
        
               };

     

       96
       96
        
       

     

       97
       97
        
               port = mkOption {

     

       98
       98
       -
                 type = types.int;

     

       98
       98
       +
                 type = types.port;

     

       99
       99
        
                 default = 443;

     

       100
       100
        
                 example = 80;

     

       101
       101
        
                 description = lib.mdDoc "Port used at the proxy";

+4 -4

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;

     
···

       96
       96
        
           };

     

       97
       97
        
       

     

       98
       98
        
           listenHttp = lib.mkOption {

     

       99
       99
       -
             type = lib.types.int;

     

       99
       99
       +
             type = lib.types.port;

     

       100
       100
        
             default = 9000;

     

       101
       101
        
             description = lib.mdDoc "listen port for HTTP server.";

     

       102
       102
        
           };

     

       103
       103
        
       

     

       104
       104
        
           listenWeb = lib.mkOption {

     

       105
       105
       -
             type = lib.types.int;

     

       105
       105
       +
             type = lib.types.port;

     

       106
       106
        
             default = 9000;

     

       107
       107
        
             description = lib.mdDoc "listen port for WEB server.";

     

       108
       108
        
           };

     
···

       177
       177
        
             };

     

       178
       178
        
       

     

       179
       179
        
             port = lib.mkOption {

     

       180
       180
       -
               type = lib.types.int;

     

       180
       180
       +
               type = lib.types.port;

     

       181
       181
        
               default = 5432;

     

       182
       182
        
               description = lib.mdDoc "Database host port.";

     

       183
       183
        
             };

+2 -2

nixos/modules/services/web-apps/restya-board.nix

···

       69
       69
        
               };

     

       70
       70
        
       

     

       71
       71
        
               listenPort = mkOption {

     

       72
       72
       -
                 type = types.int;

     

       72
       72
       +
                 type = types.port;

     

       73
       73
        
                 default = 3000;

     

       74
       74
        
                 description = lib.mdDoc ''

     

       75
       75
        
                   Listen port for the virtualhost to use.

     
···

       132
       132
        
               };

     

       133
       133
        
       

     

       134
       134
        
               port = mkOption {

     

       135
       135
       -
                 type = types.int;

     

       135
       135
       +
                 type = types.port;

     

       136
       136
        
                 default = 25;

     

       137
       137
        
                 description = lib.mdDoc ''

     

       138
       138
        
                   Port used to connect to SMTP server.

+1 -1

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

···

       67
       67
        
           };

     

       68
       68
        
       

     

       69
       69
        
           port = mkOption {

     

       70
       70
       -
             type = types.int;

     

       70
       70
       +
             type = types.port;

     

       71
       71
        
             default = 8080;

     

       72
       72
        
             description = lib.mdDoc ''

     

       73
       73
        
               The port number to bind to.

+1 -1

nixos/modules/services/web-apps/tt-rss.nix

···

       208
       208
        
               };

     

       209
       209
        
       

     

       210
       210
        
               port = mkOption {

     

       211
       211
       -
                 type = types.nullOr types.int;

     

       211
       211
       +
                 type = types.nullOr types.port;

     

       212
       212
        
                 default = null;

     

       213
       213
        
                 description = lib.mdDoc ''

     

       214
       214
        
                   The database's port. If not set, the default ports will be provided (5432

+1 -1

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

···

       68
       68
        
               The port youtrack will listen on.

     

       69
       69
        
             '';

     

       70
       70
        
             default = 8080;

     

       71
       71
       -
             type = types.int;

     

       71
       71
       +
             type = types.port;

     

       72
       72
        
           };

     

       73
       73
        
       

     

       74
       74
        
           statePath = mkOption {

+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 {

+1 -1

nixos/modules/system/boot/initrd-ssh.nix

···

       25
       25
        
           };

     

       26
       26
        
       

     

       27
       27
        
           port = mkOption {

     

       28
       28
       -
             type = types.int;

     

       28
       28
       +
             type = types.port;

     

       29
       29
        
             default = 22;

     

       30
       30
        
             description = lib.mdDoc ''

     

       31
       31
        
               Port on which SSH initrd service should listen.