commit b2a37ceeea8c38ec71447f8dae1e6890a8cf982d · pyrox.dev/nixpkgs

+1 -1

lib/attrsets.nix

···

       207
       207
        
       

     

       208
       208
        
       

     

       209
       209
        
         /* Like `mapAttrsRecursive', but it takes an additional predicate

     

       210
       210
       -
            function that tells it whether to recursive into an attribute

     

       210
       210
       +
            function that tells it whether to recurse into an attribute

     

       211
       211
        
            set.  If it returns false, `mapAttrsRecursiveCond' does not

     

       212
       212
        
            recurse, but does apply the map function.  It is returns true, it

     

       213
       213
        
            does recurse, and does not apply the map function.

+1 -2

nixos/modules/programs/ssh.nix

···

       36
       36
        
       

     

       37
       37
        
             askPassword = mkOption {

     

       38
       38
        
               type = types.str;

     

       39
       39
       +
               default = "${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass";

     

       39
       40
        
               description = ''Program used by SSH to ask for passwords.'';

     

       40
       41
        
             };

     

       41
       42
        
       

     
···

       225
       226
        
             '';

     

       226
       227
        
       

     

       227
       228
        
           environment.variables.SSH_ASKPASS = optionalString config.services.xserver.enable askPassword;

     

       228
       228
       -
       

     

       229
       229
       -
           programs.ssh.askPassword = mkDefault "${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass";

     

       230
       229
        
       

     

       231
       230
        
         };

     

       232
       231
        
       }

+1 -2

nixos/modules/programs/venus.nix

···

       99
       99
        
             };

     

       100
       100
        
       

     

       101
       101
        
             outputTheme = mkOption {

     

       102
       102
       +
               default = "${pkgs.venus}/themes/classic_fancy";

     

       102
       103
        
               type = types.path;

     

       103
       104
        
               description = ''

     

       104
       105
        
                 Directory containing a config.ini file which is merged with this one.

     
···

       168
       169
        
               environment.SSL_CERT_FILE = "/etc/ssl/certs/ca-certificates.crt";

     

       169
       170
        
               startAt = cfg.dates;

     

       170
       171
        
             };

     

       171
       171
       -
       

     

       172
       172
       -
           services.venus.outputTheme = mkDefault "${pkgs.venus}/themes/classic_fancy";

     

       173
       172
        
       

     

       174
       173
        
         };

     

       175
       174
        
       }

+1 -2

nixos/modules/services/amqp/activemq/default.nix

···

       32
       32
        
               '';

     

       33
       33
        
             };

     

       34
       34
        
             configurationDir = mkOption {

     

       35
       35
       +
               default = "${activemq}/conf";

     

       35
       36
        
               description = ''

     

       36
       37
        
                 The base directory for ActiveMQ's configuration.

     

       37
       38
        
                 By default, this directory is searched for a file named activemq.xml,

     
···

       124
       125
        
                 ${cfg.extraJavaOptions} ActiveMQBroker "${cfg.configurationURI}"

     

       125
       126
        
             '';

     

       126
       127
        
           };

     

       127
       127
       -
       

     

       128
       128
       -
           services.activemq.configurationDir = mkDefault "${activemq}/conf";

     

       129
       128
        
       

     

       130
       129
        
         };

     

       131
       130

+1 -2

nixos/modules/services/misc/nixos-manual.nix

···

       80
       80
        
       

     

       81
       81
        
           services.nixosManual.browser = mkOption {

     

       82
       82
        
             type = types.path;

     

       83
       83
       +
             default = "${pkgs.w3m-nox}/bin/w3m";

     

       83
       84
        
             description = ''

     

       84
       85
        
               Browser used to show the manual.

     

       85
       86
        
             '';

     
···

       116
       117
        
       

     

       117
       118
        
           services.mingetty.helpLine = mkIf cfg.showManual

     

       118
       119
        
             "\nPress <Alt-F${toString cfg.ttyNumber}> for the NixOS manual.";

     

       119
       119
       -
       

     

       120
       120
       -
           services.nixosManual.browser = mkDefault "${pkgs.w3m-nox}/bin/w3m";

     

       121
       120
        
       

     

       122
       121
        
         };

     

       123
       122

+1 -3

nixos/modules/services/misc/subsonic.nix

···

       97
       97
        
       

     

       98
       98
        
             transcoders = mkOption {

     

       99
       99
        
               type = types.listOf types.path;

     

       100
       100
       +
               default = [ "${pkgs.ffmpeg}/bin/ffmpeg" ];

     

       100
       101
        
               description = ''

     

       101
       102
        
                 List of paths to transcoder executables that should be accessible

     

       102
       103
        
                 from Subsonic. Symlinks will be created to each executable inside

     
···

       152
       153
        
           };

     

       153
       154
        
       

     

       154
       155
        
           users.extraGroups.subsonic.gid = config.ids.gids.subsonic;

     

       155
       155
       -
       

     

       156
       156
       -
           services.subsonic.transcoders = mkDefault [ "${pkgs.ffmpeg}/bin/ffmpeg" ];

     

       157
       157
       -
       

     

       158
       156
        
         };

     

       159
       157
        
       }

+1 -3

nixos/modules/services/monitoring/grafana.nix

···

       87
       87
        
       

     

       88
       88
        
           staticRootPath = mkOption {

     

       89
       89
        
             description = "Root path for static assets.";

     

       90
       90
       +
             default = "${cfg.package.out}/share/grafana/public";

     

       90
       91
        
             type = types.str;

     

       91
       92
        
           };

     

       92
       93
        
       

     
···

       232
       233
        
             home = cfg.dataDir;

     

       233
       234
        
             createHome = true;

     

       234
       235
        
           };

     

       235
       235
       -
       

     

       236
       236
       -
           services.grafana.staticRootPath = mkDefault "${cfg.package}/share/grafana/public";

     

       237
       237
       -
       

     

       238
       236
        
         };

     

       239
       237
        
       }

+4 -1

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

···

       52
       52
        
               default = "opendns";

     

       53
       53
        
               type = types.nullOr types.string;

     

       54
       54
        
               description = ''

     

       55
       55
       -
                 The name of the upstream DNSCrypt resolver to use.

     

       55
       55
       +
                 The name of the upstream DNSCrypt resolver to use. See

     

       56
       56
       +
                 <literal>${resolverListFile}</literal> for alternative resolvers

     

       57
       57
       +
                 (e.g., if you are concerned about logging and/or server

     

       58
       58
       +
                 location).

     

       56
       59
        
               '';

     

       57
       60
        
             };

     

       58
       61
        
             customResolver = mkOption {

+2 -3

nixos/modules/services/web-servers/phpfpm.nix

···

       46
       46
        
       

     

       47
       47
        
             phpIni = mkOption {

     

       48
       48
        
               type = types.path;

     

       49
       49
       -
               description = "PHP configuration file to use.";

     

       49
       49
       +
               default = "${cfg.phpPackage}/etc/php-recommended.ini";

     

       50
       50
       +
               description = "php.ini file to use.";

     

       50
       51
        
             };

     

       51
       52
        
       

     

       52
       53
        
             poolConfigs = mkOption {

     
···

       86
       87
        
               PIDFile = pidFile;

     

       87
       88
        
             };

     

       88
       89
        
           };

     

       89
       89
       -
       

     

       90
       90
       -
           services.phpfpm.phpIni = mkDefault "${cfg.phpPackage}/etc/php-recommended.ini";

     

       91
       90
        
       

     

       92
       91
        
         };

     

       93
       92
        
       }

+1 -3

nixos/modules/services/x11/display-managers/lightdm.nix

···

       87
       87
        
       

     

       88
       88
        
             background = mkOption {

     

       89
       89
        
               type = types.str;

     

       90
       90
       +
               default = "${pkgs.nixos-artwork}/share/artwork/gnome/Gnome_Dark.png";

     

       90
       91
        
               description = ''

     

       91
       92
        
                 The background image or color to use.

     

       92
       93
        
               '';

     
···

       152
       153
        
           };

     

       153
       154
        
       

     

       154
       155
        
           users.extraGroups.lightdm.gid = config.ids.gids.lightdm;

     

       155
       155
       -
       

     

       156
       156
       -
           services.xserver.displayManager.lightdm.background = mkDefault "${pkgs.nixos-artwork}/share/artwork/gnome/Gnome_Dark.png";

     

       157
       157
       -
       

     

       158
       156
        
           services.xserver.tty     = null; # We might start multiple X servers so let the tty increment themselves..

     

       159
       157
        
           services.xserver.display = null; # We specify our own display (and logfile) in xserver-wrapper up there

     

       160
       158
        
         };

+23 -5

nixos/release.nix

···

       92
       92
        
         }).config));

     

       93
       93
        
       

     

       94
       94
        
       

     

       95
       95
       +
         cleanConfig = import ./lib/eval-config.nix {

     

       96
       96
       +
           system = "x86_64-linux";

     

       97
       97
       +
           modules = [ ];

     

       98
       98
       +
           pkgs = with pkgs.lib;

     

       99
       99
       +
             let

     

       100
       100
       +
               scrubDerivations = namePrefix: pkgSet: mapAttrs

     

       101
       101
       +
                 (name: value:

     

       102
       102
       +
                   let wholeName = "${namePrefix}.${name}"; in

     

       103
       103
       +
                   if isAttrs value then

     

       104
       104
       +
                     scrubDerivations wholeName value

     

       105
       105
       +
                     // (optionalAttrs (isDerivation value) { outPath = "\${${wholeName}}"; })

     

       106
       106
       +
                   else value

     

       107
       107
       +
                 )

     

       108
       108
       +
                 pkgSet;

     

       109
       109
       +
             in scrubDerivations "pkgs" pkgs;

     

       110
       110
       +
         };

     

       111
       111
       +
         docs = (import ./doc/manual) {

     

       112
       112
       +
           inherit pkgs version;

     

       113
       113
       +
           revision = versionModule.system.nixosRevision;

     

       114
       114
       +
           inherit (cleanConfig) options;

     

       115
       115
       +
         };

     

       116
       116
       +
       

     

       95
       117
        
       in rec {

     

       96
       118
        
       

     

       97
       119
        
         channel = import lib/make-channel.nix { inherit pkgs nixpkgs version versionSuffix; };

     

       98
       120
        
       

     

       99
       99
       -
         manual = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manual);

     

       100
       100
       -
         manualPDF = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manualPDF)).x86_64-linux;

     

       101
       101
       -
         manpages = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manpages);

     

       102
       102
       -
         options = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.optionsJSON)).x86_64-linux;

     

       103
       103
       -
       

     

       121
       121
       +
         inherit (docs) manual manualPDF manpages optionsJSON;

     

       104
       122
        
       

     

       105
       123
        
         # Build the initial ramdisk so Hydra can keep track of its size over time.

     

       106
       124
        
         initialRamdisk = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.initialRamdisk);