commit d807b057eddc45093566b0b515b03a4217c165fa · pyrox.dev/nixpkgs

+13

nixos/modules/rename.nix

···

       14
       14
        
           (mkRenamedOptionModule [ "networking" "enableWLAN" ] [ "networking" "wireless" "enable" ])

     

       15
       15
        
           (mkRenamedOptionModule [ "networking" "enableRT73Firmware" ] [ "networking" "enableRalinkFirmware" ])

     

       16
       16
        
       

     

       17
       17
       +
           (mkRenamedOptionModule [ "services" "cadvisor" "host" ] [ "services" "cadvisor" "listenAddress" ])

     

       18
       18
       +
           (mkRenamedOptionModule [ "services" "dockerRegistry" "host" ] [ "services" "dockerRegistry" "listenAddress" ])

     

       19
       19
       +
           (mkRenamedOptionModule [ "services" "elasticsearch" "host" ] [ "services" "elasticsearch" "listenAddress" ])

     

       20
       20
       +
           (mkRenamedOptionModule [ "services" "graphite" "api" "host" ] [ "services" "graphite" "api" "listenAddress" ])

     

       21
       21
       +
           (mkRenamedOptionModule [ "services" "graphite" "web" "host" ] [ "services" "graphite" "web" "listenAddress" ])

     

       22
       22
       +
           (mkRenamedOptionModule [ "services" "kibana" "host" ] [ "services" "kibana" "listenAddress" ])

     

       23
       23
       +
           (mkRenamedOptionModule [ "services" "mpd" "network" "host" ] [ "services" "mpd" "network" "listenAddress" ])

     

       24
       24
       +
           (mkRenamedOptionModule [ "services" "neo4j" "host" ] [ "services" "neo4j" "listenAddress" ])

     

       25
       25
       +
           (mkRenamedOptionModule [ "services" "shout" "host" ] [ "services" "shout" "listenAddress" ])

     

       26
       26
       +
           (mkRenamedOptionModule [ "services" "sslh" "host" ] [ "services" "sslh" "listenAddress" ])

     

       27
       27
       +
           (mkRenamedOptionModule [ "services" "statsd" "host" ] [ "services" "statsd" "listenAddress" ])

     

       28
       28
       +
           (mkRenamedOptionModule [ "services" "subsonic" "host" ] [ "services" "subsonic" "listenAddress" ])

     

       29
       29
       +
       

     

       17
       30
        
           # Old Grub-related options.

     

       18
       31
        
           (mkRenamedOptionModule [ "boot" "initrd" "extraKernelModules" ] [ "boot" "initrd" "kernelModules" ])

     

       19
       32
        
           (mkRenamedOptionModule [ "boot" "extraKernelParams" ] [ "boot" "kernelParams" ])

+2 -2

nixos/modules/services/audio/mpd.nix

···

       18
       18
        
           user                "${cfg.user}"

     

       19
       19
        
           group               "${cfg.group}"

     

       20
       20
        
       

     

       21
       21
       -
           ${optionalString (cfg.network.host != "any") ''bind_to_address "${cfg.network.host}"''}

     

       21
       21
       +
           ${optionalString (cfg.network.listenAddress != "any") ''bind_to_address "${cfg.network.listenAddress}"''}

     

       22
       22
        
           ${optionalString (cfg.network.port != 6600)  ''port "${toString cfg.network.port}"''}

     

       23
       23
        
       

     

       24
       24
        
           ${cfg.extraConfig}

     
···

       75
       75
        
       

     

       76
       76
        
             network = {

     

       77
       77
        
       

     

       78
       78
       -
               host = mkOption {

     

       78
       78
       +
               listenAddress = mkOption {

     

       79
       79
        
                 default = "any";

     

       80
       80
        
                 description = ''

     

       81
       81
        
                   This setting sets the address for the daemon to listen on. Careful attention

+2 -2

nixos/modules/services/databases/neo4j.nix

···

       7
       7
        
       

     

       8
       8
        
         serverConfig = pkgs.writeText "neo4j-server.properties" ''

     

       9
       9
        
           org.neo4j.server.database.location=${cfg.dataDir}/data/graph.db

     

       10
       10
       -
           org.neo4j.server.webserver.address=${cfg.host}

     

       10
       10
       +
           org.neo4j.server.webserver.address=${cfg.listenAddress}

     

       11
       11
        
           org.neo4j.server.webserver.port=${toString cfg.port}

     

       12
       12
        
           ${optionalString cfg.enableHttps ''

     

       13
       13
        
             org.neo4j.server.webserver.https.enabled=true

     
···

       52
       52
        
             type = types.package;

     

       53
       53
        
           };

     

       54
       54
        
       

     

       55
       55
       -
           host = mkOption {

     

       55
       55
       +
           listenAddress = mkOption {

     

       56
       56
        
             description = "Neo4j listen address.";

     

       57
       57
        
             default = "127.0.0.1";

     

       58
       58
        
             type = types.str;

+3 -3

nixos/modules/services/misc/docker-registry.nix

···

       15
       15
        
             type = types.bool;

     

       16
       16
        
           };

     

       17
       17
        
       

     

       18
       18
       -
           host = mkOption {

     

       18
       18
       +
           listenAddress = mkOption {

     

       19
       19
        
             description = "Docker registry host or ip to bind to.";

     

       20
       20
        
             default = "127.0.0.1";

     

       21
       21
        
             type = types.str;

     
···

       50
       50
        
             after = [ "network.target" ];

     

       51
       51
        
       

     

       52
       52
        
             environment = {

     

       53
       53
       -
               REGISTRY_HOST = cfg.host;

     

       53
       53
       +
               REGISTRY_HOST = cfg.listenAddress;

     

       54
       54
        
               REGISTRY_PORT = toString cfg.port;

     

       55
       55
        
               GUNICORN_OPTS = "[--preload]"; # see https://github.com/docker/docker-registry#sqlalchemy

     

       56
       56
        
               STORAGE_PATH = cfg.storagePath;

     
···

       65
       65
        
             };

     

       66
       66
        
       

     

       67
       67
        
             postStart = ''

     

       68
       68
       -
               until ${pkgs.curl}/bin/curl -s -o /dev/null 'http://${cfg.host}:${toString cfg.port}/'; do

     

       68
       68
       +
               until ${pkgs.curl}/bin/curl -s -o /dev/null 'http://${cfg.listenAddress}:${toString cfg.port}/'; do

     

       69
       69
        
                 sleep 1;

     

       70
       70
        
               done

     

       71
       71
        
             '';

+2 -2

nixos/modules/services/misc/subsonic.nix

···

       21
       21
        
               '';

     

       22
       22
        
             };

     

       23
       23
        
       

     

       24
       24
       -
             host = mkOption {

     

       24
       24
       +
             listenAddress = mkOption {

     

       25
       25
        
               type = types.string;

     

       26
       26
        
               default = "0.0.0.0";

     

       27
       27
        
               description = ''

     
···

       115
       115
        
               ExecStart = ''

     

       116
       116
        
                 ${pkgs.jre}/bin/java -Xmx${toString cfg.maxMemory}m \

     

       117
       117
        
                   -Dsubsonic.home=${cfg.home} \

     

       118
       118
       -
                   -Dsubsonic.host=${cfg.host} \

     

       118
       118
       +
                   -Dsubsonic.host=${cfg.listenAddress} \

     

       119
       119
        
                   -Dsubsonic.port=${toString cfg.port} \

     

       120
       120
        
                   -Dsubsonic.httpsPort=${toString cfg.httpsPort} \

     

       121
       121
        
                   -Dsubsonic.contextPath=${cfg.contextPath} \

+3 -3

nixos/modules/services/monitoring/cadvisor.nix

···

       14
       14
        
               description = "Whether to enable cadvisor service.";

     

       15
       15
        
             };

     

       16
       16
        
       

     

       17
       17
       -
             host = mkOption {

     

       17
       17
       +
             listenAddress = mkOption {

     

       18
       18
        
               default = "127.0.0.1";

     

       19
       19
        
               type = types.str;

     

       20
       20
        
               description = "Cadvisor listening host";

     
···

       71
       71
        
             after = [ "network.target" "docker.service" "influxdb.service" ];

     

       72
       72
        
       

     

       73
       73
        
             postStart = mkBefore ''

     

       74
       74
       -
               until ${pkgs.curl}/bin/curl -s -o /dev/null 'http://${cfg.host}:${toString cfg.port}/containers/'; do

     

       74
       74
       +
               until ${pkgs.curl}/bin/curl -s -o /dev/null 'http://${cfg.listenAddress}:${toString cfg.port}/containers/'; do

     

       75
       75
        
                 sleep 1;

     

       76
       76
        
               done

     

       77
       77
        
             '';

     
···

       79
       79
        
             serviceConfig = {

     

       80
       80
        
               ExecStart = ''${pkgs.cadvisor}/bin/cadvisor \

     

       81
       81
        
                 -logtostderr=true \

     

       82
       82
       -
                 -listen_ip=${cfg.host} \

     

       82
       82
       +
                 -listen_ip=${cfg.listenAddress} \

     

       83
       83
        
                 -port=${toString cfg.port} \

     

       84
       84
        
                 ${optionalString (cfg.storageDriver != null) ''

     

       85
       85
        
                   -storage_driver ${cfg.storageDriver} \

+6 -6

nixos/modules/services/monitoring/graphite.nix

···

       77
       77
        
               type = types.bool;

     

       78
       78
        
             };

     

       79
       79
        
       

     

       80
       80
       -
             host = mkOption {

     

       80
       80
       +
             listenAddress = mkOption {

     

       81
       81
        
               description = "Graphite web frontend listen address.";

     

       82
       82
        
               default = "127.0.0.1";

     

       83
       83
        
               type = types.str;

     
···

       121
       121
        
               type = types.listOf types.str;

     

       122
       122
        
             };

     

       123
       123
        
       

     

       124
       124
       -
             host = mkOption {

     

       124
       124
       +
             listenAddress = mkOption {

     

       125
       125
        
               description = "Graphite web service listen address.";

     

       126
       126
        
               default = "127.0.0.1";

     

       127
       127
        
               type = types.str;

     
···

       292
       292
        
             };

     

       293
       293
        
       

     

       294
       294
        
             graphiteUrl = mkOption {

     

       295
       295
       -
               default = "http://${cfg.web.host}:${toString cfg.web.port}";

     

       295
       295
       +
               default = "http://${cfg.web.listenAddress}:${toString cfg.web.port}";

     

       296
       296
        
               description = "Host where graphite service runs.";

     

       297
       297
        
               type = types.str;

     

       298
       298
        
             };

     
···

       337
       337
        
       

     

       338
       338
        
             graphiteUrl = mkOption {

     

       339
       339
        
               description = "URL to your graphite service.";

     

       340
       340
       -
               default = "http://${cfg.web.host}:${toString cfg.web.port}";

     

       340
       340
       +
               default = "http://${cfg.web.listenAddress}:${toString cfg.web.port}";

     

       341
       341
        
               type = types.str;

     

       342
       342
        
             };

     

       343
       343
        
       

     
···

       452
       452
        
               serviceConfig = {

     

       453
       453
        
                 ExecStart = ''

     

       454
       454
        
                   ${pkgs.python27Packages.waitress}/bin/waitress-serve \

     

       455
       455
       -
                   --host=${cfg.web.host} --port=${toString cfg.web.port} \

     

       455
       455
       +
                   --host=${cfg.web.listenAddress} --port=${toString cfg.web.port} \

     

       456
       456
        
                   --call django.core.handlers.wsgi:WSGIHandler'';

     

       457
       457
        
                 User = "graphite";

     

       458
       458
        
                 Group = "graphite";

     
···

       494
       494
        
               serviceConfig = {

     

       495
       495
        
                 ExecStart = ''

     

       496
       496
        
                   ${pkgs.python27Packages.waitress}/bin/waitress-serve \

     

       497
       497
       -
                   --host=${cfg.api.host} --port=${toString cfg.api.port} \

     

       497
       497
       +
                   --host=${cfg.api.listenAddress} --port=${toString cfg.api.port} \

     

       498
       498
        
                   graphite_api.app:app

     

       499
       499
        
                 '';

     

       500
       500
        
                 User = "graphite";

+2 -2

nixos/modules/services/monitoring/statsd.nix

···

       11
       11
        
       

     

       12
       12
        
         configFile = pkgs.writeText "statsd.conf" ''

     

       13
       13
        
           {

     

       14
       14
       -
             address: "${cfg.host}",

     

       14
       14
       +
             address: "${cfg.listenAddress}",

     

       15
       15
        
             port: "${toString cfg.port}",

     

       16
       16
        
             mgmt_address: "${cfg.mgmt_address}",

     

       17
       17
        
             mgmt_port: "${toString cfg.mgmt_port}",

     
···

       48
       48
        
             type = types.bool;

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
       -
           host = mkOption {

     

       51
       51
       +
           listenAddress = mkOption {

     

       52
       52
        
             description = "Address that statsd listens on over UDP";

     

       53
       53
        
             default = "127.0.0.1";

     

       54
       54
        
             type = types.str;

+2 -2

nixos/modules/services/networking/shout.nix

···

       19
       19
        
             '';

     

       20
       20
        
           };

     

       21
       21
        
       

     

       22
       22
       -
           host = mkOption {

     

       22
       22
       +
           listenAddress = mkOption {

     

       23
       23
        
             type = types.string;

     

       24
       24
        
             default = "0.0.0.0";

     

       25
       25
        
             description = "IP interface to listen on for http connections.";

     
···

       66
       66
        
               "${pkgs.shout}/bin/shout"

     

       67
       67
        
               (if cfg.private then "--private" else "--public")

     

       68
       68
        
               "--port" (toString cfg.port)

     

       69
       69
       -
               "--host" (toString cfg.host)

     

       69
       69
       +
               "--host" (toString cfg.listenAddress)

     

       70
       70
        
               "--home" shoutHome

     

       71
       71
        
             ];

     

       72
       72
        
             serviceConfig = {

+2 -2

nixos/modules/services/networking/sslh.nix

···

       16
       16
        
       

     

       17
       17
        
           listen:

     

       18
       18
        
           (

     

       19
       19
       -
             { host: "${cfg.host}"; port: "${toString cfg.port}"; }

     

       19
       19
       +
             { host: "${cfg.listenAddress}"; port: "${toString cfg.port}"; }

     

       20
       20
        
           );

     

       21
       21
        
       

     

       22
       22
        
           ${cfg.appendConfig}

     
···

       56
       56
        
               description = "PID file path for sslh daemon.";

     

       57
       57
        
             };

     

       58
       58
        
       

     

       59
       59
       -
             host = mkOption {

     

       59
       59
       +
             listenAddress = mkOption {

     

       60
       60
        
               type = types.str;

     

       61
       61
        
               default = config.networking.hostName;

     

       62
       62
        
               description = "Listening hostname.";

+3 -3

nixos/modules/services/search/elasticsearch.nix

···

       6
       6
        
         cfg = config.services.elasticsearch;

     

       7
       7
        
       

     

       8
       8
        
         esConfig = ''

     

       9
       9
       -
           network.host: ${cfg.host}

     

       9
       9
       +
           network.host: ${cfg.listenAddress}

     

       10
       10
        
           network.port: ${toString cfg.port}

     

       11
       11
        
           network.tcp.port: ${toString cfg.tcp_port}

     

       12
       12
        
           cluster.name: ${cfg.cluster_name}

     
···

       43
       43
        
             type = types.package;

     

       44
       44
        
           };

     

       45
       45
        
       

     

       46
       46
       -
           host = mkOption {

     

       46
       46
       +
           listenAddress = mkOption {

     

       47
       47
        
             description = "Elasticsearch listen address.";

     

       48
       48
        
             default = "127.0.0.1";

     

       49
       49
        
             type = types.str;

     
···

       142
       142
        
               ln -s ${esPlugins}/plugins ${cfg.dataDir}/plugins

     

       143
       143
        
             '';

     

       144
       144
        
             postStart = mkBefore ''

     

       145
       145
       -
               until ${pkgs.curl}/bin/curl -s -o /dev/null ${cfg.host}:${toString cfg.port}; do

     

       145
       145
       +
               until ${pkgs.curl}/bin/curl -s -o /dev/null ${cfg.listenAddress}:${toString cfg.port}; do

     

       146
       146
        
                 sleep 1

     

       147
       147
        
               done

     

       148
       148
        
             '';

+2 -2

nixos/modules/services/search/kibana.nix

···

       8
       8
        
         cfgFile = pkgs.writeText "kibana.json" (builtins.toJSON (

     

       9
       9
        
           (filterAttrsRecursive (n: v: v != null) ({

     

       10
       10
        
             server = {

     

       11
       11
       -
               host = cfg.host;

     

       11
       11
       +
               host = cfg.listenAddress;

     

       12
       12
        
               port = cfg.port;

     

       13
       13
        
               ssl = {

     

       14
       14
        
                 cert = cfg.cert;

     
···

       44
       44
        
         options.services.kibana = {

     

       45
       45
        
           enable = mkEnableOption "enable kibana service";

     

       46
       46
        
       

     

       47
       47
       -
           host = mkOption {

     

       47
       47
       +
           listenAddress = mkOption {

     

       48
       48
        
             description = "Kibana listening host";

     

       49
       49
        
             default = "127.0.0.1";

     

       50
       50
        
             type = types.str;