commit 889351af8b8a9e8bb39dbd09dc56691a28b9d823 · 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 recurse into an attribute

     

       210
       210
       +
            function that tells it whether to recursive 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.

+2 -1

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

     

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

     

       41
       40
        
             };

     

       42
       41
        
       

     
···

       226
       225
        
             '';

     

       227
       226
        
       

     

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

     

       229
       230
        
       

     

       230
       231
        
         };

     

       231
       232
        
       }

+2 -1

nixos/modules/programs/venus.nix

···

       99
       99
        
             };

     

       100
       100
        
       

     

       101
       101
        
             outputTheme = mkOption {

     

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

     

       103
       102
        
               type = types.path;

     

       104
       103
        
               description = ''

     

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

     
···

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

     

       170
       169
        
               startAt = cfg.dates;

     

       171
       170
        
             };

     

       171
       171
       +
       

     

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

     

       172
       173
        
       

     

       173
       174
        
         };

     

       174
       175
        
       }

+2 -1

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

···

       32
       32
        
               '';

     

       33
       33
        
             };

     

       34
       34
        
             configurationDir = mkOption {

     

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

     

       36
       35
        
               description = ''

     

       37
       36
        
                 The base directory for ActiveMQ's configuration.

     

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

     
···

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

     

       126
       125
        
             '';

     

       127
       126
        
           };

     

       127
       127
       +
       

     

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

     

       128
       129
        
       

     

       129
       130
        
         };

     

       130
       131

+2 -1

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

     

       84
       83
        
             description = ''

     

       85
       84
        
               Browser used to show the manual.

     

       86
       85
        
             '';

     
···

       117
       116
        
       

     

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

     

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

     

       119
       119
       +
       

     

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

     

       120
       121
        
       

     

       121
       122
        
         };

     

       122
       123

+3 -1

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

     

       101
       100
        
               description = ''

     

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

     

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

     
···

       153
       152
        
           };

     

       154
       153
        
       

     

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

     

       155
       155
       +
       

     

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

     

       157
       157
       +
       

     

       156
       158
        
         };

     

       157
       159
        
       }

+3 -1

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

     

       91
       90
        
             type = types.str;

     

       92
       91
        
           };

     

       93
       92
        
       

     
···

       233
       232
        
             home = cfg.dataDir;

     

       234
       233
        
             createHome = true;

     

       235
       234
        
           };

     

       235
       235
       +
       

     

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

     

       237
       237
       +
       

     

       236
       238
        
         };

     

       237
       239
        
       }

+1 -4

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. 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).

     

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

     

       59
       56
        
               '';

     

       60
       57
        
             };

     

       61
       58
        
             customResolver = mkOption {

+3 -2

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

···

       46
       46
        
       

     

       47
       47
        
             phpIni = mkOption {

     

       48
       48
        
               type = types.path;

     

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

     

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

     

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

     

       51
       50
        
             };

     

       52
       51
        
       

     

       53
       52
        
             poolConfigs = mkOption {

     
···

       87
       86
        
               PIDFile = pidFile;

     

       88
       87
        
             };

     

       89
       88
        
           };

     

       89
       89
       +
       

     

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

     

       90
       91
        
       

     

       91
       92
        
         };

     

       92
       93
        
       }

+3 -1

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

     

       91
       90
        
               description = ''

     

       92
       91
        
                 The background image or color to use.

     

       93
       92
        
               '';

     
···

       153
       152
        
           };

     

       154
       153
        
       

     

       155
       154
        
           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
       +
       

     

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

     

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

     

       158
       160
        
         };

+5 -23

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
       -
       

     

       117
       95
        
       in rec {

     

       118
       96
        
       

     

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

     

       120
       98
        
       

     

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

     

       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
       +
       

     

       122
       104
        
       

     

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

     

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