···

       
8
       
 
       
  options = {

     

       
9
       
 
       
    hardware.brillo = {

     

       
10
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
11
       
-
       
        Enable brillo in userspace.

     

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

     

       
13
       
 
       
      '');

     

       
14
       
 
       
    };

     

       
15
       
 
       
  };

     

       
16
       
-
       


     

       
17
       
 
       


     

       
18
       
 
       
  config = mkIf cfg.enable {

     

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

     

···

       
8
       
 
       
  options = {

     

       
9
       
 
       
    hardware.brillo = {

     

       
10
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

       
11
       
+
       
        brillo in userspace.

     

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

     

       
13
       
 
       
      '');

     

       
14
       
 
       
    };

     

       
15
       
 
       
  };

     

       
0
       
 
       

     

       
16
       
 
       


     

       
17
       
 
       
  config = mkIf cfg.enable {

     

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

     

···

       
10
       
 
       
  };

     

       
11
       
 
       
in {

     

       
12
       
 
       
  options.hardware.ubertooth = {

     

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

     

       
14
       
 
       


     

       
15
       
 
       
    group = mkOption {

     

       
16
       
 
       
      type = types.str;

     

···

       
10
       
 
       
  };

     

       
11
       
 
       
in {

     

       
12
       
 
       
  options.hardware.ubertooth = {

     

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

     

       
14
       
 
       


     

       
15
       
 
       
    group = mkOption {

     

       
16
       
 
       
      type = types.str;

     

···

       
3
       
 
       
with lib;

     

       
4
       
 
       
{

     

       
5
       
 
       
  options.hardware.wooting.enable =

     

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

     

       
7
       
 
       


     

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

     

       
9
       
 
       
    environment.systemPackages = [ pkgs.wootility ];

     

···

       
3
       
 
       
with lib;

     

       
4
       
 
       
{

     

       
5
       
 
       
  options.hardware.wooting.enable =

     

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

     

       
7
       
 
       


     

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

     

       
9
       
 
       
    environment.systemPackages = [ pkgs.wootility ];

     

···

       
4
       
 
       
  cfg = config.programs.kclock;

     

       
5
       
 
       
  kclockPkg = pkgs.libsForQt5.kclock;

     

       
6
       
 
       
in {

     

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

     

       
8
       
 
       


     

       
9
       
 
       
  config = mkIf cfg.enable {

     

       
10
       
 
       
    services.dbus.packages = [ kclockPkg ];

     

···

       
4
       
 
       
  cfg = config.programs.kclock;

     

       
5
       
 
       
  kclockPkg = pkgs.libsForQt5.kclock;

     

       
6
       
 
       
in {

     

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

     

       
8
       
 
       


     

       
9
       
 
       
  config = mkIf cfg.enable {

     

       
10
       
 
       
    services.dbus.packages = [ kclockPkg ];

     

···

       
29
       
 
       
        };

     

       
30
       
 
       


     

       
31
       
 
       
        port = mkOption {

     

       
32
       
-
       
          type = types.int;

     

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

     

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

     

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

     

···

       
29
       
 
       
        };

     

       
30
       
 
       


     

       
31
       
 
       
        port = mkOption {

     

       
32
       
+
       
          type = types.port;

     

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

     

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

     

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

     

···

       
314
       
 
       


     

       
315
       
 
       
      port = mkOption {

     

       
316
       
 
       
        default = 9102;

     

       
317
       
-
       
        type = types.int;

     

       
318
       
 
       
        description = lib.mdDoc ''

     

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

     

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

     
···

       
374
       
 
       


     

       
375
       
 
       
      port = mkOption {

     

       
376
       
 
       
        default = 9103;

     

       
377
       
-
       
        type = types.int;

     

       
378
       
 
       
        description = lib.mdDoc ''

     

       
379
       
 
       
          Specifies port number on which the Storage daemon listens for

     

       
380
       
 
       
          Director connections.

     
···

       
451
       
 
       


     

       
452
       
 
       
      port = mkOption {

     

       
453
       
 
       
        default = 9101;

     

       
454
       
-
       
        type = types.int;

     

       
455
       
 
       
        description = lib.mdDoc ''

     

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

     

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

     

···

       
314
       
 
       


     

       
315
       
 
       
      port = mkOption {

     

       
316
       
 
       
        default = 9102;

     

       
317
       
+
       
        type = types.port;

     

       
318
       
 
       
        description = lib.mdDoc ''

     

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

     

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

     
···

       
374
       
 
       


     

       
375
       
 
       
      port = mkOption {

     

       
376
       
 
       
        default = 9103;

     

       
377
       
+
       
        type = types.port;

     

       
378
       
 
       
        description = lib.mdDoc ''

     

       
379
       
 
       
          Specifies port number on which the Storage daemon listens for

     

       
380
       
 
       
          Director connections.

     
···

       
451
       
 
       


     

       
452
       
 
       
      port = mkOption {

     

       
453
       
 
       
        default = 9101;

     

       
454
       
+
       
        type = types.port;

     

       
455
       
 
       
        description = lib.mdDoc ''

     

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

     

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

     

···

       
12
       
 
       


     

       
13
       
 
       
      port = mkOption {

     

       
14
       
 
       
        default = 8200;

     

       
15
       
-
       
        type = types.int;

     

       
16
       
 
       
        description = lib.mdDoc ''

     

       
17
       
 
       
          Port serving the web interface

     

       
18
       
 
       
        '';

     

···

       
12
       
 
       


     

       
13
       
 
       
      port = mkOption {

     

       
14
       
 
       
        default = 8200;

     

       
15
       
+
       
        type = types.port;

     

       
16
       
 
       
        description = lib.mdDoc ''

     

       
17
       
 
       
          Port serving the web interface

     

       
18
       
 
       
        '';

     

···

       
12
       
 
       
{

     

       
13
       
 
       
  ###### interface

     

       
14
       
 
       
  options.services.kubernetes.flannel = {

     

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

     

       
16
       
 
       
  };

     

       
17
       
 
       


     

       
18
       
 
       
  ###### implementation

     

···

       
12
       
 
       
{

     

       
13
       
 
       
  ###### interface

     

       
14
       
 
       
  options.services.kubernetes.flannel = {

     

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

     

       
16
       
 
       
  };

     

       
17
       
 
       


     

       
18
       
 
       
  ###### implementation

     

···

       
18
       
 
       
    '')

     

       
19
       
 
       
  ];

     

       
20
       
 
       
  options.services.foldingathome = {

     

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

     

       
22
       
 
       


     

       
23
       
 
       
    package = mkOption {

     

       
24
       
 
       
      type = types.package;

     

···

       
18
       
 
       
    '')

     

       
19
       
 
       
  ];

     

       
20
       
 
       
  options.services.foldingathome = {

     

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

     

       
22
       
 
       


     

       
23
       
 
       
    package = mkOption {

     

       
24
       
 
       
      type = types.package;

     

···

       
34
       
 
       


     

       
35
       
 
       
    services.couchdb = {

     

       
36
       
 
       


     

       
37
       
-
       
      enable = mkOption {

     

       
38
       
-
       
        type = types.bool;

     

       
39
       
-
       
        default = false;

     

       
40
       
-
       
        description = lib.mdDoc ''

     

       
41
       
-
       
          Whether to run CouchDB Server.

     

       
42
       
-
       
        '';

     

       
43
       
-
       
      };

     

       
44
       
 
       


     

       
45
       
 
       
      package = mkOption {

     

       
46
       
 
       
        type = types.package;

     

···

       
34
       
 
       


     

       
35
       
 
       
    services.couchdb = {

     

       
36
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
38
       
 
       


     

       
39
       
 
       
      package = mkOption {

     

       
40
       
 
       
        type = types.package;

     

···

       
15
       
 
       


     

       
16
       
 
       
    services.opentsdb = {

     

       
17
       
 
       


     

       
18
       
-
       
      enable = mkOption {

     

       
19
       
-
       
        type = types.bool;

     

       
20
       
-
       
        default = false;

     

       
21
       
-
       
        description = lib.mdDoc ''

     

       
22
       
-
       
          Whether to run OpenTSDB.

     

       
23
       
-
       
        '';

     

       
24
       
-
       
      };

     

       
25
       
 
       


     

       
26
       
 
       
      package = mkOption {

     

       
27
       
 
       
        type = types.package;

     
···

       
49
       
 
       
      };

     

       
50
       
 
       


     

       
51
       
 
       
      port = mkOption {

     

       
52
       
-
       
        type = types.int;

     

       
53
       
 
       
        default = 4242;

     

       
54
       
 
       
        description = lib.mdDoc ''

     

       
55
       
 
       
          Which port OpenTSDB listens on.

     

···

       
15
       
 
       


     

       
16
       
 
       
    services.opentsdb = {

     

       
17
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
19
       
 
       


     

       
20
       
 
       
      package = mkOption {

     

       
21
       
 
       
        type = types.package;

     
···

       
43
       
 
       
      };

     

       
44
       
 
       


     

       
45
       
 
       
      port = mkOption {

     

       
46
       
+
       
        type = types.port;

     

       
47
       
 
       
        default = 4242;

     

       
48
       
 
       
        description = lib.mdDoc ''

     

       
49
       
 
       
          Which port OpenTSDB listens on.

     

···

       
85
       
 
       
    };

     

       
86
       
 
       


     

       
87
       
 
       
    port = mkOption {

     

       
88
       
-
       
      type = types.int;

     

       
89
       
 
       
      default = 8080;

     

       
90
       
 
       
      description = lib.mdDoc ''

     

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

     

···

       
85
       
 
       
    };

     

       
86
       
 
       


     

       
87
       
 
       
    port = mkOption {

     

       
88
       
+
       
      type = types.port;

     

       
89
       
 
       
      default = 8080;

     

       
90
       
 
       
      description = lib.mdDoc ''

     

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

     

···

       
70
       
 
       
      };

     

       
71
       
 
       


     

       
72
       
 
       
      port = mkOption {

     

       
73
       
-
       
        type = types.int;

     

       
74
       
 
       
        default = 8303;

     

       
75
       
 
       
        description = lib.mdDoc ''

     

       
76
       
 
       
          Port the server will listen on.

     

···

       
70
       
 
       
      };

     

       
71
       
 
       


     

       
72
       
 
       
      port = mkOption {

     

       
73
       
+
       
        type = types.port;

     

       
74
       
 
       
        default = 8303;

     

       
75
       
 
       
        description = lib.mdDoc ''

     

       
76
       
 
       
          Port the server will listen on.

     

···

       
18
       
 
       
  ];

     

       
19
       
 
       


     

       
20
       
 
       
  options.services.zigbee2mqtt = {

     

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

     

       
22
       
 
       


     

       
23
       
 
       
    package = mkOption {

     

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

     

···

       
18
       
 
       
  ];

     

       
19
       
 
       


     

       
20
       
 
       
  options.services.zigbee2mqtt = {

     

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

     

       
22
       
 
       


     

       
23
       
 
       
    package = mkOption {

     

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

     

···

       
12
       
 
       
  options = {

     

       
13
       
 
       


     

       
14
       
 
       
    services.fluentd = {

     

       
15
       
-
       
      enable = mkOption {

     

       
16
       
-
       
        type = types.bool;

     

       
17
       
-
       
        default = false;

     

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

     

       
19
       
-
       
      };

     

       
20
       
 
       


     

       
21
       
 
       
      config = mkOption {

     

       
22
       
 
       
        type = types.lines;

     

···

       
12
       
 
       
  options = {

     

       
13
       
 
       


     

       
14
       
 
       
    services.fluentd = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
16
       
 
       


     

       
17
       
 
       
      config = mkOption {

     

       
18
       
 
       
        type = types.lines;

     

···

       
109
       
 
       
{

     

       
110
       
 
       
  options = {

     

       
111
       
 
       
    services.logcheck = {

     

       
112
       
-
       
      enable = mkOption {

     

       
113
       
-
       
        default = false;

     

       
114
       
-
       
        type = types.bool;

     

       
115
       
-
       
        description = lib.mdDoc ''

     

       
116
       
-
       
          Enable the logcheck cron job.

     

       
117
       
-
       
        '';

     

       
118
       
-
       
      };

     

       
119
       
 
       


     

       
120
       
 
       
      user = mkOption {

     

       
121
       
 
       
        default = "logcheck";

     

···

       
109
       
 
       
{

     

       
110
       
 
       
  options = {

     

       
111
       
 
       
    services.logcheck = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
113
       
 
       


     

       
114
       
 
       
      user = mkOption {

     

       
115
       
 
       
        default = "logcheck";

     

···

       
48
       
 
       
      };

     

       
49
       
 
       


     

       
50
       
 
       
      port = mkOption {

     

       
51
       
-
       
        type = types.int;

     

       
52
       
 
       
        default = 4040;

     

       
53
       
 
       
        description = lib.mdDoc ''

     

       
54
       
 
       
          The port on which Airsonic will listen for

     

···

       
48
       
 
       
      };

     

       
49
       
 
       


     

       
50
       
 
       
      port = mkOption {

     

       
51
       
+
       
        type = types.port;

     

       
52
       
 
       
        default = 4040;

     

       
53
       
 
       
        description = lib.mdDoc ''

     

       
54
       
 
       
          The port on which Airsonic will listen for

     

···

       
44
       
 
       
      };

     

       
45
       
 
       


     

       
46
       
 
       
      port = mkOption {

     

       
47
       
-
       
        type = types.int;

     

       
48
       
 
       
        default = 27701;

     

       
49
       
 
       
        description = lib.mdDoc "ankisyncd port";

     

       
50
       
 
       
      };

     

···

       
44
       
 
       
      };

     

       
45
       
 
       


     

       
46
       
 
       
      port = mkOption {

     

       
47
       
+
       
        type = types.port;

     

       
48
       
 
       
        default = 27701;

     

       
49
       
 
       
        description = lib.mdDoc "ankisyncd port";

     

       
50
       
 
       
      };

     

···

       
40
       
 
       
    port = mkOption {

     

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

     

       
42
       
 
       
      default = 9092;

     

       
43
       
-
       
      type = types.int;

     

       
44
       
 
       
    };

     

       
45
       
 
       


     

       
46
       
 
       
    hostname = mkOption {

     

···

       
40
       
 
       
    port = mkOption {

     

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

     

       
42
       
 
       
      default = 9092;

     

       
43
       
+
       
      type = types.port;

     

       
44
       
 
       
    };

     

       
45
       
 
       


     

       
46
       
 
       
    hostname = mkOption {

     

···

       
68
       
 
       
{

     

       
69
       
 
       
  options = {

     

       
70
       
 
       
    services.exhibitor = {

     

       
71
       
-
       
      enable = mkOption {

     

       
72
       
-
       
        type = types.bool;

     

       
73
       
-
       
        default = false;

     

       
74
       
-
       
        description = lib.mdDoc ''

     

       
75
       
-
       
          Whether to enable the exhibitor server.

     

       
76
       
-
       
        '';

     

       
77
       
-
       
      };

     

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

     

       
79
       
 
       
      # General options for any type of config

     

       
80
       
 
       
      port = mkOption {

     

       
81
       
-
       
        type = types.int;

     

       
82
       
 
       
        default = 8080;

     

       
83
       
 
       
        description = lib.mdDoc ''

     

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

     

···

       
68
       
 
       
{

     

       
69
       
 
       
  options = {

     

       
70
       
 
       
    services.exhibitor = {

     

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

     

       
72
       
+
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
74
       
 
       
      # General options for any type of config

     

       
75
       
 
       
      port = mkOption {

     

       
76
       
+
       
        type = types.port;

     

       
77
       
 
       
        default = 8080;

     

       
78
       
 
       
        description = lib.mdDoc ''

     

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

     

···

       
90
       
 
       
        };

     

       
91
       
 
       


     

       
92
       
 
       
        port = mkOption {

     

       
93
       
-
       
          type = types.int;

     

       
94
       
 
       
          default = 3306;

     

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

     

       
96
       
 
       
        };

     
···

       
167
       
 
       
      };

     

       
168
       
 
       


     

       
169
       
 
       
      httpPort = mkOption {

     

       
170
       
-
       
        type = types.int;

     

       
171
       
 
       
        default = 3000;

     

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

     

       
173
       
 
       
      };

     

···

       
90
       
 
       
        };

     

       
91
       
 
       


     

       
92
       
 
       
        port = mkOption {

     

       
93
       
+
       
          type = types.port;

     

       
94
       
 
       
          default = 3306;

     

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

     

       
96
       
 
       
        };

     
···

       
167
       
 
       
      };

     

       
168
       
 
       


     

       
169
       
 
       
      httpPort = mkOption {

     

       
170
       
+
       
        type = types.port;

     

       
171
       
 
       
        default = 3000;

     

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

     

       
173
       
 
       
      };

     

···

       
8
       
 
       


     

       
9
       
 
       
{

     

       
10
       
 
       
  options.services.gollum = {

     

       
11
       
-
       
    enable = mkOption {

     

       
12
       
-
       
      type = types.bool;

     

       
13
       
-
       
      default = false;

     

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

     

       
15
       
-
       
    };

     

       
16
       
 
       


     

       
17
       
 
       
    address = mkOption {

     

       
18
       
 
       
      type = types.str;

     
···

       
21
       
 
       
    };

     

       
22
       
 
       


     

       
23
       
 
       
    port = mkOption {

     

       
24
       
-
       
      type = types.int;

     

       
25
       
 
       
      default = 4567;

     

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

     

       
27
       
 
       
    };

     

···

       
8
       
 
       


     

       
9
       
 
       
{

     

       
10
       
 
       
  options.services.gollum = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
12
       
 
       


     

       
13
       
 
       
    address = mkOption {

     

       
14
       
 
       
      type = types.str;

     
···

       
17
       
 
       
    };

     

       
18
       
 
       


     

       
19
       
 
       
    port = mkOption {

     

       
20
       
+
       
      type = types.port;

     

       
21
       
 
       
      default = 4567;

     

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

     

       
23
       
 
       
    };

     

···

       
70
       
 
       
      };

     

       
71
       
 
       


     

       
72
       
 
       
      port = mkOption {

     

       
73
       
-
       
        type = types.int;

     

       
74
       
 
       
        default = 8000;

     

       
75
       
 
       
        description = lib.mdDoc ''

     

       
76
       
 
       
          Port to listen on.

     

···

       
70
       
 
       
      };

     

       
71
       
 
       


     

       
72
       
 
       
      port = mkOption {

     

       
73
       
+
       
        type = types.port;

     

       
74
       
 
       
        default = 8000;

     

       
75
       
 
       
        description = lib.mdDoc ''

     

       
76
       
 
       
          Port to listen on.

     

···

       
28
       
 
       
      };

     

       
29
       
 
       


     

       
30
       
 
       
      port = mkOption {

     

       
31
       
-
       
        type = types.int;

     

       
32
       
 
       
        default = 1688;

     

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

     

       
34
       
 
       
      };

     

···

       
28
       
 
       
      };

     

       
29
       
 
       


     

       
30
       
 
       
      port = mkOption {

     

       
31
       
+
       
        type = types.port;

     

       
32
       
 
       
        default = 1688;

     

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

     

       
34
       
 
       
      };

     

···

       
161
       
 
       
        };

     

       
162
       
 
       


     

       
163
       
 
       
        port = mkOption {

     

       
164
       
-
       
          type = types.int;

     

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

     

       
166
       
 
       
          defaultText = literalExpression "3306";

     

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

     

···

       
161
       
 
       
        };

     

       
162
       
 
       


     

       
163
       
 
       
        port = mkOption {

     

       
164
       
+
       
          type = types.port;

     

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

     

       
166
       
 
       
          defaultText = literalExpression "3306";

     

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

     

···

       
98
       
 
       


     

       
99
       
 
       
      port = mkOption {

     

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

     

       
101
       
-
       
        type = types.int;

     

       
102
       
 
       
      };

     

       
103
       
 
       


     

       
104
       
 
       
      protocol = mkOption {

     

···

       
98
       
 
       


     

       
99
       
 
       
      port = mkOption {

     

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

     

       
101
       
+
       
        type = types.port;

     

       
102
       
 
       
      };

     

       
103
       
 
       


     

       
104
       
 
       
      protocol = mkOption {

     

···

       
27
       
 
       
      };

     

       
28
       
 
       


     

       
29
       
 
       
      port = mkOption {

     

       
30
       
-
       
        type = types.int;

     

       
31
       
 
       
        default = 8181;

     

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

     

       
33
       
 
       
      };

     

···

       
27
       
 
       
      };

     

       
28
       
 
       


     

       
29
       
 
       
      port = mkOption {

     

       
30
       
+
       
        type = types.port;

     

       
31
       
 
       
        default = 8181;

     

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

     

       
33
       
 
       
      };

     

···

       
97
       
 
       
      };

     

       
98
       
 
       


     

       
99
       
 
       
      port = mkOption {

     

       
100
       
-
       
        type = types.int;

     

       
101
       
 
       
        default = 8095;

     

       
102
       
 
       
        description = lib.mdDoc ''

     

       
103
       
 
       
          The port on which to listen.

     

···

       
97
       
 
       
      };

     

       
98
       
 
       


     

       
99
       
 
       
      port = mkOption {

     

       
100
       
+
       
        type = types.port;

     

       
101
       
 
       
        default = 8095;

     

       
102
       
 
       
        description = lib.mdDoc ''

     

       
103
       
 
       
          The port on which to listen.

     

···

       
24
       
 
       
in {

     

       
25
       
 
       


     

       
26
       
 
       
  options.services.zookeeper = {

     

       
27
       
-
       
    enable = mkOption {

     

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

     

       
29
       
-
       
      default = false;

     

       
30
       
-
       
      type = types.bool;

     

       
31
       
-
       
    };

     

       
32
       
 
       


     

       
33
       
 
       
    port = mkOption {

     

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

     

       
35
       
 
       
      default = 2181;

     

       
36
       
-
       
      type = types.int;

     

       
37
       
 
       
    };

     

       
38
       
 
       


     

       
39
       
 
       
    id = mkOption {

     

···

       
24
       
 
       
in {

     

       
25
       
 
       


     

       
26
       
 
       
  options.services.zookeeper = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
28
       
 
       


     

       
29
       
 
       
    port = mkOption {

     

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

     

       
31
       
 
       
      default = 2181;

     

       
32
       
+
       
      type = types.port;

     

       
33
       
 
       
    };

     

       
34
       
 
       


     

       
35
       
 
       
    id = mkOption {

     

···

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

     

       
25
       
 
       


     

       
26
       
 
       
    port = mkOption {

     

       
27
       
-
       
      type = types.int;

     

       
28
       
 
       
      default = 5000;

     

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

     

       
30
       
 
       
    };

     

···

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

     

       
25
       
 
       


     

       
26
       
 
       
    port = mkOption {

     

       
27
       
+
       
      type = types.port;

     

       
28
       
 
       
      default = 5000;

     

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

     

       
30
       
 
       
    };

     

···

       
7
       
 
       
in {

     

       
8
       
 
       
  options = {

     

       
9
       
 
       
    services.arbtt = {

     

       
10
       
-
       
      enable = mkOption {

     

       
11
       
-
       
        type = types.bool;

     

       
12
       
-
       
        default = false;

     

       
13
       
-
       
        description = lib.mdDoc ''

     

       
14
       
-
       
          Enable the arbtt statistics capture service.

     

       
15
       
-
       
        '';

     

       
16
       
-
       
      };

     

       
17
       
 
       


     

       
18
       
 
       
      package = mkOption {

     

       
19
       
 
       
        type = types.package;

     

···

       
7
       
 
       
in {

     

       
8
       
 
       
  options = {

     

       
9
       
 
       
    services.arbtt = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
11
       
 
       


     

       
12
       
 
       
      package = mkOption {

     

       
13
       
 
       
        type = types.package;

     

···

       
22
       
 
       


     

       
23
       
 
       
    services.bosun = {

     

       
24
       
 
       


     

       
25
       
-
       
      enable = mkOption {

     

       
26
       
-
       
        type = types.bool;

     

       
27
       
-
       
        default = false;

     

       
28
       
-
       
        description = lib.mdDoc ''

     

       
29
       
-
       
          Whether to run bosun.

     

       
30
       
-
       
        '';

     

       
31
       
-
       
      };

     

       
32
       
 
       


     

       
33
       
 
       
      package = mkOption {

     

       
34
       
 
       
        type = types.package;

     

···

       
22
       
 
       


     

       
23
       
 
       
    services.bosun = {

     

       
24
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
26
       
 
       


     

       
27
       
 
       
      package = mkOption {

     

       
28
       
 
       
        type = types.package;

     

···

       
8
       
 
       
in {

     

       
9
       
 
       
  options = {

     

       
10
       
 
       
    services.cadvisor = {

     

       
11
       
-
       
      enable = mkOption {

     

       
12
       
-
       
        default = false;

     

       
13
       
-
       
        type = types.bool;

     

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

     

       
15
       
-
       
      };

     

       
16
       
 
       


     

       
17
       
 
       
      listenAddress = mkOption {

     

       
18
       
 
       
        default = "127.0.0.1";

     
···

       
22
       
 
       


     

       
23
       
 
       
      port = mkOption {

     

       
24
       
 
       
        default = 8080;

     

       
25
       
-
       
        type = types.int;

     

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

     

       
27
       
 
       
      };

     

       
28
       
 
       


     

···

       
8
       
 
       
in {

     

       
9
       
 
       
  options = {

     

       
10
       
 
       
    services.cadvisor = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
12
       
 
       


     

       
13
       
 
       
      listenAddress = mkOption {

     

       
14
       
 
       
        default = "127.0.0.1";

     
···

       
18
       
 
       


     

       
19
       
 
       
      port = mkOption {

     

       
20
       
 
       
        default = 8080;

     

       
21
       
+
       
        type = types.port;

     

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

     

       
23
       
 
       
      };

     

       
24
       
 
       


     

···

       
49
       
 
       
  };

     

       
50
       
 
       
in {

     

       
51
       
 
       
  options.services.datadog-agent = {

     

       
52
       
-
       
    enable = mkOption {

     

       
53
       
-
       
      description = lib.mdDoc ''

     

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

     

       
55
       
-
       
      '';

     

       
56
       
-
       
      default = false;

     

       
57
       
-
       
      type = types.bool;

     

       
58
       
-
       
    };

     

       
59
       
 
       


     

       
60
       
 
       
    package = mkOption {

     

       
61
       
 
       
      default = pkgs.datadog-agent;

     

···

       
49
       
 
       
  };

     

       
50
       
 
       
in {

     

       
51
       
 
       
  options.services.datadog-agent = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
53
       
 
       


     

       
54
       
 
       
    package = mkOption {

     

       
55
       
 
       
      default = pkgs.datadog-agent;

     

···

       
23
       
 
       
      port = mkOption {

     

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

     

       
25
       
 
       
        default = 3000;

     

       
26
       
-
       
        type = types.int;

     

       
27
       
 
       
      };

     

       
28
       
 
       


     

       
29
       
 
       
    };

     
···

       
36
       
 
       
    port = mkOption {

     

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

     

       
38
       
 
       
      default = 8686;

     

       
39
       
-
       
      type = types.int;

     

       
40
       
 
       
    };

     

       
41
       
 
       


     

       
42
       
 
       
    templateDir = mkOption {

     

···

       
23
       
 
       
      port = mkOption {

     

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

     

       
25
       
 
       
        default = 3000;

     

       
26
       
+
       
        type = types.port;

     

       
27
       
 
       
      };

     

       
28
       
 
       


     

       
29
       
 
       
    };

     
···

       
36
       
 
       
    port = mkOption {

     

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

     

       
38
       
 
       
      default = 8686;

     

       
39
       
+
       
      type = types.port;

     

       
40
       
 
       
    };

     

       
41
       
 
       


     

       
42
       
 
       
    templateDir = mkOption {

     

···

       
6
       
 
       
  cfg = config.services.heapster;

     

       
7
       
 
       
in {

     

       
8
       
 
       
  options.services.heapster = {

     

       
9
       
-
       
    enable = mkOption {

     

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

     

       
11
       
-
       
      default = false;

     

       
12
       
-
       
      type = types.bool;

     

       
13
       
-
       
    };

     

       
14
       
 
       


     

       
15
       
 
       
    source = mkOption {

     

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

     

···

       
6
       
 
       
  cfg = config.services.heapster;

     

       
7
       
 
       
in {

     

       
8
       
 
       
  options.services.heapster = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
10
       
 
       


     

       
11
       
 
       
    source = mkOption {

     

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

     

···

       
1563
       
 
       


     

       
1564
       
 
       
  options.services.prometheus = {

     

       
1565
       
 
       


     

       
1566
       
-
       
    enable = mkOption {

     

       
1567
       
-
       
      type = types.bool;

     

       
1568
       
-
       
      default = false;

     

       
1569
       
-
       
      description = lib.mdDoc ''

     

       
1570
       
-
       
        Enable the Prometheus monitoring daemon.

     

       
1571
       
-
       
      '';

     

       
1572
       
-
       
    };

     

       
1573
       
 
       


     

       
1574
       
 
       
    package = mkOption {

     

       
1575
       
 
       
      type = types.package;

     

···

       
1563
       
 
       


     

       
1564
       
 
       
  options.services.prometheus = {

     

       
1565
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1567
       
 
       


     

       
1568
       
 
       
    package = mkOption {

     

       
1569
       
 
       
      type = types.package;

     

···

       
33
       
 
       
      '';

     

       
34
       
 
       
    };

     

       
35
       
 
       
    port = mkOption {

     

       
36
       
-
       
      type = types.int;

     

       
37
       
 
       
      example = 587;

     

       
38
       
 
       
      description = lib.mdDoc ''

     

       
39
       
 
       
        Port to use for SMTP.

     

···

       
33
       
 
       
      '';

     

       
34
       
 
       
    };

     

       
35
       
 
       
    port = mkOption {

     

       
36
       
+
       
      type = types.port;

     

       
37
       
 
       
      example = 587;

     

       
38
       
 
       
      description = lib.mdDoc ''

     

       
39
       
 
       
        Port to use for SMTP.

     

···

       
17
       
 
       
    };

     

       
18
       
 
       


     

       
19
       
 
       
    torControlPort = mkOption {

     

       
20
       
-
       
      type = types.int;

     

       
21
       
 
       
      default = 9051;

     

       
22
       
 
       
      description = lib.mdDoc ''

     

       
23
       
 
       
        Tor control port.

     

···

       
17
       
 
       
    };

     

       
18
       
 
       


     

       
19
       
 
       
    torControlPort = mkOption {

     

       
20
       
+
       
      type = types.port;

     

       
21
       
 
       
      default = 9051;

     

       
22
       
 
       
      description = lib.mdDoc ''

     

       
23
       
 
       
        Tor control port.

     

···

       
27
       
 
       
  options = {

     

       
28
       
 
       


     

       
29
       
 
       
    services.riemann = {

     

       
30
       
-
       
      enable = mkOption {

     

       
31
       
-
       
        type = types.bool;

     

       
32
       
-
       
        default = false;

     

       
33
       
-
       
        description = lib.mdDoc ''

     

       
34
       
-
       
          Enable the Riemann network monitoring daemon.

     

       
35
       
-
       
        '';

     

       
36
       
-
       
      };

     

       
37
       
 
       
      config = mkOption {

     

       
38
       
 
       
        type = types.lines;

     

       
39
       
 
       
        description = lib.mdDoc ''

     

···

       
27
       
 
       
  options = {

     

       
28
       
 
       


     

       
29
       
 
       
    services.riemann = {

     

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

     

       
31
       
+
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       
      config = mkOption {

     

       
33
       
 
       
        type = types.lines;

     

       
34
       
 
       
        description = lib.mdDoc ''

     

···

       
94
       
 
       
        };

     

       
95
       
 
       


     

       
96
       
 
       
        port = mkOption {

     

       
97
       
-
       
          type = types.int;

     

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

     

       
99
       
 
       
          defaultText = literalExpression ''

     

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

     

···

       
94
       
 
       
        };

     

       
95
       
 
       


     

       
96
       
 
       
        port = mkOption {

     

       
97
       
+
       
          type = types.port;

     

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

     

       
99
       
 
       
          defaultText = literalExpression ''

     

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

     

···

       
9
       
 
       
  options = {

     

       
10
       
 
       
    services.samba-wsdd = {

     

       
11
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

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

     

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

     

       
14
       
 
       


     

       
15
       
 
       
        ::: {.note}

     

···

       
9
       
 
       
  options = {

     

       
10
       
 
       
    services.samba-wsdd = {

     

       
11
       
 
       
      enable = mkEnableOption (lib.mdDoc ''

     

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

     

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

     

       
14
       
 
       


     

       
15
       
 
       
        ::: {.note}

     

···

       
68
       
 
       


     

       
69
       
 
       
      portNumber = mkOption {

     

       
70
       
 
       
        default = 6667;

     

       
71
       
-
       
        type = types.int;

     

       
72
       
 
       
        description = lib.mdDoc ''

     

       
73
       
 
       
          Number of the port BitlBee will be listening to.

     

       
74
       
 
       
        '';

     

···

       
68
       
 
       


     

       
69
       
 
       
      portNumber = mkOption {

     

       
70
       
 
       
        default = 6667;

     

       
71
       
+
       
        type = types.port;

     

       
72
       
 
       
        description = lib.mdDoc ''

     

       
73
       
 
       
          Number of the port BitlBee will be listening to.

     

       
74
       
 
       
        '';

     

···

       
135
       
 
       
    };

     

       
136
       
 
       


     

       
137
       
 
       
    port = mkOption {

     

       
138
       
-
       
      type = types.int;

     

       
139
       
 
       
      default = 5353;

     

       
140
       
 
       
      description = lib.mdDoc ''

     

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

     
···

       
182
       
 
       
    };

     

       
183
       
 
       


     

       
184
       
 
       
    upstream.port = mkOption {

     

       
185
       
-
       
      type = types.int;

     

       
186
       
 
       
      default = 53;

     

       
187
       
 
       
      description = lib.mdDoc ''

     

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

     

···

       
135
       
 
       
    };

     

       
136
       
 
       


     

       
137
       
 
       
    port = mkOption {

     

       
138
       
+
       
      type = types.port;

     

       
139
       
 
       
      default = 5353;

     

       
140
       
 
       
      description = lib.mdDoc ''

     

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

     
···

       
182
       
 
       
    };

     

       
183
       
 
       


     

       
184
       
 
       
    upstream.port = mkOption {

     

       
185
       
+
       
      type = types.port;

     

       
186
       
 
       
      default = 53;

     

       
187
       
 
       
      description = lib.mdDoc ''

     

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

     

···

       
20
       
 
       


     

       
21
       
 
       
      port = mkOption {

     

       
22
       
 
       
        default = 2022;

     

       
23
       
-
       
        type = types.int;

     

       
24
       
 
       
        description = lib.mdDoc ''

     

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

     

       
26
       
 
       


     

···

       
20
       
 
       


     

       
21
       
 
       
      port = mkOption {

     

       
22
       
 
       
        default = 2022;

     

       
23
       
+
       
        type = types.port;

     

       
24
       
 
       
        description = lib.mdDoc ''

     

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

     

       
26
       
 
       


     

···

       
9
       
 
       
in

     

       
10
       
 
       
{

     

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

     

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

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

       
15
       
 
       
  config = mkIf cfg.enable {

     

···

       
9
       
 
       
in

     

       
10
       
 
       
{

     

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

     

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

     

       
13
       
 
       
  };

     

       
14
       
 
       


     

       
15
       
 
       
  config = mkIf cfg.enable {

     

···

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

     

       
2
       
 
       


     

       
3
       
 
       
{

     

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

     

       
5
       
-
       
    type = lib.types.bool;

     

       
6
       
-
       
    default = false;

     

       
7
       
-
       
    description = lib.mdDoc ''

     

       
8
       
-
       
      Enable the Mozilla VPN daemon.

     

       
9
       
-
       
    '';

     

       
10
       
-
       
  };

     

       
11
       
 
       


     

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

     

       
13
       
 
       
    environment.systemPackages = [ pkgs.mozillavpn ];

     

···

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

     

       
2
       
 
       


     

       
3
       
 
       
{

     

       
4
       
+
       
  options.services.mozillavpn.enable =

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       


     

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

     

       
8
       
 
       
    environment.systemPackages = [ pkgs.mozillavpn ];

     

···

       
365
       
 
       
          If you enable this option the

     

       
366
       
 
       
          `networkmanager_strongswan` plugin will be added to

     

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

     

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

     

       
369
       
 
       
        '';

     

       
370
       
 
       
      };

     

       
371
       
 
       


     

···

       
365
       
 
       
          If you enable this option the

     

       
366
       
 
       
          `networkmanager_strongswan` plugin will be added to

     

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

     

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

     

       
369
       
 
       
        '';

     

       
370
       
 
       
      };

     

       
371
       
 
       


     

···

       
71
       
 
       
      };

     

       
72
       
 
       


     

       
73
       
 
       
      upstreamPort = mkOption {

     

       
74
       
-
       
        type = types.int;

     

       
75
       
 
       
        default = 563;

     

       
76
       
 
       
        description = lib.mdDoc ''

     

       
77
       
 
       
          Upstream server port

     
···

       
112
       
 
       
      };

     

       
113
       
 
       


     

       
114
       
 
       
      port = mkOption {

     

       
115
       
-
       
        type = types.int;

     

       
116
       
 
       
        default = 5555;

     

       
117
       
 
       
        description = lib.mdDoc ''

     

       
118
       
 
       
          Proxy listen port

     

···

       
71
       
 
       
      };

     

       
72
       
 
       


     

       
73
       
 
       
      upstreamPort = mkOption {

     

       
74
       
+
       
        type = types.port;

     

       
75
       
 
       
        default = 563;

     

       
76
       
 
       
        description = lib.mdDoc ''

     

       
77
       
 
       
          Upstream server port

     
···

       
112
       
 
       
      };

     

       
113
       
 
       


     

       
114
       
 
       
      port = mkOption {

     

       
115
       
+
       
        type = types.port;

     

       
116
       
 
       
        default = 5555;

     

       
117
       
 
       
        description = lib.mdDoc ''

     

       
118
       
 
       
          Proxy listen port

     

···

       
26
       
 
       
  ### Interface

     

       
27
       
 
       


     

       
28
       
 
       
  options.services.onedrive = {

     

       
29
       
-
       
    enable = lib.mkOption {

     

       
30
       
-
       
      type = lib.types.bool;

     

       
31
       
-
       
      default = false;

     

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

     

       
33
       
-
       
    };

     

       
34
       
 
       


     

       
35
       
 
       
     package = lib.mkOption {

     

       
36
       
 
       
       type = lib.types.package;

     

···

       
26
       
 
       
  ### Interface

     

       
27
       
 
       


     

       
28
       
 
       
  options.services.onedrive = {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
30
       
 
       


     

       
31
       
 
       
     package = lib.mkOption {

     

       
32
       
 
       
       type = lib.types.package;

     

···

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

     

       
30
       
 
       


     

       
31
       
 
       
      port = mkOption {

     

       
32
       
-
       
        type = types.int;

     

       
33
       
 
       
        default = 7878;

     

       
34
       
 
       
        description = lib.mdDoc ''

     

       
35
       
 
       
          Port to listen on.

     

···

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

     

       
30
       
 
       


     

       
31
       
 
       
      port = mkOption {

     

       
32
       
+
       
        type = types.port;

     

       
33
       
 
       
        default = 7878;

     

       
34
       
 
       
        description = lib.mdDoc ''

     

       
35
       
 
       
          Port to listen on.

     

···

       
10
       
 
       
  ###### interface

     

       
11
       
 
       


     

       
12
       
 
       
  options = {

     

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

     

       
14
       
 
       
  };

     

       
15
       
 
       


     

       
16
       
 
       


     

···

       
10
       
 
       
  ###### interface

     

       
11
       
 
       


     

       
12
       
 
       
  options = {

     

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

     

       
14
       
 
       
  };

     

       
15
       
 
       


     

       
16
       
 
       


     

···

       
23
       
 
       


     

       
24
       
 
       
    services.polipo = {

     

       
25
       
 
       


     

       
26
       
-
       
      enable = mkOption {

     

       
27
       
-
       
        type = types.bool;

     

       
28
       
-
       
        default = false;

     

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

     

       
30
       
-
       
      };

     

       
31
       
 
       


     

       
32
       
 
       
      proxyAddress = mkOption {

     

       
33
       
 
       
        type = types.str;

     
···

       
36
       
 
       
      };

     

       
37
       
 
       


     

       
38
       
 
       
      proxyPort = mkOption {

     

       
39
       
-
       
        type = types.int;

     

       
40
       
 
       
        default = 8123;

     

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

     

       
42
       
 
       
      };

     

···

       
23
       
 
       


     

       
24
       
 
       
    services.polipo = {

     

       
25
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
27
       
 
       


     

       
28
       
 
       
      proxyAddress = mkOption {

     

       
29
       
 
       
        type = types.str;

     
···

       
32
       
 
       
      };

     

       
33
       
 
       


     

       
34
       
 
       
      proxyPort = mkOption {

     

       
35
       
+
       
        type = types.port;

     

       
36
       
 
       
        default = 8123;

     

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

     

       
38
       
 
       
      };

     

···

       
48
       
 
       
      };

     

       
49
       
 
       


     

       
50
       
 
       
      port = mkOption {

     

       
51
       
-
       
        type = types.int;

     

       
52
       
 
       
        default = 8388;

     

       
53
       
 
       
        description = lib.mdDoc ''

     

       
54
       
 
       
          Port which the server uses.

     

···

       
48
       
 
       
      };

     

       
49
       
 
       


     

       
50
       
 
       
      port = mkOption {

     

       
51
       
+
       
        type = types.port;

     

       
52
       
 
       
        default = 8388;

     

       
53
       
 
       
        description = lib.mdDoc ''

     

       
54
       
 
       
          Port which the server uses.

     

···

       
49
       
 
       
{

     

       
50
       
 
       
  options = {

     

       
51
       
 
       
    services.smokeping = {

     

       
52
       
-
       
      enable = mkOption {

     

       
53
       
-
       
        type = types.bool;

     

       
54
       
-
       
        default = false;

     

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

     

       
56
       
-
       
      };

     

       
57
       
 
       
      alertConfig = mkOption {

     

       
58
       
 
       
        type = types.lines;

     

       
59
       
 
       
        default = ''

     
···

       
186
       
 
       
        '';

     

       
187
       
 
       
      };

     

       
188
       
 
       
      port = mkOption {

     

       
189
       
-
       
        type = types.int;

     

       
190
       
 
       
        default = 8081;

     

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

     

       
192
       
 
       
      };

     

···

       
49
       
 
       
{

     

       
50
       
 
       
  options = {

     

       
51
       
 
       
    services.smokeping = {

     

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

     

       
53
       
+
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
54
       
 
       
      alertConfig = mkOption {

     

       
55
       
 
       
        type = types.lines;

     

       
56
       
 
       
        default = ''

     
···

       
183
       
 
       
        '';

     

       
184
       
 
       
      };

     

       
185
       
 
       
      port = mkOption {

     

       
186
       
+
       
        type = types.port;

     

       
187
       
 
       
        default = 8081;

     

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

     

       
189
       
 
       
      };

     

···

       
70
       
 
       
      };

     

       
71
       
 
       


     

       
72
       
 
       
      port = mkOption {

     

       
73
       
-
       
        type = types.int;

     

       
74
       
 
       
        default = 443;

     

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

     

       
76
       
 
       
      };

     

···

       
70
       
 
       
      };

     

       
71
       
 
       


     

       
72
       
 
       
      port = mkOption {

     

       
73
       
+
       
        type = types.port;

     

       
74
       
 
       
        default = 443;

     

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

     

       
76
       
 
       
      };

     

···

       
65
       
 
       
        };

     

       
66
       
 
       


     

       
67
       
 
       
        port = mkOption {

     

       
68
       
-
       
          type = int;

     

       
69
       
 
       
          default = 3000;

     

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

     

       
71
       
 
       
        };

     

···

       
65
       
 
       
        };

     

       
66
       
 
       


     

       
67
       
 
       
        port = mkOption {

     

       
68
       
+
       
          type = port;

     

       
69
       
 
       
          default = 3000;

     

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

     

       
71
       
 
       
        };

     

···

       
29
       
 
       
          };

     

       
30
       
 
       


     

       
31
       
 
       
          port = mkOption {

     

       
32
       
-
       
            type = types.int;

     

       
33
       
 
       
            default = 33445;

     

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

     

       
35
       
 
       
          };

     

···

       
29
       
 
       
          };

     

       
30
       
 
       


     

       
31
       
 
       
          port = mkOption {

     

       
32
       
+
       
            type = types.port;

     

       
33
       
 
       
            default = 33445;

     

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

     

       
35
       
 
       
          };

     

···

       
14
       
 
       
      };

     

       
15
       
 
       


     

       
16
       
 
       
      port = mkOption {

     

       
17
       
-
       
        type        = types.int;

     

       
18
       
 
       
        default     = 33445;

     

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

     

       
20
       
 
       
      };

     

···

       
14
       
 
       
      };

     

       
15
       
 
       


     

       
16
       
 
       
      port = mkOption {

     

       
17
       
+
       
        type        = types.port;

     

       
18
       
 
       
        default     = 33445;

     

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

     

       
20
       
 
       
      };

     

···

       
54
       
 
       
      };

     

       
55
       
 
       


     

       
56
       
 
       
      port = mkOption {

     

       
57
       
-
       
        type = types.int;

     

       
58
       
 
       
        default = 3389;

     

       
59
       
 
       
        description = lib.mdDoc ''

     

       
60
       
 
       
          Specifies on which port the xrdp daemon listens.

     

···

       
54
       
 
       
      };

     

       
55
       
 
       


     

       
56
       
 
       
      port = mkOption {

     

       
57
       
+
       
        type = types.port;

     

       
58
       
 
       
        default = 3389;

     

       
59
       
 
       
        description = lib.mdDoc ''

     

       
60
       
 
       
          Specifies on which port the xrdp daemon listens.

     

···

       
19
       
 
       


     

       
20
       
 
       
  options.services.zerotierone.port = mkOption {

     

       
21
       
 
       
    default = 9993;

     

       
22
       
-
       
    type = types.int;

     

       
23
       
 
       
    description = lib.mdDoc ''

     

       
24
       
 
       
      Network port used by ZeroTier.

     

       
25
       
 
       
    '';

     

···

       
19
       
 
       


     

       
20
       
 
       
  options.services.zerotierone.port = mkOption {

     

       
21
       
 
       
    default = 9993;

     

       
22
       
+
       
    type = types.port;

     

       
23
       
 
       
    description = lib.mdDoc ''

     

       
24
       
 
       
      Network port used by ZeroTier.

     

       
25
       
 
       
    '';

     

···

       
21
       
 
       
      };

     

       
22
       
 
       


     

       
23
       
 
       
      port = mkOption {

     

       
24
       
-
       
        type = types.int;

     

       
25
       
 
       
        default = 8983;

     

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

     

       
27
       
 
       
      };

     

···

       
21
       
 
       
      };

     

       
22
       
 
       


     

       
23
       
 
       
      port = mkOption {

     

       
24
       
+
       
        type = types.port;

     

       
25
       
 
       
        default = 8983;

     

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

     

       
27
       
 
       
      };

     

···

       
61
       
 
       
      };

     

       
62
       
 
       


     

       
63
       
 
       
      listenPort = mkOption {

     

       
64
       
-
       
        type = types.int;

     

       
65
       
 
       
        default = 8092;

     

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

     

       
67
       
 
       
      };

     
···

       
95
       
 
       
        };

     

       
96
       
 
       


     

       
97
       
 
       
        port = mkOption {

     

       
98
       
-
       
          type = types.int;

     

       
99
       
 
       
          default = 443;

     

       
100
       
 
       
          example = 80;

     

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

     

···

       
61
       
 
       
      };

     

       
62
       
 
       


     

       
63
       
 
       
      listenPort = mkOption {

     

       
64
       
+
       
        type = types.port;

     

       
65
       
 
       
        default = 8092;

     

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

     

       
67
       
 
       
      };

     
···

       
95
       
 
       
        };

     

       
96
       
 
       


     

       
97
       
 
       
        port = mkOption {

     

       
98
       
+
       
          type = types.port;

     

       
99
       
 
       
          default = 443;

     

       
100
       
 
       
          example = 80;

     

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

     

···

       
75
       
 
       


     

       
76
       
 
       
in {

     

       
77
       
 
       
  options.services.peertube = {

     

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

     

       
79
       
 
       


     

       
80
       
 
       
    user = lib.mkOption {

     

       
81
       
 
       
      type = lib.types.str;

     
···

       
96
       
 
       
    };

     

       
97
       
 
       


     

       
98
       
 
       
    listenHttp = lib.mkOption {

     

       
99
       
-
       
      type = lib.types.int;

     

       
100
       
 
       
      default = 9000;

     

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

     

       
102
       
 
       
    };

     

       
103
       
 
       


     

       
104
       
 
       
    listenWeb = lib.mkOption {

     

       
105
       
-
       
      type = lib.types.int;

     

       
106
       
 
       
      default = 9000;

     

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

     

       
108
       
 
       
    };

     
···

       
177
       
 
       
      };

     

       
178
       
 
       


     

       
179
       
 
       
      port = lib.mkOption {

     

       
180
       
-
       
        type = lib.types.int;

     

       
181
       
 
       
        default = 5432;

     

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

     

       
183
       
 
       
      };