commit ea27db19593703a0f5529d7e2029069e31018f23 · pyrox.dev/nixpkgs

+1 -1

nixos/modules/profiles/nix-builder-vm.nix

···

       85
       85
        
           };

     

       86
       86
        
           hostPort = mkOption {

     

       87
       87
        
             default = 31022;

     

       88
       88
       -
             type = types.int;

     

       88
       88
       +
             type = types.port;

     

       89
       89
        
             example = 22;

     

       90
       90
        
             description = ''

     

       91
       91
        
               The localhost host port to forward TCP to the guest port.

+1 -1

nixos/modules/services/continuous-integration/buildbot/master.nix

···

       182
       182
        
       

     

       183
       183
        
             pbPort = lib.mkOption {

     

       184
       184
        
               default = 9989;

     

       185
       185
       -
               type = lib.types.either lib.types.str lib.types.int;

     

       185
       185
       +
               type = lib.types.either lib.types.str lib.types.port;

     

       186
       186
        
               example = "'tcp:9990:interface=127.0.0.1'";

     

       187
       187
        
               description = ''

     

       188
       188
        
                 The buildmaster will listen on a TCP port of your choosing

+1 -1

nixos/modules/services/continuous-integration/gocd-server/default.nix

···

       64
       64
        
       

     

       65
       65
        
             sslPort = mkOption {

     

       66
       66
        
               default = 8154;

     

       67
       67
       -
               type = types.int;

     

       67
       67
       +
               type = types.port;

     

       68
       68
        
               description = ''

     

       69
       69
        
                 Specifies port number on which the Go.CD server HTTPS interface listens.

     

       70
       70
        
               '';

+1 -1

nixos/modules/services/databases/cassandra.nix

···

       415
       415
        
           };

     

       416
       416
        
       

     

       417
       417
        
           jmxPort = mkOption {

     

       418
       418
       -
             type = types.int;

     

       418
       418
       +
             type = types.port;

     

       419
       419
        
             default = 7199;

     

       420
       420
        
             description = ''

     

       421
       421
        
               Specifies the default port over which Cassandra will be available for

+1 -1

nixos/modules/services/databases/foundationdb.nix

···

       94
       94
        
           };

     

       95
       95
        
       

     

       96
       96
        
           listenPortStart = lib.mkOption {

     

       97
       97
       -
             type = lib.types.int;

     

       97
       97
       +
             type = lib.types.port;

     

       98
       98
        
             default = 4500;

     

       99
       99
        
             description = ''

     

       100
       100
        
               Starting port number for database listening sockets. Every FDB process binds to a

+1 -1

nixos/modules/services/misc/gitlab.nix

···

       638
       638
        
                 description = "External address used to access registry from the internet";

     

       639
       639
        
               };

     

       640
       640
        
               externalPort = mkOption {

     

       641
       641
       -
                 type = types.int;

     

       641
       641
       +
                 type = types.port;

     

       642
       642
        
                 description = "External port used to access registry from the internet";

     

       643
       643
        
               };

     

       644
       644
        
             };

+1 -1

nixos/modules/services/misc/homepage-dashboard.nix

···

       23
       23
        
             };

     

       24
       24
        
       

     

       25
       25
        
             listenPort = lib.mkOption {

     

       26
       26
       -
               type = lib.types.int;

     

       26
       26
       +
               type = lib.types.port;

     

       27
       27
        
               default = 8082;

     

       28
       28
        
               description = "Port for Homepage to bind to.";

     

       29
       29
        
             };

+1 -1

nixos/modules/services/misc/taskserver/default.nix

···

       329
       329
        
             };

     

       330
       330
        
       

     

       331
       331
        
             listenPort = lib.mkOption {

     

       332
       332
       -
               type = lib.types.int;

     

       332
       332
       +
               type = lib.types.port;

     

       333
       333
        
               default = 53589;

     

       334
       334
        
               description = ''

     

       335
       335
        
                 Port number of the Taskserver.

+1 -1

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

···

       22
       22
        
           };

     

       23
       23
        
       

     

       24
       24
        
           gatewayPort = mkOption {

     

       25
       25
       -
             type = types.int;

     

       25
       25
       +
             type = types.port;

     

       26
       26
        
             default = 49000;

     

       27
       27
        
             description = ''

     

       28
       28
        
               The port of the FRITZ!Box UPnP service.

+1 -1

nixos/modules/services/monitoring/statsd.nix

···

       110
       110
        
           graphitePort = lib.mkOption {

     

       111
       111
        
             description = "Port of Graphite server (i.e. carbon-cache).";

     

       112
       112
        
             default = null;

     

       113
       113
       -
             type = lib.types.nullOr lib.types.int;

     

       113
       113
       +
             type = lib.types.nullOr lib.types.port;

     

       114
       114
        
           };

     

       115
       115
        
       

     

       116
       116
        
           extraConfig = lib.mkOption {

+3 -3

nixos/modules/services/network-filesystems/nfsd.nix

···

       81
       81
        
               };

     

       82
       82
        
       

     

       83
       83
        
               mountdPort = lib.mkOption {

     

       84
       84
       -
                 type = lib.types.nullOr lib.types.int;

     

       84
       84
       +
                 type = lib.types.nullOr lib.types.port;

     

       85
       85
        
                 default = null;

     

       86
       86
        
                 example = 4002;

     

       87
       87
        
                 description = ''

     
···

       90
       90
        
               };

     

       91
       91
        
       

     

       92
       92
        
               lockdPort = lib.mkOption {

     

       93
       93
       -
                 type = lib.types.nullOr lib.types.int;

     

       93
       93
       +
                 type = lib.types.nullOr lib.types.port;

     

       94
       94
        
                 default = null;

     

       95
       95
        
                 example = 4001;

     

       96
       96
        
                 description = ''

     
···

       101
       101
        
               };

     

       102
       102
        
       

     

       103
       103
        
               statdPort = lib.mkOption {

     

       104
       104
       -
                 type = lib.types.nullOr lib.types.int;

     

       104
       104
       +
                 type = lib.types.nullOr lib.types.port;

     

       105
       105
        
                 default = null;

     

       106
       106
        
                 example = 4000;

     

       107
       107
        
                 description = ''

+1 -1

nixos/modules/services/network-filesystems/tahoe.nix

···

       140
       140
        
                   sftpd.enable = lib.mkEnableOption "SFTP service";

     

       141
       141
        
                   sftpd.port = lib.mkOption {

     

       142
       142
        
                     default = null;

     

       143
       143
       -
                     type = lib.types.nullOr lib.types.int;

     

       143
       143
       +
                     type = lib.types.nullOr lib.types.port;

     

       144
       144
        
                     description = ''

     

       145
       145
        
                       The port on which the SFTP server will listen.

     

       146
       146

+2 -2

nixos/modules/services/networking/3proxy.nix

···

       83
       83
        
                     '';

     

       84
       84
        
                   };

     

       85
       85
        
                   bindPort = lib.mkOption {

     

       86
       86
       -
                     type = lib.types.nullOr lib.types.int;

     

       86
       86
       +
                     type = lib.types.nullOr lib.types.port;

     

       87
       87
        
                     default = null;

     

       88
       88
        
                     example = 3128;

     

       89
       89
        
                     description = ''

     
···

       192
       192
        
                             '';

     

       193
       193
        
                           };

     

       194
       194
        
                           targetPorts = lib.mkOption {

     

       195
       195
       -
                             type = lib.types.listOf lib.types.int;

     

       195
       195
       +
                             type = lib.types.listOf lib.types.port;

     

       196
       196
        
                             default = [ ];

     

       197
       197
        
                             example = [

     

       198
       198
        
                               80

+1 -1

nixos/modules/services/networking/autossh.nix

···

       33
       33
        
                       description = "Name of the user the AutoSSH session should run as";

     

       34
       34
        
                     };

     

       35
       35
        
                     monitoringPort = lib.mkOption {

     

       36
       36
       -
                       type = lib.types.int;

     

       36
       36
       +
                       type = lib.types.port;

     

       37
       37
        
                       default = 0;

     

       38
       38
        
                       example = 20000;

     

       39
       39
        
                       description = ''

+7 -7

nixos/modules/services/networking/coturn.nix

···

       50
       50
        
           services.coturn = {

     

       51
       51
        
             enable = lib.mkEnableOption "coturn TURN server";

     

       52
       52
        
             listening-port = lib.mkOption {

     

       53
       53
       -
               type = lib.types.int;

     

       53
       53
       +
               type = lib.types.port;

     

       54
       54
        
               default = 3478;

     

       55
       55
        
               description = ''

     

       56
       56
        
                 TURN listener port for UDP and TCP.

     
···

       59
       59
        
               '';

     

       60
       60
        
             };

     

       61
       61
        
             tls-listening-port = lib.mkOption {

     

       62
       62
       -
               type = lib.types.int;

     

       62
       62
       +
               type = lib.types.port;

     

       63
       63
        
               default = 5349;

     

       64
       64
        
               description = ''

     

       65
       65
        
                 TURN listener port for TLS.

     
···

       74
       74
        
               '';

     

       75
       75
        
             };

     

       76
       76
        
             alt-listening-port = lib.mkOption {

     

       77
       77
       -
               type = lib.types.int;

     

       77
       77
       +
               type = lib.types.port;

     

       78
       78
        
               default = cfg.listening-port + 1;

     

       79
       79
        
               defaultText = lib.literalExpression "listening-port + 1";

     

       80
       80
        
               description = ''

     
···

       89
       89
        
               '';

     

       90
       90
        
             };

     

       91
       91
        
             alt-tls-listening-port = lib.mkOption {

     

       92
       92
       -
               type = lib.types.int;

     

       92
       92
       +
               type = lib.types.port;

     

       93
       93
        
               default = cfg.tls-listening-port + 1;

     

       94
       94
        
               defaultText = lib.literalExpression "tls-listening-port + 1";

     

       95
       95
        
               description = ''

     
···

       130
       130
        
               '';

     

       131
       131
        
             };

     

       132
       132
        
             min-port = lib.mkOption {

     

       133
       133
       -
               type = lib.types.int;

     

       133
       133
       +
               type = lib.types.port;

     

       134
       134
        
               default = 49152;

     

       135
       135
        
               description = ''

     

       136
       136
        
                 Lower bound of UDP relay endpoints

     

       137
       137
        
               '';

     

       138
       138
        
             };

     

       139
       139
        
             max-port = lib.mkOption {

     

       140
       140
       -
               type = lib.types.int;

     

       140
       140
       +
               type = lib.types.port;

     

       141
       141
        
               default = 65535;

     

       142
       142
        
               description = ''

     

       143
       143
        
                 Upper bound of UDP relay endpoints

     
···

       263
       263
        
               '';

     

       264
       264
        
             };

     

       265
       265
        
             cli-port = lib.mkOption {

     

       266
       266
       -
               type = lib.types.int;

     

       266
       266
       +
               type = lib.types.port;

     

       267
       267
        
               default = 5766;

     

       268
       268
        
               description = ''

     

       269
       269
        
                 CLI server port.

+3 -3

nixos/modules/services/networking/i2pd.nix

···

       667
       667
        
                 description = "Upstream outproxy bind address.";

     

       668
       668
        
               };

     

       669
       669
        
               outproxyPort = mkOption {

     

       670
       670
       -
                 type = types.int;

     

       670
       670
       +
                 type = types.port;

     

       671
       671
        
                 default = 4444;

     

       672
       672
        
                 description = "Upstream outproxy bind port.";

     

       673
       673
        
               };

     
···

       686
       686
        
                   {

     

       687
       687
        
                     options = {

     

       688
       688
        
                       destinationPort = mkOption {

     

       689
       689
       -
                         type = with types; nullOr int;

     

       689
       689
       +
                         type = with types; nullOr port;

     

       690
       690
        
                         default = null;

     

       691
       691
        
                         description = "Connect to particular port at destination.";

     

       692
       692
        
                       };

     
···

       711
       711
        
                   {

     

       712
       712
        
                     options = {

     

       713
       713
        
                       inPort = mkOption {

     

       714
       714
       -
                         type = types.int;

     

       714
       714
       +
                         type = types.port;

     

       715
       715
        
                         default = 0;

     

       716
       716
        
                         description = "Service port. Default to the tunnel's listen port.";

     

       717
       717
        
                       };

+2 -2

nixos/modules/services/networking/livekit-ingress.nix

···

       71
       71
        
       

     

       72
       72
        
                 rtc_config = {

     

       73
       73
        
                   port_range_start = lib.mkOption {

     

       74
       74
       -
                     type = lib.types.int;

     

       74
       74
       +
                     type = lib.types.port;

     

       75
       75
        
                     default = 50000;

     

       76
       76
        
                     description = "Start of UDP port range for WebRTC";

     

       77
       77
        
                   };

     

       78
       78
        
       

     

       79
       79
        
                   port_range_end = lib.mkOption {

     

       80
       80
       -
                     type = lib.types.int;

     

       80
       80
       +
                     type = lib.types.port;

     

       81
       81
        
                     default = 51000;

     

       82
       82
        
                     description = "End of UDP port range for WebRTC";

     

       83
       83
        
                   };

+2 -2

nixos/modules/services/networking/livekit.nix

···

       85
       85
        
       

     

       86
       86
        
                 rtc = {

     

       87
       87
        
                   port_range_start = lib.mkOption {

     

       88
       88
       -
                     type = lib.types.int;

     

       88
       88
       +
                     type = lib.types.port;

     

       89
       89
        
                     default = 50000;

     

       90
       90
        
                     description = "Start of UDP port range for WebRTC";

     

       91
       91
        
                   };

     

       92
       92
        
       

     

       93
       93
        
                   port_range_end = lib.mkOption {

     

       94
       94
       -
                     type = lib.types.int;

     

       94
       94
       +
                     type = lib.types.port;

     

       95
       95
        
                     default = 51000;

     

       96
       96
        
                     description = "End of UDP port range for WebRTC";

     

       97
       97
        
                   };

+1 -1

nixos/modules/services/networking/ntopng.nix

···

       80
       80
        
       

     

       81
       81
        
             httpPort = mkOption {

     

       82
       82
        
               default = 3000;

     

       83
       83
       -
               type = types.int;

     

       83
       83
       +
               type = types.port;

     

       84
       84
        
               description = ''

     

       85
       85
        
                 Sets the HTTP port of the embedded web server.

     

       86
       86
        
               '';

+2 -2

nixos/modules/services/networking/prosody.nix

···

       708
       708
        
       

     

       709
       709
        
             # HTTP server-related options

     

       710
       710
        
             httpPorts = mkOption {

     

       711
       711
       -
               type = types.listOf types.int;

     

       711
       711
       +
               type = types.listOf types.port;

     

       712
       712
        
               description = "Listening HTTP ports list for this service.";

     

       713
       713
        
               default = [ 5280 ];

     

       714
       714
        
             };

     
···

       723
       723
        
             };

     

       724
       724
        
       

     

       725
       725
        
             httpsPorts = mkOption {

     

       726
       726
       -
               type = types.listOf types.int;

     

       726
       726
       +
               type = types.listOf types.port;

     

       727
       727
        
               description = "Listening HTTPS ports list for this service.";

     

       728
       728
        
               default = [ 5281 ];

     

       729
       729
        
             };

+2 -2

nixos/modules/services/networking/resilio.nix

···

       113
       113
        
             };

     

       114
       114
        
       

     

       115
       115
        
             listeningPort = mkOption {

     

       116
       116
       -
               type = types.int;

     

       116
       116
       +
               type = types.port;

     

       117
       117
        
               default = 0;

     

       118
       118
        
               example = 44444;

     

       119
       119
        
               description = ''

     
···

       166
       166
        
             };

     

       167
       167
        
       

     

       168
       168
        
             httpListenPort = mkOption {

     

       169
       169
       -
               type = types.int;

     

       169
       169
       +
               type = types.port;

     

       170
       170
        
               default = 9000;

     

       171
       171
        
               description = ''

     

       172
       172
        
                 HTTP port to bind on.

+1 -1

nixos/modules/services/networking/squid.nix

···

       145
       145
        
             };

     

       146
       146
        
       

     

       147
       147
        
             proxyPort = mkOption {

     

       148
       148
       -
               type = types.int;

     

       148
       148
       +
               type = types.port;

     

       149
       149
        
               default = 3128;

     

       150
       150
        
               description = "TCP port on which squid will listen.";

     

       151
       151
        
             };

+1 -1

nixos/modules/services/networking/syncthing.nix

···

       336
       336
        
                           };

     

       337
       337
        
       

     

       338
       338
        
                           localAnnouncePort = mkOption {

     

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

     

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

     

       340
       340
        
                             default = null;

     

       341
       341
        
                             description = ''

     

       342
       342
        
                               The port on which to listen and send IPv4 broadcast announcements to.

+1 -1

nixos/modules/services/networking/websockify.nix

···

       36
       36
        
             portMap = mkOption {

     

       37
       37
        
               description = "Ports to map by default.";

     

       38
       38
        
               default = { };

     

       39
       39
       -
               type = types.attrsOf types.int;

     

       39
       39
       +
               type = types.attrsOf types.port;

     

       40
       40
        
             };

     

       41
       41
        
           };

     

       42
       42
        
         };

+1 -1

nixos/modules/services/networking/zerobin.nix

···

       44
       44
        
             };

     

       45
       45
        
       

     

       46
       46
        
             listenPort = mkOption {

     

       47
       47
       -
               type = types.int;

     

       47
       47
       +
               type = types.port;

     

       48
       48
        
               default = 8000;

     

       49
       49
        
               example = 1357;

     

       50
       50
        
               description = ''

+1 -1

nixos/modules/services/search/elasticsearch.nix

···

       72
       72
        
           tcp_port = mkOption {

     

       73
       73
        
             description = "Elasticsearch port for the node to node communication.";

     

       74
       74
        
             default = 9300;

     

       75
       75
       -
             type = types.int;

     

       75
       75
       +
             type = types.port;

     

       76
       76
        
           };

     

       77
       77
        
       

     

       78
       78
        
           cluster_name = mkOption {

+2 -2

nixos/modules/services/security/shibboleth-sp.nix

···

       30
       30
        
             };

     

       31
       31
        
       

     

       32
       32
        
             fastcgi.shibAuthorizerPort = lib.mkOption {

     

       33
       33
       -
               type = lib.types.int;

     

       33
       33
       +
               type = lib.types.port;

     

       34
       34
        
               default = 9100;

     

       35
       35
        
               description = "Port for shibauthorizer FastCGI process to bind to";

     

       36
       36
        
             };

     

       37
       37
        
       

     

       38
       38
        
             fastcgi.shibResponderPort = lib.mkOption {

     

       39
       39
       -
               type = lib.types.int;

     

       39
       39
       +
               type = lib.types.port;

     

       40
       40
        
               default = 9101;

     

       41
       41
        
               description = "Port for shibauthorizer FastCGI process to bind to";

     

       42
       42
        
             };

+1 -1

nixos/modules/services/web-apps/anuko-time-tracker.nix

···

       225
       225
        
               };

     

       226
       226
        
       

     

       227
       227
        
               smtpPort = lib.mkOption {

     

       228
       228
       -
                 type = lib.types.int;

     

       228
       228
       +
                 type = lib.types.port;

     

       229
       229
        
                 description = "MTA port.";

     

       230
       230
        
                 default = 25;

     

       231
       231
        
               };

+2 -2

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

···

       75
       75
        
                   description = "Address on which the Node.js server should listen";

     

       76
       76
        
                 };

     

       77
       77
        
                 httpPort = mkOption {

     

       78
       78
       -
                   type = types.int;

     

       78
       78
       +
                   type = types.port;

     

       79
       79
        
                   default = 3000;

     

       80
       80
        
                   description = "Port on which the Node.js server should listen";

     

       81
       81
        
                 };

     

       82
       82
        
                 websocketPort = mkOption {

     

       83
       83
       -
                   type = types.int;

     

       83
       83
       +
                   type = types.port;

     

       84
       84
        
                   default = 3003;

     

       85
       85
        
                   description = "Port for the websocket that needs to be separate";

     

       86
       86
        
                 };

+1 -1

nixos/modules/services/web-apps/kasmweb/default.nix

···

       102
       102
        
           };

     

       103
       103
        
       

     

       104
       104
        
           listenPort = lib.mkOption {

     

       105
       105
       -
             type = lib.types.int;

     

       105
       105
       +
             type = lib.types.port;

     

       106
       106
        
             default = 443;

     

       107
       107
        
             description = ''

     

       108
       108
        
               The port on which kasmweb should listen.

+1 -1

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

···

       46
       46
        
             };

     

       47
       47
        
       

     

       48
       48
        
             listenPort = mkOption {

     

       49
       49
       -
               type = types.int;

     

       49
       49
       +
               type = types.port;

     

       50
       50
        
               default = 8081;

     

       51
       51
        
               description = "Port to listen on.";

     

       52
       52
        
             };

+2 -2

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

···

       69
       69
        
             };

     

       70
       70
        
       

     

       71
       71
        
             listenPort = lib.mkOption {

     

       72
       72
       -
               type = lib.types.int;

     

       72
       72
       +
               type = lib.types.port;

     

       73
       73
        
               default = if cfg.enableHTTPS then 8443 else 8080;

     

       74
       74
        
               defaultText = lib.literalExpression ''

     

       75
       75
        
                 if config.${opt.enableHTTPS}

     
···

       91
       91
        
             };

     

       92
       92
        
       

     

       93
       93
        
             proxyPort = lib.mkOption {

     

       94
       94
       -
               type = lib.types.nullOr lib.types.int;

     

       94
       94
       +
               type = lib.types.nullOr lib.types.port;

     

       95
       95
        
               default = if cfg.enableHTTPS then 8443 else null;

     

       96
       96
        
               defaultText = lib.literalExpression ''

     

       97
       97
        
                 if config.${opt.enableHTTPS}

+1 -1

nixos/modules/services/web-apps/pgpkeyserver-lite.nix

···

       47
       47
        
             hkpPort = mkOption {

     

       48
       48
        
               default = sksCfg.hkpPort;

     

       49
       49
        
               defaultText = literalExpression "config.${sksOpt.hkpPort}";

     

       50
       50
       -
               type = types.int;

     

       50
       50
       +
               type = types.port;

     

       51
       51
        
               description = ''

     

       52
       52
        
                 Which port the sks-keyserver is listening on.

     

       53
       53
        
               '';

+1 -1

nixos/modules/services/web-apps/plantuml-server.nix

···

       75
       75
        
             };

     

       76
       76
        
       

     

       77
       77
        
             listenPort = mkOption {

     

       78
       78
       -
               type = types.int;

     

       78
       78
       +
               type = types.port;

     

       79
       79
        
               default = 8080;

     

       80
       80
        
               description = "Port to listen on.";

     

       81
       81
        
             };

+1 -1

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

···

       24
       24
        
             };

     

       25
       25
        
       

     

       26
       26
        
             listenPort = lib.mkOption {

     

       27
       27
       -
               type = lib.types.int;

     

       27
       27
       +
               type = lib.types.port;

     

       28
       28
        
               default = 3000;

     

       29
       29
        
               description = "Port to listen on.";

     

       30
       30
        
             };

+2 -2

nixos/modules/virtualisation/nixos-containers.nix

···

       416
       416
        
                     description = "The protocol specifier for port forwarding between host and container";

     

       417
       417
        
                   };

     

       418
       418
        
                   hostPort = mkOption {

     

       419
       419
       -
                     type = types.int;

     

       419
       419
       +
                     type = types.port;

     

       420
       420
        
                     description = "Source port of the external interface on host";

     

       421
       421
        
                   };

     

       422
       422
        
                   containerPort = mkOption {

     

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

     

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

     

       424
       424
        
                     default = null;

     

       425
       425
        
                     description = "Target port of container";

     

       426
       426
        
                   };