commit 583e3d6d248ce22704a61e51ea9bb3eaf32b4784 · pyrox.dev/nixpkgs

+34

nixos/doc/manual/default.nix

···

       15
       15
        
         inherit (pkgs) buildPackages runCommand docbook_xsl_ns;

     

       16
       16
        
       

     

       17
       17
        
         inherit (pkgs.lib)

     

       18
       18
       +
           evalModules

     

       18
       19
        
           hasPrefix

     

       19
       20
        
           removePrefix

     

       20
       21
        
           flip

     
···

       117
       118
        
               ${testOptionsDoc.optionsJSON}/${common.outputPath}/options.json

     

       118
       119
        
           sed -e '/@PYTHON_MACHINE_METHODS@/ {' -e 'r ${testDriverMachineDocstrings}/machine-methods.md' -e 'd' -e '}' \

     

       119
       120
        
             -i ./development/writing-nixos-tests.section.md

     

       121
       121
       +
           substituteInPlace ./development/modular-services.md \

     

       122
       122
       +
             --replace-fail \

     

       123
       123
       +
               '@PORTABLE_SERVICE_OPTIONS@' \

     

       124
       124
       +
               ${portableServiceOptions.optionsJSON}/${common.outputPath}/options.json

     

       125
       125
       +
           substituteInPlace ./development/modular-services.md \

     

       126
       126
       +
             --replace-fail \

     

       127
       127
       +
               '@SYSTEMD_SERVICE_OPTIONS@' \

     

       128
       128
       +
               ${systemdServiceOptions.optionsJSON}/${common.outputPath}/options.json

     

       120
       129
        
         '';

     

       130
       130
       +
       

     

       131
       131
       +
         portableServiceOptions = buildPackages.nixosOptionsDoc {

     

       132
       132
       +
           inherit (evalModules { modules = [ ../../modules/system/service/portable/service.nix ]; }) options;

     

       133
       133
       +
           inherit revision warningsAreErrors;

     

       134
       134
       +
           transformOptions =

     

       135
       135
       +
             opt:

     

       136
       136
       +
             opt

     

       137
       137
       +
             // {

     

       138
       138
       +
               # Clean up declaration sites to not refer to the NixOS source tree.

     

       139
       139
       +
               declarations = map stripAnyPrefixes opt.declarations;

     

       140
       140
       +
             };

     

       141
       141
       +
         };

     

       142
       142
       +
       

     

       143
       143
       +
         systemdServiceOptions = buildPackages.nixosOptionsDoc {

     

       144
       144
       +
           inherit (evalModules { modules = [ ../../modules/system/service/systemd/service.nix ]; }) options;

     

       145
       145
       +
           # TODO: filter out options that are not systemd-specific, maybe also change option prefix to just `service-opt-`?

     

       146
       146
       +
           inherit revision warningsAreErrors;

     

       147
       147
       +
           transformOptions =

     

       148
       148
       +
             opt:

     

       149
       149
       +
             opt

     

       150
       150
       +
             // {

     

       151
       151
       +
               # Clean up declaration sites to not refer to the NixOS source tree.

     

       152
       152
       +
               declarations = map stripAnyPrefixes opt.declarations;

     

       153
       153
       +
             };

     

       154
       154
       +
         };

     

       121
       155
        
       

     

       122
       156
        
       in

     

       123
       157
        
       rec {

nixos/doc/manual/development/development.md

···

       12
       12
        
       nixos-tests.chapter.md

     

       13
       13
        
       developing-the-test-driver.chapter.md

     

       14
       14
        
       testing-installer.chapter.md

     

       15
       15
       +
       modular-services.md

     

       15
       16
        
       ```

+98

nixos/doc/manual/development/modular-services.md

···

       1
       1
       +
       

     

       2
       2
       +
       # Modular Services {#modular-services}

     

       3
       3
       +
       

     

       4
       4
       +
       Status: in development. This functionality is new in NixOS 25.11, and significant changes should be expected. We'd love to hear your feedback in <https://github.com/NixOS/nixpkgs/pull/372170>

     

       5
       5
       +
       

     

       6
       6
       +
       Traditionally, NixOS services were defined using sets of options *in* modules, not *as* modules. This made them non-modular, resulting in problems with composability, reuse, and portability.

     

       7
       7
       +
       

     

       8
       8
       +
       A configuration management framework is an application of `evalModules` with the `class` and `specialArgs` input attribute set to particular values.

     

       9
       9
       +
       NixOS is such a configuration management framework, and so are [Home Manager](https://github.com/nix-community/home-manager) and [`nix-darwin`](https://github.com/lnl7/nix-darwin).

     

       10
       10
       +
       

     

       11
       11
       +
       The service management component of a configuration management framework is the set of module options that connects Nix expressions with the underlying service (or process) manager.

     

       12
       12
       +
       For NixOS this is the module wrapping [`systemd`](https://systemd.io/), on `nix-darwin` this is the module wrapping [`launchd`](https://en.wikipedia.org/wiki/Launchd).

     

       13
       13
       +
       

     

       14
       14
       +
       A *modular service* is a [module] that defines values for a core set of options declared in the service management component of a configuration management framework, including which program to run.

     

       15
       15
       +
       Since it's a module, it can be composed with other modules via `imports` to extend its functionality.

     

       16
       16
       +
       

     

       17
       17
       +
       NixOS provides two options into which such modules can be plugged:

     

       18
       18
       +
       

     

       19
       19
       +
       - `system.services.<name>`

     

       20
       20
       +
       - an option for user services (TBD)

     

       21
       21
       +
       

     

       22
       22
       +
       Crucially, these options have the type [`attrsOf`] [`submodule`].

     

       23
       23
       +
       The name of the service is the attribute name corresponding to `attrsOf`.

     

       24
       24
       +
       <!-- ^ This is how composition is *always* provided, instead of a difficult thing (but this is reference docs, not a changelog) -->

     

       25
       25
       +
       The `submodule` is pre-loaded with two modules:

     

       26
       26
       +
       - a generic module that is intended to be portable

     

       27
       27
       +
       - a module with systemd-specific options, whose values or defaults derive from the generic module's option values.

     

       28
       28
       +
       

     

       29
       29
       +
       So note that the default value of `system.services.<name>` is not a complete service. It requires that the user provide a value, and this is typically done by importing a module. For example:

     

       30
       30
       +
       

     

       31
       31
       +
       <!-- Not using typical example syntax, because reading this is *not* optional, and should it should not be folded closed. -->

     

       32
       32
       +
       ```nix

     

       33
       33
       +
       {

     

       34
       34
       +
         system.services.my-service-instance = {

     

       35
       35
       +
           imports = [ pkgs.some-application.services.some-service-module ];

     

       36
       36
       +
           foo.settings = {

     

       37
       37
       +
             # ...

     

       38
       38
       +
           };

     

       39
       39
       +
         };

     

       40
       40
       +
       }

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

       43
       43
       +
       ## Portability {#modular-service-portability}

     

       44
       44
       +
       

     

       45
       45
       +
       It is possible to write service modules that are portable. This is done by either avoiding the `systemd` option tree, or by defining process-manager-specific definitions in an optional way:

     

       46
       46
       +
       

     

       47
       47
       +
       ```nix

     

       48
       48
       +
       { config, options, lib, ... }: {

     

       49
       49
       +
         _class = "service";

     

       50
       50
       +
         config = {

     

       51
       51
       +
           process.argv = [ (lib.getExe config.foo.program) ];

     

       52
       52
       +
         } // lib.optionalAttrs (options?systemd) {

     

       53
       53
       +
           # ... systemd-specific definitions ...

     

       54
       54
       +
         };

     

       55
       55
       +
       }

     

       56
       56
       +
       ```

     

       57
       57
       +
       

     

       58
       58
       +
       This way, the module can be loaded into a configuration manager that does not use systemd, and the `systemd` definitions will be ignored.

     

       59
       59
       +
       Similarly, other configuration managers can declare their own options for services to customize.

     

       60
       60
       +
       

     

       61
       61
       +
       ## Composition and Ownership {#modular-service-composition}

     

       62
       62
       +
       

     

       63
       63
       +
       Compared to traditional services, modular services are inherently more composable, by virtue of being modules and receiving a user-provided name when imported.

     

       64
       64
       +
       However, composition can not end there, because services need to be able to interact with each other.

     

       65
       65
       +
       This can be achieved in two ways:

     

       66
       66
       +
       1. Users can link services together by providing the necessary NixOS configuration.

     

       67
       67
       +
       2. Services can be compositions of other services.

     

       68
       68
       +
       

     

       69
       69
       +
       These aren't mutually exclusive. In fact, it is a good practice when developing services to first write them as individual services, and then compose them into a higher-level composition. Each of these services is a valid modular service, including their composition.

     

       70
       70
       +
       

     

       71
       71
       +
       ## Migration {#modular-service-migration}

     

       72
       72
       +
       

     

       73
       73
       +
       Many services could be migrated to the modular service system, but even when the modular service system is mature, it is not necessary to migrate all services.

     

       74
       74
       +
       For instance, many system-wide services are a mandatory part of a desktop system, and it doesn't make sense to have multiple instances of them.

     

       75
       75
       +
       Moving their logic into separate Nix files may still be beneficial for the efficient evaluation of configurations that don't use those services, but that is a rather minor benefit, unless modular services potentially become the standard way to define services.

     

       76
       76
       +
       

     

       77
       77
       +
       <!-- TODO example of a single-instance service -->

     

       78
       78
       +
       

     

       79
       79
       +
       ## Portable Service Options {#modular-service-options-portable}

     

       80
       80
       +
       

     

       81
       81
       +
       ```{=include=} options

     

       82
       82
       +
       id-prefix: service-opt-

     

       83
       83
       +
       list-id: service-options

     

       84
       84
       +
       source: @PORTABLE_SERVICE_OPTIONS@

     

       85
       85
       +
       ```

     

       86
       86
       +
       

     

       87
       87
       +
       ## Systemd-specific Service Options {#modular-service-options-systemd}

     

       88
       88
       +
       

     

       89
       89
       +
       ```{=include=} options

     

       90
       90
       +
       id-prefix: systemd-service-opt-

     

       91
       91
       +
       list-id: systemd-service-options

     

       92
       92
       +
       source: @SYSTEMD_SERVICE_OPTIONS@

     

       93
       93
       +
       ```

     

       94
       94
       +
       

     

       95
       95
       +
       [module]: https://nixos.org/manual/nixpkgs/stable/index.html#module-system

     

       96
       96
       +
       <!-- TODO: more anchors -->

     

       97
       97
       +
       [`attrsOf`]: #sec-option-types-composed

     

       98
       98
       +
       [`submodule`]: #sec-option-types-submodule

+18

nixos/doc/manual/redirects.json

···

       11
       11
        
         "book-nixos-manual": [

     

       12
       12
        
           "index.html#book-nixos-manual"

     

       13
       13
        
         ],

     

       14
       14
       +
         "modular-service-composition": [

     

       15
       15
       +
           "index.html#modular-service-composition"

     

       16
       16
       +
         ],

     

       17
       17
       +
         "modular-service-migration": [

     

       18
       18
       +
           "index.html#modular-service-migration"

     

       19
       19
       +
         ],

     

       20
       20
       +
         "modular-service-options-portable": [

     

       21
       21
       +
           "index.html#modular-service-options-portable"

     

       22
       22
       +
         ],

     

       23
       23
       +
         "modular-service-options-systemd": [

     

       24
       24
       +
           "index.html#modular-service-options-systemd"

     

       25
       25
       +
         ],

     

       26
       26
       +
         "modular-service-portability": [

     

       27
       27
       +
           "index.html#modular-service-portability"

     

       28
       28
       +
         ],

     

       29
       29
       +
         "modular-services": [

     

       30
       30
       +
           "index.html#modular-services"

     

       31
       31
       +
         ],

     

       14
       32
        
         "module-services-anubis": [

     

       15
       33
        
           "index.html#module-services-anubis"

     

       16
       34
        
         ],

+3 -1

nixos/modules/misc/assertions.nix

···

       32
       32
        
           };

     

       33
       33
        
       

     

       34
       34
        
         };

     

       35
       35
       -
         # impl of assertions is in <nixpkgs/nixos/modules/system/activation/top-level.nix>

     

       35
       35
       +
         # impl of assertions is in

     

       36
       36
       +
         # - <nixpkgs/nixos/modules/system/activation/top-level.nix>

     

       37
       37
       +
         # - <nixpkgs/nixos/modules/system/service/portable/lib.nix>

     

       36
       38
        
       }

nixos/modules/module-list.nix

···

       1843
       1843
        
         ./system/boot/uvesafb.nix

     

       1844
       1844
        
         ./system/boot/zram-as-tmp.nix

     

       1845
       1845
        
         ./system/etc/etc-activation.nix

     

       1846
       1846
       +
         ./system/service/systemd/system.nix

     

       1847
       1847
       +
         ./system/service/systemd/user.nix

     

       1846
       1848
        
         ./tasks/auto-upgrade.nix

     

       1847
       1849
        
         ./tasks/bcache.nix

     

       1848
       1850
        
         ./tasks/cpu-freq.nix

+219 -216

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

···

       4
       4
        
         pkgs,

     

       5
       5
        
         ...

     

       6
       6
        
       }:

     

       7
       7
       -
       

     

       8
       8
       -
       with lib;

     

       9
       9
       -
       

     

       10
       7
        
       let

     

       8
       8
       +
         inherit (lib)

     

       9
       9
       +
           mkIf

     

       10
       10
       +
           mkMerge

     

       11
       11
       +
           ;

     

       12
       12
       +
       

     

       11
       13
        
         cfg = config.services.nextcloud;

     

       12
       14
        
       

     

       13
       15
        
         overridePackage = cfg.package.override {

     
···

       43
       45
        
           nix-apps = {

     

       44
       46
        
             enabled = cfg.extraApps != { };

     

       45
       47
        
             linkTarget = pkgs.linkFarm "nix-apps" (

     

       46
       46
       -
               mapAttrsToList (name: path: { inherit name path; }) cfg.extraApps

     

       48
       48
       +
               lib.mapAttrsToList (name: path: { inherit name path; }) cfg.extraApps

     

       47
       49
        
             );

     

       48
       50
        
             writable = false;

     

       49
       51
        
           };

     
···

       63
       65
        
             ''

     

       64
       66
        
               mkdir $out

     

       65
       67
        
               ln -sfv "${overridePackage}"/* "$out"

     

       66
       66
       -
               ${concatStrings (

     

       67
       67
       -
                 mapAttrsToList (

     

       68
       68
       +
               ${lib.concatStrings (

     

       69
       69
       +
                 lib.mapAttrsToList (

     

       68
       70
        
                   name: store:

     

       69
       69
       -
                   optionalString (store.enabled && store ? linkTarget) ''

     

       71
       71
       +
                   lib.optionalString (store.enabled && store ? linkTarget) ''

     

       70
       72
        
                     if [ -e "$out"/${name} ]; then

     

       71
       73
        
                       echo "Didn't expect ${name} already in $out!"

     

       72
       74
        
                       exit 1

     
···

       90
       92
        
                 intl

     

       91
       93
        
                 sodium

     

       92
       94
        
               ] # recommended

     

       93
       93
       -
               ++ optional cfg.enableImagemagick imagick

     

       95
       95
       +
               ++ lib.optional cfg.enableImagemagick imagick

     

       94
       96
        
               # Optionally enabled depending on caching settings

     

       95
       95
       -
               ++ optional cfg.caching.apcu apcu

     

       96
       96
       -
               ++ optional cfg.caching.redis redis

     

       97
       97
       -
               ++ optional cfg.caching.memcached memcached

     

       98
       98
       -
               ++ optional (cfg.settings.log_type == "systemd") systemd

     

       97
       97
       +
               ++ lib.optional cfg.caching.apcu apcu

     

       98
       98
       +
               ++ lib.optional cfg.caching.redis redis

     

       99
       99
       +
               ++ lib.optional cfg.caching.memcached memcached

     

       100
       100
       +
               ++ lib.optional (cfg.settings.log_type == "systemd") systemd

     

       99
       101
        
             )

     

       100
       102
        
             ++ cfg.phpExtraExtensions all; # Enabled by user

     

       101
       103
        
           extraConfig = toKeyValue cfg.phpOptions;

     

       102
       104
        
         };

     

       103
       105
        
       

     

       104
       104
       -
         toKeyValue = generators.toKeyValue {

     

       105
       105
       -
           mkKeyValue = generators.mkKeyValueDefault { } " = ";

     

       106
       106
       +
         toKeyValue = lib.generators.toKeyValue {

     

       107
       107
       +
           mkKeyValue = lib.generators.mkKeyValueDefault { } " = ";

     

       106
       108
        
         };

     

       107
       109
        
       

     

       108
       108
       -
         phpCli = concatStringsSep " " (

     

       110
       110
       +
         phpCli = lib.concatStringsSep " " (

     

       109
       111
        
           [

     

       110
       110
       -
             "${getExe phpPackage}"

     

       112
       112
       +
             "${lib.getExe phpPackage}"

     

       111
       113
        
           ]

     

       112
       112
       -
           ++ optionals (cfg.cli.memoryLimit != null) [

     

       114
       114
       +
           ++ lib.optionals (cfg.cli.memoryLimit != null) [

     

       113
       115
        
             "-dmemory_limit=${cfg.cli.memoryLimit}"

     

       114
       116
        
           ]

     

       115
       117
        
         );

     
···

       198
       200
        
               let

     

       199
       201
        
                 s3 = c.objectstore.s3;

     

       200
       202
        
               in

     

       201
       201
       -
               optionalString s3.enable ''

     

       203
       203
       +
               lib.optionalString s3.enable ''

     

       202
       204
        
                 'objectstore' => [

     

       203
       205
        
                   'class' => '\\OC\\Files\\ObjectStore\\S3',

     

       204
       206
        
                   'arguments' => [

     

       205
       207
        
                     'bucket' => '${s3.bucket}',

     

       206
       206
       -
                     'verify_bucket_exists' => ${boolToString s3.verify_bucket_exists},

     

       208
       208
       +
                     'verify_bucket_exists' => ${lib.boolToString s3.verify_bucket_exists},

     

       207
       209
        
                     'key' => '${s3.key}',

     

       208
       210
        
                     'secret' => nix_read_secret('s3_secret'),

     

       209
       209
       -
                     ${optionalString (s3.hostname != null) "'hostname' => '${s3.hostname}',"}

     

       210
       210
       -
                     ${optionalString (s3.port != null) "'port' => ${toString s3.port},"}

     

       211
       211
       -
                     'use_ssl' => ${boolToString s3.useSsl},

     

       212
       212
       -
                     ${optionalString (s3.region != null) "'region' => '${s3.region}',"}

     

       213
       213
       -
                     'use_path_style' => ${boolToString s3.usePathStyle},

     

       214
       214
       -
                     ${optionalString (s3.sseCKeyFile != null) "'sse_c_key' => nix_read_secret('s3_sse_c_key'),"}

     

       211
       211
       +
                     ${lib.optionalString (s3.hostname != null) "'hostname' => '${s3.hostname}',"}

     

       212
       212
       +
                     ${lib.optionalString (s3.port != null) "'port' => ${toString s3.port},"}

     

       213
       213
       +
                     'use_ssl' => ${lib.boolToString s3.useSsl},

     

       214
       214
       +
                     ${lib.optionalString (s3.region != null) "'region' => '${s3.region}',"}

     

       215
       215
       +
                     'use_path_style' => ${lib.boolToString s3.usePathStyle},

     

       216
       216
       +
                     ${lib.optionalString (s3.sseCKeyFile != null) "'sse_c_key' => nix_read_secret('s3_sse_c_key'),"}

     

       215
       217
        
                   ],

     

       216
       218
        
                 ]

     

       217
       219
        
               '';

     
···

       220
       222
        
               let

     

       221
       223
        
                 x = cfg.appstoreEnable;

     

       222
       224
        
               in

     

       223
       223
       -
               if x == null then "false" else boolToString x;

     

       225
       225
       +
               if x == null then "false" else lib.boolToString x;

     

       224
       226
        
             mkAppStoreConfig =

     

       225
       227
        
               name:

     

       226
       228
        
               { enabled, writable, ... }:

     

       227
       227
       -
               optionalString enabled ''

     

       228
       228
       -
                 [ 'path' => '${webroot}/${name}', 'url' => '/${name}', 'writable' => ${boolToString writable} ],

     

       229
       229
       +
               lib.optionalString enabled ''

     

       230
       230
       +
                 [ 'path' => '${webroot}/${name}', 'url' => '/${name}', 'writable' => ${lib.boolToString writable} ],

     

       229
       231
        
               '';

     

       230
       232
        
           in

     

       231
       233
        
           pkgs.writeText "nextcloud-config.php" ''

     

       232
       234
        
             <?php

     

       233
       233
       -
             ${optionalString requiresRuntimeSystemdCredentials ''

     

       235
       235
       +
             ${lib.optionalString requiresRuntimeSystemdCredentials ''

     

       234
       236
        
               function nix_read_secret($credential_name) {

     

       235
       237
        
                 $credentials_directory = getenv("CREDENTIALS_DIRECTORY");

     

       236
       238
        
                 if (!$credentials_directory) {

     
···

       278
       280
        
             }

     

       279
       281
        
             $CONFIG = [

     

       280
       282
        
               'apps_paths' => [

     

       281
       281
       -
                 ${concatStrings (mapAttrsToList mkAppStoreConfig appStores)}

     

       283
       283
       +
                 ${lib.concatStrings (lib.mapAttrsToList mkAppStoreConfig appStores)}

     

       282
       284
        
               ],

     

       283
       283
       -
               ${optionalString (showAppStoreSetting) "'appstoreenabled' => ${renderedAppStoreSetting},"}

     

       284
       284
       -
               ${optionalString cfg.caching.apcu "'memcache.local' => '\\OC\\Memcache\\APCu',"}

     

       285
       285
       -
               ${optionalString (c.dbname != null) "'dbname' => '${c.dbname}',"}

     

       286
       286
       -
               ${optionalString (c.dbhost != null) "'dbhost' => '${c.dbhost}',"}

     

       287
       287
       -
               ${optionalString (c.dbuser != null) "'dbuser' => '${c.dbuser}',"}

     

       288
       288
       -
               ${optionalString (c.dbtableprefix != null) "'dbtableprefix' => '${toString c.dbtableprefix}',"}

     

       289
       289
       -
               ${optionalString (c.dbpassFile != null) "'dbpassword' => nix_read_secret('dbpass'),"}

     

       285
       285
       +
               ${lib.optionalString (showAppStoreSetting) "'appstoreenabled' => ${renderedAppStoreSetting},"}

     

       286
       286
       +
               ${lib.optionalString cfg.caching.apcu "'memcache.local' => '\\OC\\Memcache\\APCu',"}

     

       287
       287
       +
               ${lib.optionalString (c.dbname != null) "'dbname' => '${c.dbname}',"}

     

       288
       288
       +
               ${lib.optionalString (c.dbhost != null) "'dbhost' => '${c.dbhost}',"}

     

       289
       289
       +
               ${lib.optionalString (c.dbuser != null) "'dbuser' => '${c.dbuser}',"}

     

       290
       290
       +
               ${lib.optionalString (

     

       291
       291
       +
                 c.dbtableprefix != null

     

       292
       292
       +
               ) "'dbtableprefix' => '${toString c.dbtableprefix}',"}

     

       293
       293
       +
               ${lib.optionalString (c.dbpassFile != null) "'dbpassword' => nix_read_secret('dbpass'),"}

     

       290
       294
        
               'dbtype' => '${c.dbtype}',

     

       291
       295
        
               ${objectstoreConfig}

     

       292
       296
        
             ];

     
···

       296
       300
        
               "impossible: this should never happen (decoding generated settings file %s failed)"

     

       297
       301
        
             ));

     

       298
       302
        
       

     

       299
       299
       -
             ${optionalString (cfg.secretFile != null) ''

     

       303
       303
       +
             ${lib.optionalString (cfg.secretFile != null) ''

     

       300
       304
        
               $CONFIG = array_replace_recursive($CONFIG, nix_read_secret_and_decode_json_file('secret_file'));

     

       301
       305
        
             ''}

     

       302
       306
        
           '';

     
···

       304
       308
        
       {

     

       305
       309
        
       

     

       306
       310
        
         imports = [

     

       307
       307
       -
           (mkRenamedOptionModule

     

       311
       311
       +
           (lib.mkRenamedOptionModule

     

       308
       312
        
             [ "services" "nextcloud" "cron" "memoryLimit" ]

     

       309
       313
        
             [ "services" "nextcloud" "cli" "memoryLimit" ]

     

       310
       314
        
           )

     

       311
       311
       -
           (mkRemovedOptionModule [ "services" "nextcloud" "enableBrokenCiphersForSSE" ] ''

     

       315
       315
       +
           (lib.mkRemovedOptionModule [ "services" "nextcloud" "enableBrokenCiphersForSSE" ] ''

     

       312
       316
        
             This option has no effect since there's no supported Nextcloud version packaged here

     

       313
       317
        
             using OpenSSL for RC4 SSE.

     

       314
       318
        
           '')

     

       315
       315
       -
           (mkRemovedOptionModule [ "services" "nextcloud" "config" "dbport" ] ''

     

       319
       319
       +
           (lib.mkRemovedOptionModule [ "services" "nextcloud" "config" "dbport" ] ''

     

       316
       320
        
             Add port to services.nextcloud.config.dbhost instead.

     

       317
       321
        
           '')

     

       318
       318
       -
           (mkRenamedOptionModule

     

       322
       322
       +
           (lib.mkRenamedOptionModule

     

       319
       323
        
             [ "services" "nextcloud" "logLevel" ]

     

       320
       324
        
             [ "services" "nextcloud" "settings" "loglevel" ]

     

       321
       325
        
           )

     

       322
       322
       -
           (mkRenamedOptionModule

     

       326
       326
       +
           (lib.mkRenamedOptionModule

     

       323
       327
        
             [ "services" "nextcloud" "logType" ]

     

       324
       328
        
             [ "services" "nextcloud" "settings" "log_type" ]

     

       325
       329
        
           )

     

       326
       326
       -
           (mkRenamedOptionModule

     

       330
       330
       +
           (lib.mkRenamedOptionModule

     

       327
       331
        
             [ "services" "nextcloud" "config" "defaultPhoneRegion" ]

     

       328
       332
        
             [ "services" "nextcloud" "settings" "default_phone_region" ]

     

       329
       333
        
           )

     

       330
       330
       -
           (mkRenamedOptionModule

     

       334
       334
       +
           (lib.mkRenamedOptionModule

     

       331
       335
        
             [ "services" "nextcloud" "config" "overwriteProtocol" ]

     

       332
       336
        
             [ "services" "nextcloud" "settings" "overwriteprotocol" ]

     

       333
       337
        
           )

     

       334
       334
       -
           (mkRenamedOptionModule

     

       338
       338
       +
           (lib.mkRenamedOptionModule

     

       335
       339
        
             [ "services" "nextcloud" "skeletonDirectory" ]

     

       336
       340
        
             [ "services" "nextcloud" "settings" "skeletondirectory" ]

     

       337
       341
        
           )

     

       338
       338
       -
           (mkRenamedOptionModule

     

       342
       342
       +
           (lib.mkRenamedOptionModule

     

       339
       343
        
             [ "services" "nextcloud" "globalProfiles" ]

     

       340
       344
        
             [ "services" "nextcloud" "settings" "profile.enabled" ]

     

       341
       345
        
           )

     

       342
       342
       -
           (mkRenamedOptionModule

     

       346
       346
       +
           (lib.mkRenamedOptionModule

     

       343
       347
        
             [ "services" "nextcloud" "config" "extraTrustedDomains" ]

     

       344
       348
        
             [ "services" "nextcloud" "settings" "trusted_domains" ]

     

       345
       349
        
           )

     

       346
       346
       -
           (mkRenamedOptionModule

     

       350
       350
       +
           (lib.mkRenamedOptionModule

     

       347
       351
        
             [ "services" "nextcloud" "config" "trustedProxies" ]

     

       348
       352
        
             [ "services" "nextcloud" "settings" "trusted_proxies" ]

     

       349
       353
        
           )

     

       350
       350
       -
           (mkRenamedOptionModule

     

       354
       354
       +
           (lib.mkRenamedOptionModule

     

       351
       355
        
             [ "services" "nextcloud" "extraOptions" ]

     

       352
       356
        
             [ "services" "nextcloud" "settings" ]

     

       353
       357
        
           )

     

       354
       354
       -
           (mkRenamedOptionModule

     

       358
       358
       +
           (lib.mkRenamedOptionModule

     

       355
       359
        
             [ "services" "nextcloud" "config" "objectstore" "s3" "autocreate" ]

     

       356
       360
        
             [ "services" "nextcloud" "config" "objectstore" "s3" "verify_bucket_exists" ]

     

       357
       361
        
           )

     

       358
       362
        
         ];

     

       359
       363
        
       

     

       360
       364
        
         options.services.nextcloud = {

     

       361
       361
       -
           enable = mkEnableOption "nextcloud";

     

       365
       365
       +
           enable = lib.mkEnableOption "nextcloud";

     

       362
       366
        
       

     

       363
       363
       -
           hostName = mkOption {

     

       364
       364
       -
             type = types.str;

     

       367
       367
       +
           hostName = lib.mkOption {

     

       368
       368
       +
             type = lib.types.str;

     

       365
       369
        
             description = "FQDN for the nextcloud instance.";

     

       366
       370
        
           };

     

       367
       367
       -
           home = mkOption {

     

       368
       368
       -
             type = types.str;

     

       371
       371
       +
           home = lib.mkOption {

     

       372
       372
       +
             type = lib.types.str;

     

       369
       373
        
             default = "/var/lib/nextcloud";

     

       370
       374
        
             description = "Storage path of nextcloud.";

     

       371
       375
        
           };

     

       372
       372
       -
           datadir = mkOption {

     

       373
       373
       -
             type = types.str;

     

       376
       376
       +
           datadir = lib.mkOption {

     

       377
       377
       +
             type = lib.types.str;

     

       374
       378
        
             default = config.services.nextcloud.home;

     

       375
       375
       -
             defaultText = literalExpression "config.services.nextcloud.home";

     

       379
       379
       +
             defaultText = lib.literalExpression "config.services.nextcloud.home";

     

       376
       380
        
             description = ''

     

       377
       381
        
               Nextcloud's data storage path.  Will be [](#opt-services.nextcloud.home) by default.

     

       378
       382
        
               This folder will be populated with a config.php file and a data folder which contains the state of the instance (excluding the database).";

     

       379
       383
        
             '';

     

       380
       384
        
             example = "/mnt/nextcloud-file";

     

       381
       385
        
           };

     

       382
       382
       -
           extraApps = mkOption {

     

       383
       383
       -
             type = types.attrsOf types.package;

     

       386
       386
       +
           extraApps = lib.mkOption {

     

       387
       387
       +
             type = lib.types.attrsOf lib.types.package;

     

       384
       388
        
             default = { };

     

       385
       389
        
             description = ''

     

       386
       390
        
               Extra apps to install. Should be an attrSet of appid to packages generated by fetchNextcloudApp.

     

       387
       391
        
               The appid must be identical to the "id" value in the apps appinfo/info.xml.

     

       388
       392
        
               Using this will disable the appstore to prevent Nextcloud from updating these apps (see [](#opt-services.nextcloud.appstoreEnable)).

     

       389
       393
        
             '';

     

       390
       390
       -
             example = literalExpression ''

     

       394
       394
       +
             example = lib.literalExpression ''

     

       391
       395
        
               {

     

       392
       396
        
                 inherit (pkgs.nextcloud31Packages.apps) mail calendar contacts;

     

       393
       397
        
                 phonetrack = pkgs.fetchNextcloudApp {

     
···

       399
       403
        
               }

     

       400
       404
        
             '';

     

       401
       405
        
           };

     

       402
       402
       -
           extraAppsEnable = mkOption {

     

       403
       403
       -
             type = types.bool;

     

       406
       406
       +
           extraAppsEnable = lib.mkOption {

     

       407
       407
       +
             type = lib.types.bool;

     

       404
       408
        
             default = true;

     

       405
       409
        
             description = ''

     

       406
       410
        
               Automatically enable the apps in [](#opt-services.nextcloud.extraApps) every time Nextcloud starts.

     

       407
       411
        
               If set to false, apps need to be enabled in the Nextcloud web user interface or with `nextcloud-occ app:enable`.

     

       408
       412
        
             '';

     

       409
       413
        
           };

     

       410
       410
       -
           appstoreEnable = mkOption {

     

       411
       411
       -
             type = types.nullOr types.bool;

     

       414
       414
       +
           appstoreEnable = lib.mkOption {

     

       415
       415
       +
             type = lib.types.nullOr lib.types.bool;

     

       412
       416
        
             default = null;

     

       413
       417
        
             example = true;

     

       414
       418
        
             description = ''

     
···

       418
       422
        
               Set this to false to disable the installation of apps from the global appstore. App management is always enabled regardless of this setting.

     

       419
       423
        
             '';

     

       420
       424
        
           };

     

       421
       421
       -
           https = mkOption {

     

       422
       422
       -
             type = types.bool;

     

       425
       425
       +
           https = lib.mkOption {

     

       426
       426
       +
             type = lib.types.bool;

     

       423
       427
        
             default = false;

     

       424
       428
        
             description = ''

     

       425
       429
        
               Use HTTPS for generated links.

     
···

       427
       431
        
               Be aware that this also enables HTTP Strict Transport Security (HSTS) headers.

     

       428
       432
        
             '';

     

       429
       433
        
           };

     

       430
       430
       -
           package = mkOption {

     

       431
       431
       -
             type = types.package;

     

       434
       434
       +
           package = lib.mkOption {

     

       435
       435
       +
             type = lib.types.package;

     

       432
       436
        
             description = "Which package to use for the Nextcloud instance.";

     

       433
       437
        
             relatedPackages = [

     

       434
       438
        
               "nextcloud30"

     

       435
       439
        
               "nextcloud31"

     

       436
       440
        
             ];

     

       437
       441
        
           };

     

       438
       438
       -
           phpPackage = mkPackageOption pkgs "php" {

     

       442
       442
       +
           phpPackage = lib.mkPackageOption pkgs "php" {

     

       443
       443
       +
             default = [ "php83" ];

     

       439
       444
        
             example = "php82";

     

       440
       445
        
           };

     

       441
       446
        
       

     

       442
       442
       -
           finalPackage = mkOption {

     

       443
       443
       -
             type = types.package;

     

       447
       447
       +
           finalPackage = lib.mkOption {

     

       448
       448
       +
             type = lib.types.package;

     

       444
       449
        
             readOnly = true;

     

       445
       450
        
             description = ''

     

       446
       451
        
               Package to the finalized Nextcloud package, including all installed apps.

     
···

       448
       453
        
             '';

     

       449
       454
        
           };

     

       450
       455
        
       

     

       451
       451
       -
           maxUploadSize = mkOption {

     

       456
       456
       +
           maxUploadSize = lib.mkOption {

     

       452
       457
        
             default = "512M";

     

       453
       453
       -
             type = types.str;

     

       458
       458
       +
             type = lib.types.str;

     

       454
       459
        
             description = ''

     

       455
       460
        
               The upload limit for files. This changes the relevant options

     

       456
       461
        
               in php.ini and nginx if enabled.

     

       457
       462
        
             '';

     

       458
       463
        
           };

     

       459
       464
        
       

     

       460
       460
       -
           webfinger = mkOption {

     

       461
       461
       -
             type = types.bool;

     

       465
       465
       +
           webfinger = lib.mkOption {

     

       466
       466
       +
             type = lib.types.bool;

     

       462
       467
        
             default = false;

     

       463
       468
        
             description = ''

     

       464
       469
        
               Enable this option if you plan on using the webfinger plugin.

     
···

       466
       471
        
             '';

     

       467
       472
        
           };

     

       468
       473
        
       

     

       469
       469
       -
           phpExtraExtensions = mkOption {

     

       470
       470
       -
             type = with types; functionTo (listOf package);

     

       474
       474
       +
           phpExtraExtensions = lib.mkOption {

     

       475
       475
       +
             type = lib.types.functionTo (lib.types.listOf lib.types.package);

     

       471
       476
        
             default = all: [ ];

     

       472
       472
       -
             defaultText = literalExpression "all: []";

     

       477
       477
       +
             defaultText = lib.literalExpression "all: []";

     

       473
       478
        
             description = ''

     

       474
       479
        
               Additional PHP extensions to use for Nextcloud.

     

       475
       480
        
               By default, only extensions necessary for a vanilla Nextcloud installation are enabled,

     

       476
       481
        
               but you may choose from the list of available extensions and add further ones.

     

       477
       482
        
               This is sometimes necessary to be able to install a certain Nextcloud app that has additional requirements.

     

       478
       483
        
             '';

     

       479
       479
       -
             example = literalExpression ''

     

       484
       484
       +
             example = lib.literalExpression ''

     

       480
       485
        
               all: [ all.pdlib all.bz2 ]

     

       481
       486
        
             '';

     

       482
       487
        
           };

     

       483
       488
        
       

     

       484
       484
       -
           phpOptions = mkOption {

     

       485
       485
       -
             type =

     

       486
       486
       -
               with types;

     

       487
       487
       -
               attrsOf (oneOf [

     

       488
       488
       -
                 str

     

       489
       489
       -
                 int

     

       490
       490
       -
               ]);

     

       491
       491
       -
             defaultText = literalExpression (

     

       492
       492
       -
               generators.toPretty { } (

     

       493
       493
       -
                 defaultPHPSettings // { "openssl.cafile" = literalExpression "config.security.pki.caBundle"; }

     

       489
       489
       +
           phpOptions = lib.mkOption {

     

       490
       490
       +
             type = lib.types.attrsOf (

     

       491
       491
       +
               lib.types.oneOf [

     

       492
       492
       +
                 lib.types.str

     

       493
       493
       +
                 lib.types.int

     

       494
       494
       +
               ]

     

       495
       495
       +
             );

     

       496
       496
       +
             defaultText = lib.literalExpression (

     

       497
       497
       +
               lib.generators.toPretty { } (

     

       498
       498
       +
                 defaultPHPSettings // { "openssl.cafile" = lib.literalExpression "config.security.pki.caBundle"; }

     

       494
       499
        
               )

     

       495
       500
        
             );

     

       496
       501
        
             description = ''

     
···

       522
       527
        
             '';

     

       523
       528
        
           };

     

       524
       529
        
       

     

       525
       525
       -
           poolSettings = mkOption {

     

       526
       526
       -
             type =

     

       527
       527
       -
               with types;

     

       528
       528
       -
               attrsOf (oneOf [

     

       529
       529
       -
                 str

     

       530
       530
       -
                 int

     

       531
       531
       -
                 bool

     

       532
       532
       -
               ]);

     

       530
       530
       +
           poolSettings = lib.mkOption {

     

       531
       531
       +
             type = lib.types.attrsOf (

     

       532
       532
       +
               lib.types.oneOf [

     

       533
       533
       +
                 lib.types.str

     

       534
       534
       +
                 lib.types.int

     

       535
       535
       +
                 lib.types.bool

     

       536
       536
       +
               ]

     

       537
       537
       +
             );

     

       533
       538
        
             default = {

     

       534
       539
        
               "pm" = "dynamic";

     

       535
       540
        
               "pm.max_children" = "120";

     
···

       547
       552
        
             '';

     

       548
       553
        
           };

     

       549
       554
        
       

     

       550
       550
       -
           poolConfig = mkOption {

     

       551
       551
       -
             type = types.nullOr types.lines;

     

       555
       555
       +
           poolConfig = lib.mkOption {

     

       556
       556
       +
             type = lib.types.nullOr lib.types.lines;

     

       552
       557
        
             default = null;

     

       553
       558
        
             description = ''

     

       554
       559
        
               Options for Nextcloud's PHP pool. See the documentation on `php-fpm.conf` for details on configuration directives.

     

       555
       560
        
             '';

     

       556
       561
        
           };

     

       557
       562
        
       

     

       558
       558
       -
           fastcgiTimeout = mkOption {

     

       559
       559
       -
             type = types.int;

     

       563
       563
       +
           fastcgiTimeout = lib.mkOption {

     

       564
       564
       +
             type = lib.types.int;

     

       560
       565
        
             default = 120;

     

       561
       566
        
             description = ''

     

       562
       567
        
               FastCGI timeout for database connection in seconds.

     
···

       565
       570
        
       

     

       566
       571
        
           database = {

     

       567
       572
        
       

     

       568
       568
       -
             createLocally = mkOption {

     

       569
       569
       -
               type = types.bool;

     

       573
       573
       +
             createLocally = lib.mkOption {

     

       574
       574
       +
               type = lib.types.bool;

     

       570
       575
        
               default = false;

     

       571
       576
        
               description = ''

     

       572
       577
        
                 Whether to create the database and database user locally.

     
···

       576
       581
        
           };

     

       577
       582
        
       

     

       578
       583
        
           config = {

     

       579
       579
       -
             dbtype = mkOption {

     

       580
       580
       -
               type = types.nullOr (

     

       581
       581
       -
                 types.enum [

     

       584
       584
       +
             dbtype = lib.mkOption {

     

       585
       585
       +
               type = lib.types.nullOr (

     

       586
       586
       +
                 lib.types.enum [

     

       582
       587
        
                   "sqlite"

     

       583
       588
        
                   "pgsql"

     

       584
       589
        
                   "mysql"

     
···

       587
       592
        
               default = null;

     

       588
       593
        
               description = "Database type.";

     

       589
       594
        
             };

     

       590
       590
       -
             dbname = mkOption {

     

       591
       591
       -
               type = types.nullOr types.str;

     

       595
       595
       +
             dbname = lib.mkOption {

     

       596
       596
       +
               type = lib.types.nullOr lib.types.str;

     

       592
       597
        
               default = "nextcloud";

     

       593
       598
        
               description = "Database name.";

     

       594
       599
        
             };

     

       595
       595
       -
             dbuser = mkOption {

     

       596
       596
       -
               type = types.nullOr types.str;

     

       600
       600
       +
             dbuser = lib.mkOption {

     

       601
       601
       +
               type = lib.types.nullOr lib.types.str;

     

       597
       602
        
               default = "nextcloud";

     

       598
       603
        
               description = "Database user.";

     

       599
       604
        
             };

     

       600
       600
       -
             dbpassFile = mkOption {

     

       601
       601
       -
               type = types.nullOr types.str;

     

       605
       605
       +
             dbpassFile = lib.mkOption {

     

       606
       606
       +
               type = lib.types.nullOr lib.types.str;

     

       602
       607
        
               default = null;

     

       603
       608
        
               description = ''

     

       604
       609
        
                 The full path to a file that contains the database password.

     

       605
       610
        
               '';

     

       606
       611
        
             };

     

       607
       607
       -
             dbhost = mkOption {

     

       608
       608
       -
               type = types.nullOr types.str;

     

       612
       612
       +
             dbhost = lib.mkOption {

     

       613
       613
       +
               type = lib.types.nullOr lib.types.str;

     

       609
       614
        
               default =

     

       610
       615
        
                 if pgsqlLocal then

     

       611
       616
        
                   "/run/postgresql"

     
···

       622
       627
        
                 defaults to the correct Unix socket instead.

     

       623
       628
        
               '';

     

       624
       629
        
             };

     

       625
       625
       -
             dbtableprefix = mkOption {

     

       626
       626
       -
               type = types.nullOr types.str;

     

       630
       630
       +
             dbtableprefix = lib.mkOption {

     

       631
       631
       +
               type = lib.types.nullOr lib.types.str;

     

       627
       632
        
               default = null;

     

       628
       633
        
               description = ''

     

       629
       634
        
                 Table prefix in Nextcloud's database.

     
···

       633
       638
        
                 with installations that were originally provisioned with Nextcloud <20.

     

       634
       639
        
               '';

     

       635
       640
        
             };

     

       636
       636
       -
             adminuser = mkOption {

     

       637
       637
       -
               type = types.str;

     

       641
       641
       +
             adminuser = lib.mkOption {

     

       642
       642
       +
               type = lib.types.str;

     

       638
       643
        
               default = "root";

     

       639
       644
        
               description = ''

     

       640
       645
        
                 Username for the admin account. The username is only set during the

     
···

       642
       647
        
                 ID internally, it cannot be changed later!

     

       643
       648
        
               '';

     

       644
       649
        
             };

     

       645
       645
       -
             adminpassFile = mkOption {

     

       646
       646
       -
               type = types.str;

     

       650
       650
       +
             adminpassFile = lib.mkOption {

     

       651
       651
       +
               type = lib.types.str;

     

       647
       652
        
               description = ''

     

       648
       653
        
                 The full path to a file that contains the admin's password. The password is

     

       649
       654
        
                 set only in the initial setup of Nextcloud by the systemd service `nextcloud-setup.service`.

     
···

       651
       656
        
             };

     

       652
       657
        
             objectstore = {

     

       653
       658
        
               s3 = {

     

       654
       654
       -
                 enable = mkEnableOption ''

     

       659
       659
       +
                 enable = lib.mkEnableOption ''

     

       655
       660
        
                   S3 object storage as primary storage.

     

       656
       661
        
       

     

       657
       662
        
                   This mounts a bucket on an Amazon S3 object storage or compatible

     
···

       660
       665
        
                   Further details about this feature can be found in the

     

       661
       666
        
                   [upstream documentation](https://docs.nextcloud.com/server/22/admin_manual/configuration_files/primary_storage.html)

     

       662
       667
        
                 '';

     

       663
       663
       -
                 bucket = mkOption {

     

       664
       664
       -
                   type = types.str;

     

       668
       668
       +
                 bucket = lib.mkOption {

     

       669
       669
       +
                   type = lib.types.str;

     

       665
       670
        
                   example = "nextcloud";

     

       666
       671
        
                   description = ''

     

       667
       672
        
                     The name of the S3 bucket.

     

       668
       673
        
                   '';

     

       669
       674
        
                 };

     

       670
       670
       -
                 verify_bucket_exists = mkOption {

     

       671
       671
       -
                   type = types.bool;

     

       675
       675
       +
                 verify_bucket_exists = lib.mkOption {

     

       676
       676
       +
                   type = lib.types.bool;

     

       672
       677
        
                   default = true;

     

       673
       678
        
                   description = ''

     

       674
       679
        
                     Create the objectstore bucket if it does not exist.

     

       675
       680
        
                   '';

     

       676
       681
        
                 };

     

       677
       677
       -
                 key = mkOption {

     

       678
       678
       -
                   type = types.str;

     

       682
       682
       +
                 key = lib.mkOption {

     

       683
       683
       +
                   type = lib.types.str;

     

       679
       684
        
                   example = "EJ39ITYZEUH5BGWDRUFY";

     

       680
       685
        
                   description = ''

     

       681
       686
        
                     The access key for the S3 bucket.

     

       682
       687
        
                   '';

     

       683
       688
        
                 };

     

       684
       684
       -
                 secretFile = mkOption {

     

       685
       685
       -
                   type = types.str;

     

       689
       689
       +
                 secretFile = lib.mkOption {

     

       690
       690
       +
                   type = lib.types.str;

     

       686
       691
        
                   example = "/var/nextcloud-objectstore-s3-secret";

     

       687
       692
        
                   description = ''

     

       688
       693
        
                     The full path to a file that contains the access secret.

     

       689
       694
        
                   '';

     

       690
       695
        
                 };

     

       691
       691
       -
                 hostname = mkOption {

     

       692
       692
       -
                   type = types.nullOr types.str;

     

       696
       696
       +
                 hostname = lib.mkOption {

     

       697
       697
       +
                   type = lib.types.nullOr lib.types.str;

     

       693
       698
        
                   default = null;

     

       694
       699
        
                   example = "example.com";

     

       695
       700
        
                   description = ''

     

       696
       701
        
                     Required for some non-Amazon implementations.

     

       697
       702
        
                   '';

     

       698
       703
        
                 };

     

       699
       699
       -
                 port = mkOption {

     

       700
       700
       -
                   type = types.nullOr types.port;

     

       704
       704
       +
                 port = lib.mkOption {

     

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

     

       701
       706
        
                   default = null;

     

       702
       707
        
                   description = ''

     

       703
       708
        
                     Required for some non-Amazon implementations.

     

       704
       709
        
                   '';

     

       705
       710
        
                 };

     

       706
       706
       -
                 useSsl = mkOption {

     

       707
       707
       -
                   type = types.bool;

     

       711
       711
       +
                 useSsl = lib.mkOption {

     

       712
       712
       +
                   type = lib.types.bool;

     

       708
       713
        
                   default = true;

     

       709
       714
        
                   description = ''

     

       710
       715
        
                     Use SSL for objectstore access.

     

       711
       716
        
                   '';

     

       712
       717
        
                 };

     

       713
       713
       -
                 region = mkOption {

     

       714
       714
       -
                   type = types.nullOr types.str;

     

       718
       718
       +
                 region = lib.mkOption {

     

       719
       719
       +
                   type = lib.types.nullOr lib.types.str;

     

       715
       720
        
                   default = null;

     

       716
       721
        
                   example = "REGION";

     

       717
       722
        
                   description = ''

     

       718
       723
        
                     Required for some non-Amazon implementations.

     

       719
       724
        
                   '';

     

       720
       725
        
                 };

     

       721
       721
       -
                 usePathStyle = mkOption {

     

       722
       722
       -
                   type = types.bool;

     

       726
       726
       +
                 usePathStyle = lib.mkOption {

     

       727
       727
       +
                   type = lib.types.bool;

     

       723
       728
        
                   default = false;

     

       724
       729
        
                   description = ''

     

       725
       730
        
                     Required for some non-Amazon S3 implementations.

     
···

       730
       735
        
                     `http://hostname.domain/bucket` instead.

     

       731
       736
        
                   '';

     

       732
       737
        
                 };

     

       733
       733
       -
                 sseCKeyFile = mkOption {

     

       734
       734
       -
                   type = types.nullOr types.path;

     

       738
       738
       +
                 sseCKeyFile = lib.mkOption {

     

       739
       739
       +
                   type = lib.types.nullOr lib.types.path;

     

       735
       740
        
                   default = null;

     

       736
       741
        
                   example = "/var/nextcloud-objectstore-s3-sse-c-key";

     

       737
       742
        
                   description = ''

     
···

       754
       759
        
           };

     

       755
       760
        
       

     

       756
       761
        
           enableImagemagick =

     

       757
       757
       -
             mkEnableOption ''

     

       762
       762
       +
             lib.mkEnableOption ''

     

       758
       763
        
               the ImageMagick module for PHP.

     

       759
       764
        
               This is used by the theming app and for generating previews of certain images (e.g. SVG and HEIF).

     

       760
       765
        
               You may want to disable it for increased security. In that case, previews will still be available

     
···

       768
       773
        
           configureRedis = lib.mkOption {

     

       769
       774
        
             type = lib.types.bool;

     

       770
       775
        
             default = config.services.nextcloud.notify_push.enable;

     

       771
       771
       -
             defaultText = literalExpression "config.services.nextcloud.notify_push.enable";

     

       776
       776
       +
             defaultText = lib.literalExpression "config.services.nextcloud.notify_push.enable";

     

       772
       777
        
             description = ''

     

       773
       778
        
               Whether to configure Nextcloud to use the recommended Redis settings for small instances.

     

       774
       779
        
       

     
···

       779
       784
        
           };

     

       780
       785
        
       

     

       781
       786
        
           caching = {

     

       782
       782
       -
             apcu = mkOption {

     

       783
       783
       -
               type = types.bool;

     

       787
       787
       +
             apcu = lib.mkOption {

     

       788
       788
       +
               type = lib.types.bool;

     

       784
       789
        
               default = true;

     

       785
       790
        
               description = ''

     

       786
       791
        
                 Whether to load the APCu module into PHP.

     

       787
       792
        
               '';

     

       788
       793
        
             };

     

       789
       789
       -
             redis = mkOption {

     

       790
       790
       -
               type = types.bool;

     

       794
       794
       +
             redis = lib.mkOption {

     

       795
       795
       +
               type = lib.types.bool;

     

       791
       796
        
               default = false;

     

       792
       797
        
               description = ''

     

       793
       798
        
                 Whether to load the Redis module into PHP.

     
···

       795
       800
        
                 See <https://docs.nextcloud.com/server/latest/admin_manual/configuration_server/caching_configuration.html>

     

       796
       801
        
               '';

     

       797
       802
        
             };

     

       798
       798
       -
             memcached = mkOption {

     

       799
       799
       -
               type = types.bool;

     

       803
       803
       +
             memcached = lib.mkOption {

     

       804
       804
       +
               type = lib.types.bool;

     

       800
       805
        
               default = false;

     

       801
       806
        
               description = ''

     

       802
       807
        
                 Whether to load the Memcached module into PHP.

     
···

       806
       811
        
             };

     

       807
       812
        
           };

     

       808
       813
        
           autoUpdateApps = {

     

       809
       809
       -
             enable = mkOption {

     

       810
       810
       -
               type = types.bool;

     

       814
       814
       +
             enable = lib.mkOption {

     

       815
       815
       +
               type = lib.types.bool;

     

       811
       816
        
               default = false;

     

       812
       817
        
               description = ''

     

       813
       818
        
                 Run a regular auto-update of all apps installed from the Nextcloud app store.

     

       814
       819
        
               '';

     

       815
       820
        
             };

     

       816
       816
       -
             startAt = mkOption {

     

       817
       817
       -
               type = with types; either str (listOf str);

     

       821
       821
       +
             startAt = lib.mkOption {

     

       822
       822
       +
               type = lib.types.either lib.types.str (lib.types.listOf lib.types.str);

     

       818
       823
        
               default = "05:00:00";

     

       819
       824
        
               example = "Sun 14:00:00";

     

       820
       825
        
               description = ''

     
···

       822
       827
        
               '';

     

       823
       828
        
             };

     

       824
       829
        
           };

     

       825
       825
       -
           occ = mkOption {

     

       826
       826
       -
             type = types.package;

     

       830
       830
       +
           occ = lib.mkOption {

     

       831
       831
       +
             type = lib.types.package;

     

       827
       832
        
             default = occ;

     

       828
       828
       -
             defaultText = literalMD "generated script";

     

       833
       833
       +
             defaultText = lib.literalMD "generated script";

     

       829
       834
        
             description = ''

     

       830
       835
        
               The nextcloud-occ program preconfigured to target this Nextcloud instance.

     

       831
       836
        
             '';

     

       832
       837
        
           };

     

       833
       838
        
       

     

       834
       834
       -
           settings = mkOption {

     

       835
       835
       -
             type = types.submodule {

     

       839
       839
       +
           settings = lib.mkOption {

     

       840
       840
       +
             type = lib.types.submodule {

     

       836
       841
        
               freeformType = jsonFormat.type;

     

       837
       842
        
               options = {

     

       838
       843
        
       

     

       839
       839
       -
                 loglevel = mkOption {

     

       840
       840
       -
                   type = types.ints.between 0 4;

     

       844
       844
       +
                 loglevel = lib.mkOption {

     

       845
       845
       +
                   type = lib.types.ints.between 0 4;

     

       841
       846
        
                   default = 2;

     

       842
       847
        
                   description = ''

     

       843
       848
        
                     Log level value between 0 (DEBUG) and 4 (FATAL).

     
···

       853
       858
        
                     - 4 (fatal): Log only fatal errors that cause the server to stop.

     

       854
       859
        
                   '';

     

       855
       860
        
                 };

     

       856
       856
       -
                 log_type = mkOption {

     

       857
       857
       -
                   type = types.enum [

     

       861
       861
       +
                 log_type = lib.mkOption {

     

       862
       862
       +
                   type = lib.types.enum [

     

       858
       863
        
                     "errorlog"

     

       859
       864
        
                     "file"

     

       860
       865
        
                     "syslog"

     
···

       867
       872
        
                     See the [nextcloud documentation](https://docs.nextcloud.com/server/latest/admin_manual/configuration_server/logging_configuration.html) for details.

     

       868
       873
        
                   '';

     

       869
       874
        
                 };

     

       870
       870
       -
                 skeletondirectory = mkOption {

     

       875
       875
       +
                 skeletondirectory = lib.mkOption {

     

       871
       876
        
                   default = "";

     

       872
       872
       -
                   type = types.str;

     

       877
       877
       +
                   type = lib.types.str;

     

       873
       878
        
                   description = ''

     

       874
       879
        
                     The directory where the skeleton files are located. These files will be

     

       875
       880
        
                     copied to the data directory of new users. Leave empty to not copy any

     

       876
       881
        
                     skeleton files.

     

       877
       882
        
                   '';

     

       878
       883
        
                 };

     

       879
       879
       -
                 trusted_domains = mkOption {

     

       880
       880
       -
                   type = types.listOf types.str;

     

       884
       884
       +
                 trusted_domains = lib.mkOption {

     

       885
       885
       +
                   type = lib.types.listOf lib.types.str;

     

       881
       886
        
                   default = [ ];

     

       882
       887
        
                   description = ''

     

       883
       888
        
                     Trusted domains, from which the nextcloud installation will be

     
···

       885
       890
        
                     `services.nextcloud.hostname` here.

     

       886
       891
        
                   '';

     

       887
       892
        
                 };

     

       888
       888
       -
                 trusted_proxies = mkOption {

     

       889
       889
       -
                   type = types.listOf types.str;

     

       893
       893
       +
                 trusted_proxies = lib.mkOption {

     

       894
       894
       +
                   type = lib.types.listOf lib.types.str;

     

       890
       895
        
                   default = [ ];

     

       891
       896
        
                   description = ''

     

       892
       897
        
                     Trusted proxies, to provide if the nextcloud installation is being

     

       893
       898
        
                     proxied to secure against e.g. spoofing.

     

       894
       899
        
                   '';

     

       895
       900
        
                 };

     

       896
       896
       -
                 overwriteprotocol = mkOption {

     

       897
       897
       -
                   type = types.enum [

     

       901
       901
       +
                 overwriteprotocol = lib.mkOption {

     

       902
       902
       +
                   type = lib.types.enum [

     

       898
       903
        
                     ""

     

       899
       904
        
                     "http"

     

       900
       905
        
                     "https"

     
···

       908
       913
        
                     Nextcloud may be served via HTTPS.

     

       909
       914
        
                   '';

     

       910
       915
        
                 };

     

       911
       911
       -
                 default_phone_region = mkOption {

     

       916
       916
       +
                 default_phone_region = lib.mkOption {

     

       912
       917
        
                   default = "";

     

       913
       913
       -
                   type = types.str;

     

       918
       918
       +
                   type = lib.types.str;

     

       914
       919
        
                   example = "DE";

     

       915
       920
        
                   description = ''

     

       916
       921
        
                     An [ISO 3166-1](https://www.iso.org/iso-3166-country-codes.html)

     
···

       921
       926
        
                     the `+49` prefix can be omitted for phone numbers.

     

       922
       927
        
                   '';

     

       923
       928
        
                 };

     

       924
       924
       -
                 "profile.enabled" = mkEnableOption "global profiles" // {

     

       929
       929
       +
                 "profile.enabled" = lib.mkEnableOption "global profiles" // {

     

       925
       930
        
                   description = ''

     

       926
       931
        
                     Makes user-profiles globally available under `nextcloud.tld/u/user.name`.

     

       927
       932
        
                     Even though it's enabled by default in Nextcloud, it must be explicitly enabled

     
···

       946
       951
        
             description = ''

     

       947
       952
        
               Extra options which should be appended to Nextcloud's config.php file.

     

       948
       953
        
             '';

     

       949
       949
       -
             example = literalExpression ''

     

       954
       954
       +
             example = lib.literalExpression ''

     

       950
       955
        
               {

     

       951
       956
        
                 redis = {

     

       952
       957
        
                   host = "/run/redis/redis.sock";

     
···

       959
       964
        
             '';

     

       960
       965
        
           };

     

       961
       966
        
       

     

       962
       962
       -
           secretFile = mkOption {

     

       963
       963
       -
             type = types.nullOr types.str;

     

       967
       967
       +
           secretFile = lib.mkOption {

     

       968
       968
       +
             type = lib.types.nullOr lib.types.str;

     

       964
       969
        
             default = null;

     

       965
       970
        
             description = ''

     

       966
       971
        
               Secret options which will be appended to Nextcloud's config.php file (written as JSON, in the same

     
···

       970
       975
        
           };

     

       971
       976
        
       

     

       972
       977
        
           nginx = {

     

       973
       973
       -
             recommendedHttpHeaders = mkOption {

     

       974
       974
       -
               type = types.bool;

     

       978
       978
       +
             recommendedHttpHeaders = lib.mkOption {

     

       979
       979
       +
               type = lib.types.bool;

     

       975
       980
        
               default = true;

     

       976
       981
        
               description = "Enable additional recommended HTTP response headers";

     

       977
       982
        
             };

     

       978
       978
       -
             hstsMaxAge = mkOption {

     

       979
       979
       -
               type = types.ints.positive;

     

       983
       983
       +
             hstsMaxAge = lib.mkOption {

     

       984
       984
       +
               type = lib.types.ints.positive;

     

       980
       985
        
               default = 15552000;

     

       981
       986
        
               description = ''

     

       982
       987
        
                 Value for the `max-age` directive of the HTTP

     
···

       986
       991
        
                 directive and header.

     

       987
       992
        
               '';

     

       988
       993
        
             };

     

       989
       989
       -
             enableFastcgiRequestBuffering = mkOption {

     

       990
       990
       -
               type = types.bool;

     

       994
       994
       +
             enableFastcgiRequestBuffering = lib.mkOption {

     

       995
       995
       +
               type = lib.types.bool;

     

       991
       996
        
               default = false;

     

       992
       997
        
               description = ''

     

       993
       998
        
                 Whether to buffer requests against fastcgi requests. This is a workaround

     
···

       1005
       1010
        
             };

     

       1006
       1011
        
           };

     

       1007
       1012
        
       

     

       1008
       1008
       -
           cli.memoryLimit = mkOption {

     

       1009
       1009
       -
             type = types.nullOr types.str;

     

       1013
       1013
       +
           cli.memoryLimit = lib.mkOption {

     

       1014
       1014
       +
             type = lib.types.nullOr lib.types.str;

     

       1010
       1015
        
             default = null;

     

       1011
       1016
        
             example = "1G";

     

       1012
       1017
        
             description = ''

     
···

       1035
       1040
        
                 '';

     

       1036
       1041
        
       

     

       1037
       1042
        
               in

     

       1038
       1038
       -
               (optional (cfg.poolConfig != null) ''

     

       1043
       1043
       +
               (lib.optional (cfg.poolConfig != null) ''

     

       1039
       1044
        
                 Using config.services.nextcloud.poolConfig is deprecated and will become unsupported in a future release.

     

       1040
       1045
        
                 Please migrate your configuration to config.services.nextcloud.poolSettings.

     

       1041
       1046
        
               '')

     

       1042
       1042
       -
               ++ (optional (cfg.config.dbtableprefix != null) ''

     

       1047
       1047
       +
               ++ (lib.optional (cfg.config.dbtableprefix != null) ''

     

       1043
       1048
        
                 Using `services.nextcloud.config.dbtableprefix` is deprecated. Fresh installations with this

     

       1044
       1049
        
                 option set are not allowed anymore since v20.

     

       1045
       1050
        
       

     

       1046
       1051
        
                 If you have an existing installation with a custom table prefix, make sure it is

     

       1047
       1052
        
                 set correctly in `config.php` and remove the option from your NixOS config.

     

       1048
       1053
        
               '')

     

       1049
       1049
       -
               ++ (optional (versionOlder overridePackage.version "26") (upgradeWarning 25 "23.05"))

     

       1050
       1050
       -
               ++ (optional (versionOlder overridePackage.version "27") (upgradeWarning 26 "23.11"))

     

       1051
       1051
       -
               ++ (optional (versionOlder overridePackage.version "28") (upgradeWarning 27 "24.05"))

     

       1052
       1052
       -
               ++ (optional (versionOlder overridePackage.version "29") (upgradeWarning 28 "24.11"))

     

       1053
       1053
       -
               ++ (optional (versionOlder overridePackage.version "30") (upgradeWarning 29 "24.11"))

     

       1054
       1054
       -
               ++ (optional (versionOlder overridePackage.version "31") (upgradeWarning 30 "25.05"));

     

       1054
       1054
       +
               ++ (lib.optional (lib.versionOlder overridePackage.version "26") (upgradeWarning 25 "23.05"))

     

       1055
       1055
       +
               ++ (lib.optional (lib.versionOlder overridePackage.version "27") (upgradeWarning 26 "23.11"))

     

       1056
       1056
       +
               ++ (lib.optional (lib.versionOlder overridePackage.version "28") (upgradeWarning 27 "24.05"))

     

       1057
       1057
       +
               ++ (lib.optional (lib.versionOlder overridePackage.version "29") (upgradeWarning 28 "24.11"))

     

       1058
       1058
       +
               ++ (lib.optional (lib.versionOlder overridePackage.version "30") (upgradeWarning 29 "24.11"))

     

       1059
       1059
       +
               ++ (lib.optional (lib.versionOlder overridePackage.version "31") (upgradeWarning 30 "25.05"));

     

       1055
       1060
        
       

     

       1056
       1061
        
             services.nextcloud.package =

     

       1057
       1062
        
               with pkgs;

     

       1058
       1058
       -
               mkDefault (

     

       1063
       1063
       +
               lib.mkDefault (

     

       1059
       1064
        
                 if pkgs ? nextcloud then

     

       1060
       1065
        
                   throw ''

     

       1061
       1066
        
                     The `pkgs.nextcloud`-attribute has been removed. If it's supposed to be the default

     
···

       1072
       1077
        
                   nextcloud31

     

       1073
       1078
        
               );

     

       1074
       1079
        
       

     

       1075
       1075
       -
             services.nextcloud.phpPackage = pkgs.php83;

     

       1076
       1076
       -
       

     

       1077
       1080
        
             services.nextcloud.phpOptions = mkMerge [

     

       1078
       1078
       -
               (mapAttrs (const mkOptionDefault) defaultPHPSettings)

     

       1081
       1081
       +
               (lib.mapAttrs (lib.const lib.mkOptionDefault) defaultPHPSettings)

     

       1079
       1082
        
               {

     

       1080
       1083
        
                 upload_max_filesize = cfg.maxUploadSize;

     

       1081
       1084
        
                 post_max_size = cfg.maxUploadSize;

     
···

       1164
       1167
        
                         arg = "ADMINPASS";

     

       1165
       1168
        
                         value = ''"$(<"$CREDENTIALS_DIRECTORY/adminpass")"'';

     

       1166
       1169
        
                       };

     

       1167
       1167
       -
                       installFlags = concatStringsSep " \\\n    " (

     

       1168
       1168
       -
                         mapAttrsToList (k: v: "${k} ${toString v}") {

     

       1170
       1170
       +
                       installFlags = lib.concatStringsSep " \\\n    " (

     

       1171
       1171
       +
                         lib.mapAttrsToList (k: v: "${k} ${toString v}") {

     

       1169
       1172
        
                           "--database" = ''"${c.dbtype}"'';

     

       1170
       1173
        
                           # The following attributes are optional depending on the type of

     

       1171
       1174
        
                           # database.  Those that evaluate to null on the left hand side

     
···

       1186
       1189
        
                       ${lib.getExe occ} maintenance:install \

     

       1187
       1190
        
                           ${installFlags}

     

       1188
       1191
        
                     '';

     

       1189
       1189
       -
                   occSetTrustedDomainsCmd = concatStringsSep "\n" (

     

       1190
       1190
       -
                     imap0 (i: v: ''

     

       1192
       1192
       +
                   occSetTrustedDomainsCmd = lib.concatStringsSep "\n" (

     

       1193
       1193
       +
                     lib.imap0 (i: v: ''

     

       1191
       1194
        
                       ${lib.getExe occ} config:system:set trusted_domains \

     

       1192
       1195
        
                         ${toString i} --value="${toString v}"

     

       1193
       1196
        
                     '') (lib.unique ([ cfg.hostName ] ++ cfg.settings.trusted_domains))

     
···

       1198
       1201
        
                   wantedBy = [ "multi-user.target" ];

     

       1199
       1202
        
                   wants = [ "nextcloud-update-db.service" ];

     

       1200
       1203
        
                   before = [ "phpfpm-nextcloud.service" ];

     

       1201
       1201
       -
                   after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       1202
       1202
       -
                   requires = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       1204
       1204
       +
                   after = lib.optional mysqlLocal "mysql.service" ++ lib.optional pgsqlLocal "postgresql.target";

     

       1205
       1205
       +
                   requires = lib.optional mysqlLocal "mysql.service" ++ lib.optional pgsqlLocal "postgresql.target";

     

       1203
       1206
        
                   path = [ occ ];

     

       1204
       1207
        
                   restartTriggers = [ overrideConfig ];

     

       1205
       1208
        
                   script = ''

     

       1206
       1206
       -
                     ${optionalString (c.dbpassFile != null) ''

     

       1209
       1209
       +
                     ${lib.optionalString (c.dbpassFile != null) ''

     

       1207
       1210
        
                       if [ -z "$(<"$CREDENTIALS_DIRECTORY/dbpass")" ]; then

     

       1208
       1211
        
                         echo "dbpassFile ${c.dbpassFile} is empty!"

     

       1209
       1212
        
                         exit 1

     
···

       1223
       1226
        
                       exit 1

     

       1224
       1227
        
                     fi

     

       1225
       1228
        
       

     

       1226
       1226
       -
                     ${concatMapStrings

     

       1229
       1229
       +
                     ${lib.concatMapStrings

     

       1227
       1230
        
                       (name: ''

     

       1228
       1231
        
                         if [ -d "${cfg.home}"/${name} ]; then

     

       1229
       1232
        
                           echo "Cleaning up ${name}; these are now bundled in the webroot store-path!"

     
···

       1245
       1248
        
       

     

       1246
       1249
        
                     ${lib.getExe occ} config:system:delete trusted_domains

     

       1247
       1250
        
       

     

       1248
       1248
       -
                     ${optionalString (cfg.extraAppsEnable && cfg.extraApps != { }) ''

     

       1251
       1251
       +
                     ${lib.optionalString (cfg.extraAppsEnable && cfg.extraApps != { }) ''

     

       1249
       1252
        
                       # Try to enable apps

     

       1250
       1250
       -
                       ${lib.getExe occ} app:enable ${concatStringsSep " " (attrNames cfg.extraApps)}

     

       1253
       1253
       +
                       ${lib.getExe occ} app:enable ${lib.concatStringsSep " " (lib.attrNames cfg.extraApps)}

     

       1251
       1254
        
                     ''}

     

       1252
       1255
        
       

     

       1253
       1256
        
                     ${occSetTrustedDomainsCmd}

     
···

       1357
       1360
        
                   PATH = "/run/wrappers/bin:/nix/var/nix/profiles/default/bin:/run/current-system/sw/bin:/usr/bin:/bin";

     

       1358
       1361
        
                 };

     

       1359
       1362
        
                 settings =

     

       1360
       1360
       -
                   mapAttrs (name: mkDefault) {

     

       1363
       1363
       +
                   lib.mapAttrs (name: lib.mkDefault) {

     

       1361
       1364
        
                     "listen.owner" = config.services.nginx.user;

     

       1362
       1365
        
                     "listen.group" = config.services.nginx.group;

     

       1363
       1366
        
                   }

     
···

       1411
       1414
        
             services.nextcloud = {

     

       1412
       1415
        
               caching.redis = lib.mkIf cfg.configureRedis true;

     

       1413
       1416
        
               settings = mkMerge [

     

       1414
       1414
       -
                 ({

     

       1417
       1417
       +
                 {

     

       1415
       1418
        
                   datadirectory = lib.mkDefault "${datadir}/data";

     

       1416
       1419
        
                   trusted_domains = [ cfg.hostName ];

     

       1417
       1420
        
                   "upgrade.disable-web" = true;

     

       1418
       1421
        
                   # NixOS already provides its own integrity check and the nix store is read-only, therefore Nextcloud does not need to do its own integrity checks.

     

       1419
       1422
        
                   "integrity.check.disabled" = true;

     

       1420
       1420
       -
                 })

     

       1423
       1423
       +
                 }

     

       1421
       1424
        
                 (lib.mkIf cfg.configureRedis {

     

       1422
       1425
        
                   "memcache.distributed" = ''\OC\Memcache\Redis'';

     

       1423
       1426
        
                   "memcache.locking" = ''\OC\Memcache\Redis'';

     
···

       1429
       1432
        
               ];

     

       1430
       1433
        
             };

     

       1431
       1434
        
       

     

       1432
       1432
       -
             services.nginx.enable = mkDefault true;

     

       1435
       1435
       +
             services.nginx.enable = lib.mkDefault true;

     

       1433
       1436
        
       

     

       1434
       1437
        
             services.nginx.virtualHosts.${cfg.hostName} = {

     

       1435
       1438
        
               root = webroot;

     
···

       1528
       1531
        
               };

     

       1529
       1532
        
               extraConfig = ''

     

       1530
       1533
        
                 index index.php index.html /index.php$request_uri;

     

       1531
       1531
       -
                 ${optionalString (cfg.nginx.recommendedHttpHeaders) ''

     

       1534
       1534
       +
                 ${lib.optionalString (cfg.nginx.recommendedHttpHeaders) ''

     

       1532
       1535
        
                   add_header X-Content-Type-Options nosniff;

     

       1533
       1536
        
                   add_header X-XSS-Protection "1; mode=block";

     

       1534
       1537
        
                   add_header X-Robots-Tag "noindex, nofollow";

     
···

       1536
       1539
        
                   add_header X-Frame-Options sameorigin;

     

       1537
       1540
        
                   add_header Referrer-Policy no-referrer;

     

       1538
       1541
        
                 ''}

     

       1539
       1539
       -
                 ${optionalString (cfg.https) ''

     

       1542
       1542
       +
                 ${lib.optionalString (cfg.https) ''

     

       1540
       1543
        
                   add_header Strict-Transport-Security "max-age=${toString cfg.nginx.hstsMaxAge}; includeSubDomains" always;

     

       1541
       1544
        
                 ''}

     

       1542
       1545
        
                 client_max_body_size ${cfg.maxUploadSize};

     
···

       1549
       1552
        
                 gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;

     

       1550
       1553
        
                 gzip_types application/atom+xml text/javascript application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/wasm application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;

     

       1551
       1554
        
       

     

       1552
       1552
       -
                 ${optionalString cfg.webfinger ''

     

       1555
       1555
       +
                 ${lib.optionalString cfg.webfinger ''

     

       1553
       1556
        
                   rewrite ^/.well-known/host-meta /public.php?service=host-meta last;

     

       1554
       1557
        
                   rewrite ^/.well-known/host-meta.json /public.php?service=host-meta-json last;

     

       1555
       1558
        
                 ''}

     
···

       1559
       1562
        
         ]);

     

       1560
       1563
        
       

     

       1561
       1564
        
         meta.doc = ./nextcloud.md;

     

       1562
       1562
       -
         meta.maintainers = teams.nextcloud.members;

     

       1565
       1565
       +
         meta.maintainers = lib.teams.nextcloud.members;

     

       1563
       1566
        
       }

+28

nixos/modules/system/service/README.md

···

       1
       1
       +
       

     

       2
       2
       +
       # Modular Services

     

       3
       3
       +
       

     

       4
       4
       +
       This directory defines a modular service infrastructure for NixOS.

     

       5
       5
       +
       See the [Modular Services chapter] in the manual [[source]](../../doc/manual/development/modular-services.md).

     

       6
       6
       +
       

     

       7
       7
       +
       [Modular Services chapter]: https://nixos.org/manual/nixos/unstable/#modular-services

     

       8
       8
       +
       

     

       9
       9
       +
       # Design decision log

     

       10
       10
       +
       

     

       11
       11
       +
       - `system.services.<name>`. Alternatives considered

     

       12
       12
       +
         - `systemServices`: similar to does not allow importing a composition of services into `system`. Not sure if that's a good idea in the first place, but I've kept the possibility open.

     

       13
       13
       +
         - `services.abstract`: used in https://github.com/NixOS/nixpkgs/pull/267111, but too weird. Service modules should fit naturally into the configuration system.

     

       14
       14
       +
           Also "abstract" is wrong, because it has submodules - in other words, evalModules results, concrete services - not abstract at all.

     

       15
       15
       +
         - `services.modular`: only slightly better than `services.abstract`, but still weird

     

       16
       16
       +
       

     

       17
       17
       +
       - No `daemon.*` options. https://github.com/NixOS/nixpkgs/pull/267111/files#r1723206521

     

       18
       18
       +
       

     

       19
       19
       +
       - For now, do not add an `enable` option, because it's ambiguous. Does it disable at the Nix level (not generate anything) or at the systemd level (generate a service that is disabled)?

     

       20
       20
       +
       

     

       21
       21
       +
       - Move all process options into a `process` option tree. Putting this at the root is messy, because we also have sub-services at that level. Those are rather distinct. Grouping them "by kind" should raise fewer questions.

     

       22
       22
       +
       

     

       23
       23
       +
       - `modules/system/service/systemd/system.nix` has `system` twice. Not great, but

     

       24
       24
       +
         - they have different meanings

     

       25
       25
       +
           1. These are system-provided modules, provided by the configuration manager

     

       26
       26
       +
           2. `systemd/system` configures SystemD _system units_.

     

       27
       27
       +
         - This reserves `modules/service` for actual service modules, at least until those are lifted out of NixOS, potentially

     

       28
       28
       +

+33

nixos/modules/system/service/portable/lib.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) concatLists mapAttrsToList showOption;

     

       4
       4
       +
       in

     

       5
       5
       +
       rec {

     

       6
       6
       +
         flattenMapServicesConfigToList =

     

       7
       7
       +
           f: loc: config:

     

       8
       8
       +
           f loc config

     

       9
       9
       +
           ++ concatLists (

     

       10
       10
       +
             mapAttrsToList (

     

       11
       11
       +
               k: v:

     

       12
       12
       +
               flattenMapServicesConfigToList f (

     

       13
       13
       +
                 loc

     

       14
       14
       +
                 ++ [

     

       15
       15
       +
                   "services"

     

       16
       16
       +
                   k

     

       17
       17
       +
                 ]

     

       18
       18
       +
               ) v

     

       19
       19
       +
             ) config.services

     

       20
       20
       +
           );

     

       21
       21
       +
       

     

       22
       22
       +
         getWarnings = flattenMapServicesConfigToList (

     

       23
       23
       +
           loc: config: map (msg: "in ${showOption loc}: ${msg}") config.warnings

     

       24
       24
       +
         );

     

       25
       25
       +
       

     

       26
       26
       +
         getAssertions = flattenMapServicesConfigToList (

     

       27
       27
       +
           loc: config:

     

       28
       28
       +
           map (ass: {

     

       29
       29
       +
             message = "in ${showOption loc}: ${ass.message}";

     

       30
       30
       +
             assertion = ass.assertion;

     

       31
       31
       +
           }) config.assertions

     

       32
       32
       +
         );

     

       33
       33
       +
       }

+48

nixos/modules/system/service/portable/service.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         config,

     

       4
       4
       +
         options,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         inherit (lib) mkOption types;

     

       9
       9
       +
         pathOrStr = types.coercedTo types.path (x: "${x}") types.str;

     

       10
       10
       +
       in

     

       11
       11
       +
       {

     

       12
       12
       +
         # https://nixos.org/manual/nixos/unstable/#modular-services

     

       13
       13
       +
         _class = "service";

     

       14
       14
       +
         imports = [

     

       15
       15
       +
           ../../../misc/assertions.nix

     

       16
       16
       +
         ];

     

       17
       17
       +
         options = {

     

       18
       18
       +
           services = mkOption {

     

       19
       19
       +
             type = types.attrsOf (

     

       20
       20
       +
               types.submoduleWith {

     

       21
       21
       +
                 modules = [

     

       22
       22
       +
                   ./service.nix

     

       23
       23
       +
                 ];

     

       24
       24
       +
               }

     

       25
       25
       +
             );

     

       26
       26
       +
             description = ''

     

       27
       27
       +
               A collection of [modular services](https://nixos.org/manual/nixos/unstable/#modular-services) that are configured in one go.

     

       28
       28
       +
       

     

       29
       29
       +
               You could consider the sub-service relationship to be an ownership relation.

     

       30
       30
       +
               It **does not** automatically create any other relationship between services (e.g. systemd slices), unless perhaps such a behavior is explicitly defined and enabled in another option.

     

       31
       31
       +
             '';

     

       32
       32
       +
             default = { };

     

       33
       33
       +
             visible = "shallow";

     

       34
       34
       +
           };

     

       35
       35
       +
           process = {

     

       36
       36
       +
             argv = lib.mkOption {

     

       37
       37
       +
               type = types.listOf pathOrStr;

     

       38
       38
       +
               example = lib.literalExpression ''[ (lib.getExe config.package) "--nobackground" ]'';

     

       39
       39
       +
               description = ''

     

       40
       40
       +
                 Command filename and arguments for starting this service.

     

       41
       41
       +
                 This is a raw command-line that should not contain any shell escaping.

     

       42
       42
       +
                 If expansion of environmental variables is required then use

     

       43
       43
       +
                 a shell script or `importas` from `pkgs.execline`.

     

       44
       44
       +
               '';

     

       45
       45
       +
             };

     

       46
       46
       +
           };

     

       47
       47
       +
         };

     

       48
       48
       +
       }

+183

nixos/modules/system/service/portable/test.nix

···

       1
       1
       +
       # Run:

     

       2
       2
       +
       #   nix-instantiate --eval nixos/modules/system/service/portable/test.nix

     

       3
       3
       +
       let

     

       4
       4
       +
         lib = import ../../../../../lib;

     

       5
       5
       +
       

     

       6
       6
       +
         inherit (lib) mkOption types;

     

       7
       7
       +
       

     

       8
       8
       +
         portable-lib = import ./lib.nix { inherit lib; };

     

       9
       9
       +
       

     

       10
       10
       +
         dummyPkg =

     

       11
       11
       +
           name:

     

       12
       12
       +
           derivation {

     

       13
       13
       +
             system = "dummy";

     

       14
       14
       +
             name = name;

     

       15
       15
       +
             builder = "/bin/false";

     

       16
       16
       +
           };

     

       17
       17
       +
       

     

       18
       18
       +
         exampleConfig = {

     

       19
       19
       +
           _file = "${__curPos.file}:${toString __curPos.line}";

     

       20
       20
       +
           services = {

     

       21
       21
       +
             service1 = {

     

       22
       22
       +
               process = {

     

       23
       23
       +
                 argv = [

     

       24
       24
       +
                   "/usr/bin/echo" # *giggles*

     

       25
       25
       +
                   "hello"

     

       26
       26
       +
                 ];

     

       27
       27
       +
               };

     

       28
       28
       +
               assertions = [

     

       29
       29
       +
                 {

     

       30
       30
       +
                   assertion = false;

     

       31
       31
       +
                   message = "you can't enable this for that reason";

     

       32
       32
       +
                 }

     

       33
       33
       +
               ];

     

       34
       34
       +
               warnings = [

     

       35
       35
       +
                 "The `foo' service is deprecated and will go away soon!"

     

       36
       36
       +
               ];

     

       37
       37
       +
             };

     

       38
       38
       +
             service2 = {

     

       39
       39
       +
               process = {

     

       40
       40
       +
                 # No meta.mainProgram, because it's supposedly an executable script _file_,

     

       41
       41
       +
                 # not a directory with a bin directory containing the main program.

     

       42
       42
       +
                 argv = [

     

       43
       43
       +
                   (dummyPkg "cowsay.sh")

     

       44
       44
       +
                   "world"

     

       45
       45
       +
                 ];

     

       46
       46
       +
               };

     

       47
       47
       +
             };

     

       48
       48
       +
             service3 = {

     

       49
       49
       +
               process = {

     

       50
       50
       +
                 argv = [ "/bin/false" ];

     

       51
       51
       +
               };

     

       52
       52
       +
               services.exclacow = {

     

       53
       53
       +
                 process = {

     

       54
       54
       +
                   argv = [

     

       55
       55
       +
                     (lib.getExe (

     

       56
       56
       +
                       dummyPkg "cowsay-ng"

     

       57
       57
       +
                       // {

     

       58
       58
       +
                         meta.mainProgram = "cowsay";

     

       59
       59
       +
                       }

     

       60
       60
       +
                     ))

     

       61
       61
       +
                     "!"

     

       62
       62
       +
                   ];

     

       63
       63
       +
                 };

     

       64
       64
       +
                 assertions = [

     

       65
       65
       +
                   {

     

       66
       66
       +
                     assertion = false;

     

       67
       67
       +
                     message = "you can't enable this for such reason";

     

       68
       68
       +
                   }

     

       69
       69
       +
                 ];

     

       70
       70
       +
                 warnings = [

     

       71
       71
       +
                   "The `bar' service is deprecated and will go away soon!"

     

       72
       72
       +
                 ];

     

       73
       73
       +
               };

     

       74
       74
       +
             };

     

       75
       75
       +
           };

     

       76
       76
       +
         };

     

       77
       77
       +
       

     

       78
       78
       +
         exampleEval = lib.evalModules {

     

       79
       79
       +
           modules = [

     

       80
       80
       +
             {

     

       81
       81
       +
               options.services = mkOption {

     

       82
       82
       +
                 type = types.attrsOf (

     

       83
       83
       +
                   types.submoduleWith {

     

       84
       84
       +
                     class = "service";

     

       85
       85
       +
                     modules = [

     

       86
       86
       +
                       ./service.nix

     

       87
       87
       +
                     ];

     

       88
       88
       +
                   }

     

       89
       89
       +
                 );

     

       90
       90
       +
               };

     

       91
       91
       +
             }

     

       92
       92
       +
             exampleConfig

     

       93
       93
       +
           ];

     

       94
       94
       +
         };

     

       95
       95
       +
       

     

       96
       96
       +
         test =

     

       97
       97
       +
           assert

     

       98
       98
       +
             exampleEval.config == {

     

       99
       99
       +
               services = {

     

       100
       100
       +
                 service1 = {

     

       101
       101
       +
                   process = {

     

       102
       102
       +
                     argv = [

     

       103
       103
       +
                       "/usr/bin/echo"

     

       104
       104
       +
                       "hello"

     

       105
       105
       +
                     ];

     

       106
       106
       +
                   };

     

       107
       107
       +
                   services = { };

     

       108
       108
       +
                   assertions = [

     

       109
       109
       +
                     {

     

       110
       110
       +
                       assertion = false;

     

       111
       111
       +
                       message = "you can't enable this for that reason";

     

       112
       112
       +
                     }

     

       113
       113
       +
                   ];

     

       114
       114
       +
                   warnings = [

     

       115
       115
       +
                     "The `foo' service is deprecated and will go away soon!"

     

       116
       116
       +
                   ];

     

       117
       117
       +
                 };

     

       118
       118
       +
                 service2 = {

     

       119
       119
       +
                   process = {

     

       120
       120
       +
                     argv = [

     

       121
       121
       +
                       "${dummyPkg "cowsay.sh"}"

     

       122
       122
       +
                       "world"

     

       123
       123
       +
                     ];

     

       124
       124
       +
                   };

     

       125
       125
       +
                   services = { };

     

       126
       126
       +
                   assertions = [ ];

     

       127
       127
       +
                   warnings = [ ];

     

       128
       128
       +
                 };

     

       129
       129
       +
                 service3 = {

     

       130
       130
       +
                   process = {

     

       131
       131
       +
                     argv = [ "/bin/false" ];

     

       132
       132
       +
                   };

     

       133
       133
       +
                   services.exclacow = {

     

       134
       134
       +
                     process = {

     

       135
       135
       +
                       argv = [

     

       136
       136
       +
                         "${dummyPkg "cowsay-ng"}/bin/cowsay"

     

       137
       137
       +
                         "!"

     

       138
       138
       +
                       ];

     

       139
       139
       +
                     };

     

       140
       140
       +
                     services = { };

     

       141
       141
       +
                     assertions = [

     

       142
       142
       +
                       {

     

       143
       143
       +
                         assertion = false;

     

       144
       144
       +
                         message = "you can't enable this for such reason";

     

       145
       145
       +
                       }

     

       146
       146
       +
                     ];

     

       147
       147
       +
                     warnings = [ "The `bar' service is deprecated and will go away soon!" ];

     

       148
       148
       +
                   };

     

       149
       149
       +
                   assertions = [ ];

     

       150
       150
       +
                   warnings = [ ];

     

       151
       151
       +
                 };

     

       152
       152
       +
               };

     

       153
       153
       +
             };

     

       154
       154
       +
       

     

       155
       155
       +
           assert

     

       156
       156
       +
             portable-lib.getWarnings [ "service1" ] exampleEval.config.services.service1 == [

     

       157
       157
       +
               "in service1: The `foo' service is deprecated and will go away soon!"

     

       158
       158
       +
             ];

     

       159
       159
       +
       

     

       160
       160
       +
           assert

     

       161
       161
       +
             portable-lib.getAssertions [ "service1" ] exampleEval.config.services.service1 == [

     

       162
       162
       +
               {

     

       163
       163
       +
                 message = "in service1: you can't enable this for that reason";

     

       164
       164
       +
                 assertion = false;

     

       165
       165
       +
               }

     

       166
       166
       +
             ];

     

       167
       167
       +
       

     

       168
       168
       +
           assert

     

       169
       169
       +
             portable-lib.getWarnings [ "service3" ] exampleEval.config.services.service3 == [

     

       170
       170
       +
               "in service3.services.exclacow: The `bar' service is deprecated and will go away soon!"

     

       171
       171
       +
             ];

     

       172
       172
       +
           assert

     

       173
       173
       +
             portable-lib.getAssertions [ "service3" ] exampleEval.config.services.service3 == [

     

       174
       174
       +
               {

     

       175
       175
       +
                 message = "in service3.services.exclacow: you can't enable this for such reason";

     

       176
       176
       +
                 assertion = false;

     

       177
       177
       +
               }

     

       178
       178
       +
             ];

     

       179
       179
       +
       

     

       180
       180
       +
           "ok";

     

       181
       181
       +
       

     

       182
       182
       +
       in

     

       183
       183
       +
       test

+121

nixos/modules/system/service/systemd/service.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         config,

     

       4
       4
       +
         systemdPackage,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         inherit (lib)

     

       9
       9
       +
           concatMapStringsSep

     

       10
       10
       +
           isDerivation

     

       11
       11
       +
           isInt

     

       12
       12
       +
           isFloat

     

       13
       13
       +
           isPath

     

       14
       14
       +
           isString

     

       15
       15
       +
           mkOption

     

       16
       16
       +
           replaceStrings

     

       17
       17
       +
           types

     

       18
       18
       +
           ;

     

       19
       19
       +
         inherit (builtins) toJSON;

     

       20
       20
       +
       

     

       21
       21
       +
         # Local copy of systemd exec argument escaping function.

     

       22
       22
       +
         # TODO: This could perhaps be deduplicated, but it is unclear where it should go.

     

       23
       23
       +
         #       Preferably, we don't create a hard dependency on NixOS here, so that this

     

       24
       24
       +
         #       module can be reused in a non-NixOS context, such as mutaable services

     

       25
       25
       +
         #       in /run/systemd/system.

     

       26
       26
       +
       

     

       27
       27
       +
         # Quotes an argument for use in Exec* service lines.

     

       28
       28
       +
         # systemd accepts "-quoted strings with escape sequences, toJSON produces

     

       29
       29
       +
         # a subset of these.

     

       30
       30
       +
         # Additionally we escape % to disallow expansion of % specifiers. Any lone ;

     

       31
       31
       +
         # in the input will be turned it ";" and thus lose its special meaning.

     

       32
       32
       +
         # Every $ is escaped to $$, this makes it unnecessary to disable environment

     

       33
       33
       +
         # substitution for the directive.

     

       34
       34
       +
         escapeSystemdExecArg =

     

       35
       35
       +
           arg:

     

       36
       36
       +
           let

     

       37
       37
       +
             s =

     

       38
       38
       +
               if isPath arg then

     

       39
       39
       +
                 "${arg}"

     

       40
       40
       +
               else if isString arg then

     

       41
       41
       +
                 arg

     

       42
       42
       +
               else if isInt arg || isFloat arg || isDerivation arg then

     

       43
       43
       +
                 toString arg

     

       44
       44
       +
               else

     

       45
       45
       +
                 throw "escapeSystemdExecArg only allows strings, paths, numbers and derivations";

     

       46
       46
       +
           in

     

       47
       47
       +
           replaceStrings [ "%" "$" ] [ "%%" "$$" ] (toJSON s);

     

       48
       48
       +
       

     

       49
       49
       +
         # Quotes a list of arguments into a single string for use in a Exec*

     

       50
       50
       +
         # line.

     

       51
       51
       +
         escapeSystemdExecArgs = concatMapStringsSep " " escapeSystemdExecArg;

     

       52
       52
       +
       

     

       53
       53
       +
       in

     

       54
       54
       +
       {

     

       55
       55
       +
         imports = [

     

       56
       56
       +
           ../portable/service.nix

     

       57
       57
       +
           (lib.mkAliasOptionModule [ "systemd" "service" ] [ "systemd" "services" "" ])

     

       58
       58
       +
           (lib.mkAliasOptionModule [ "systemd" "socket" ] [ "systemd" "sockets" "" ])

     

       59
       59
       +
         ];

     

       60
       60
       +
         options = {

     

       61
       61
       +
           systemd.services = mkOption {

     

       62
       62
       +
             description = ''

     

       63
       63
       +
               This module configures systemd services, with the notable difference that their unit names will be prefixed with the abstract service name.

     

       64
       64
       +
       

     

       65
       65
       +
               This option's value is not suitable for reading, but you can define a module here that interacts with just the unit configuration in the host system configuration.

     

       66
       66
       +
       

     

       67
       67
       +
               Note that this option contains _deferred_ modules.

     

       68
       68
       +
               This means that the module has not been combined with the system configuration yet, no values can be read from this option.

     

       69
       69
       +
               What you can do instead is define a module that reads from the module arguments (such as `config`) that are available when the module is merged into the system configuration.

     

       70
       70
       +
             '';

     

       71
       71
       +
             type = types.lazyAttrsOf (

     

       72
       72
       +
               types.deferredModuleWith {

     

       73
       73
       +
                 staticModules = [

     

       74
       74
       +
                   # TODO: Add modules for the purpose of generating documentation?

     

       75
       75
       +
                 ];

     

       76
       76
       +
               }

     

       77
       77
       +
             );

     

       78
       78
       +
             default = { };

     

       79
       79
       +
           };

     

       80
       80
       +
           systemd.sockets = mkOption {

     

       81
       81
       +
             description = ''

     

       82
       82
       +
               Declares systemd socket units. Names will be prefixed by the service name / path.

     

       83
       83
       +
       

     

       84
       84
       +
               See {option}`systemd.services`.

     

       85
       85
       +
             '';

     

       86
       86
       +
             type = types.lazyAttrsOf types.deferredModule;

     

       87
       87
       +
             default = { };

     

       88
       88
       +
           };

     

       89
       89
       +
       

     

       90
       90
       +
           # Also import systemd logic into sub-services

     

       91
       91
       +
           # extends the portable `services` option

     

       92
       92
       +
           services = mkOption {

     

       93
       93
       +
             type = types.attrsOf (

     

       94
       94
       +
               types.submoduleWith {

     

       95
       95
       +
                 class = "service";

     

       96
       96
       +
                 modules = [

     

       97
       97
       +
                   ./service.nix

     

       98
       98
       +
                 ];

     

       99
       99
       +
                 specialArgs = {

     

       100
       100
       +
                   inherit systemdPackage;

     

       101
       101
       +
                 };

     

       102
       102
       +
               }

     

       103
       103
       +
             );

     

       104
       104
       +
           };

     

       105
       105
       +
         };

     

       106
       106
       +
         config = {

     

       107
       107
       +
           # Note that this is the systemd.services option above, not the system one.

     

       108
       108
       +
           systemd.services."" = {

     

       109
       109
       +
             # TODO description;

     

       110
       110
       +
             wantedBy = lib.mkDefault [ "multi-user.target" ];

     

       111
       111
       +
             serviceConfig = {

     

       112
       112
       +
               Type = lib.mkDefault "simple";

     

       113
       113
       +
               Restart = lib.mkDefault "always";

     

       114
       114
       +
               RestartSec = lib.mkDefault "5";

     

       115
       115
       +
               ExecStart = [

     

       116
       116
       +
                 (escapeSystemdExecArgs config.process.argv)

     

       117
       117
       +
               ];

     

       118
       118
       +
             };

     

       119
       119
       +
           };

     

       120
       120
       +
         };

     

       121
       121
       +
       }

+90

nixos/modules/system/service/systemd/system.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         config,

     

       4
       4
       +
         options,

     

       5
       5
       +
         pkgs,

     

       6
       6
       +
         ...

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       let

     

       10
       10
       +
         inherit (lib)

     

       11
       11
       +
           concatMapAttrs

     

       12
       12
       +
           mkOption

     

       13
       13
       +
           types

     

       14
       14
       +
           concatLists

     

       15
       15
       +
           mapAttrsToList

     

       16
       16
       +
           ;

     

       17
       17
       +
       

     

       18
       18
       +
         portable-lib = import ../portable/lib.nix { inherit lib; };

     

       19
       19
       +
       

     

       20
       20
       +
         dash =

     

       21
       21
       +
           before: after:

     

       22
       22
       +
           if after == "" then

     

       23
       23
       +
             before

     

       24
       24
       +
           else if before == "" then

     

       25
       25
       +
             after

     

       26
       26
       +
           else

     

       27
       27
       +
             "${before}-${after}";

     

       28
       28
       +
       

     

       29
       29
       +
         makeUnits =

     

       30
       30
       +
           unitType: prefix: service:

     

       31
       31
       +
           concatMapAttrs (unitName: unitModule: {

     

       32
       32
       +
             "${dash prefix unitName}" =

     

       33
       33
       +
               { ... }:

     

       34
       34
       +
               {

     

       35
       35
       +
                 imports = [ unitModule ];

     

       36
       36
       +
               };

     

       37
       37
       +
           }) service.systemd.${unitType}

     

       38
       38
       +
           // concatMapAttrs (

     

       39
       39
       +
             subServiceName: subService: makeUnits unitType (dash prefix subServiceName) subService

     

       40
       40
       +
           ) service.services;

     

       41
       41
       +
       in

     

       42
       42
       +
       {

     

       43
       43
       +
         # First half of the magic: mix systemd logic into the otherwise abstract services

     

       44
       44
       +
         options = {

     

       45
       45
       +
           system.services = mkOption {

     

       46
       46
       +
             description = ''

     

       47
       47
       +
               A collection of NixOS [modular services](https://nixos.org/manual/nixos/unstable/#modular-services) that are configured as systemd services.

     

       48
       48
       +
             '';

     

       49
       49
       +
             type = types.attrsOf (

     

       50
       50
       +
               types.submoduleWith {

     

       51
       51
       +
                 class = "service";

     

       52
       52
       +
                 modules = [

     

       53
       53
       +
                   ./service.nix

     

       54
       54
       +
                 ];

     

       55
       55
       +
                 specialArgs = {

     

       56
       56
       +
                   # perhaps: features."systemd" = { };

     

       57
       57
       +
                   inherit pkgs;

     

       58
       58
       +
                   systemdPackage = config.systemd.package;

     

       59
       59
       +
                 };

     

       60
       60
       +
               }

     

       61
       61
       +
             );

     

       62
       62
       +
             default = { };

     

       63
       63
       +
             visible = "shallow";

     

       64
       64
       +
           };

     

       65
       65
       +
         };

     

       66
       66
       +
       

     

       67
       67
       +
         # Second half of the magic: siphon units that were defined in isolation to the system

     

       68
       68
       +
         config = {

     

       69
       69
       +
       

     

       70
       70
       +
           assertions = concatLists (

     

       71
       71
       +
             mapAttrsToList (

     

       72
       72
       +
               name: cfg: portable-lib.getAssertions (options.system.services.loc ++ [ name ]) cfg

     

       73
       73
       +
             ) config.system.services

     

       74
       74
       +
           );

     

       75
       75
       +
       

     

       76
       76
       +
           warnings = concatLists (

     

       77
       77
       +
             mapAttrsToList (

     

       78
       78
       +
               name: cfg: portable-lib.getWarnings (options.system.services.loc ++ [ name ]) cfg

     

       79
       79
       +
             ) config.system.services

     

       80
       80
       +
           );

     

       81
       81
       +
       

     

       82
       82
       +
           systemd.services = concatMapAttrs (

     

       83
       83
       +
             serviceName: topLevelService: makeUnits "services" serviceName topLevelService

     

       84
       84
       +
           ) config.system.services;

     

       85
       85
       +
       

     

       86
       86
       +
           systemd.sockets = concatMapAttrs (

     

       87
       87
       +
             serviceName: topLevelService: makeUnits "sockets" serviceName topLevelService

     

       88
       88
       +
           ) config.system.services;

     

       89
       89
       +
         };

     

       90
       90
       +
       }

+92

nixos/modules/system/service/systemd/test.nix

···

       1
       1
       +
       # Run:

     

       2
       2
       +
       #   nix-build -A nixosTests.modularService

     

       3
       3
       +
       

     

       4
       4
       +
       {

     

       5
       5
       +
         evalSystem,

     

       6
       6
       +
         runCommand,

     

       7
       7
       +
         hello,

     

       8
       8
       +
         ...

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       let

     

       12
       12
       +
         machine = evalSystem (

     

       13
       13
       +
           { lib, ... }:

     

       14
       14
       +
           let

     

       15
       15
       +
             hello' = lib.getExe hello;

     

       16
       16
       +
           in

     

       17
       17
       +
           {

     

       18
       18
       +
       

     

       19
       19
       +
             # Test input

     

       20
       20
       +
       

     

       21
       21
       +
             system.services.foo = {

     

       22
       22
       +
               process = {

     

       23
       23
       +
                 argv = [

     

       24
       24
       +
                   hello'

     

       25
       25
       +
                   "--greeting"

     

       26
       26
       +
                   "hoi"

     

       27
       27
       +
                 ];

     

       28
       28
       +
               };

     

       29
       29
       +
             };

     

       30
       30
       +
             system.services.bar = {

     

       31
       31
       +
               process = {

     

       32
       32
       +
                 argv = [

     

       33
       33
       +
                   hello'

     

       34
       34
       +
                   "--greeting"

     

       35
       35
       +
                   "hoi"

     

       36
       36
       +
                 ];

     

       37
       37
       +
               };

     

       38
       38
       +
               systemd.service = {

     

       39
       39
       +
                 serviceConfig.X-Bar = "lol crossbar whatever";

     

       40
       40
       +
               };

     

       41
       41
       +
               services.db = {

     

       42
       42
       +
                 process = {

     

       43
       43
       +
                   argv = [

     

       44
       44
       +
                     hello'

     

       45
       45
       +
                     "--greeting"

     

       46
       46
       +
                     "Hi, I'm a database, would you believe it"

     

       47
       47
       +
                   ];

     

       48
       48
       +
                 };

     

       49
       49
       +
                 systemd.service = {

     

       50
       50
       +
                   serviceConfig.RestartSec = "42";

     

       51
       51
       +
                 };

     

       52
       52
       +
               };

     

       53
       53
       +
             };

     

       54
       54
       +
       

     

       55
       55
       +
             # irrelevant stuff

     

       56
       56
       +
             system.stateVersion = "25.05";

     

       57
       57
       +
             fileSystems."/".device = "/test/dummy";

     

       58
       58
       +
             boot.loader.grub.enable = false;

     

       59
       59
       +
           }

     

       60
       60
       +
         );

     

       61
       61
       +
       

     

       62
       62
       +
         inherit (machine.config.system.build) toplevel;

     

       63
       63
       +
       in

     

       64
       64
       +
       runCommand "test-modular-service-systemd-units"

     

       65
       65
       +
         {

     

       66
       66
       +
           passthru = {

     

       67
       67
       +
             inherit

     

       68
       68
       +
               machine

     

       69
       69
       +
               toplevel

     

       70
       70
       +
               ;

     

       71
       71
       +
           };

     

       72
       72
       +
         }

     

       73
       73
       +
         ''

     

       74
       74
       +
           echo ${toplevel}/etc/systemd/system/foo.service:

     

       75
       75
       +
           cat -n ${toplevel}/etc/systemd/system/foo.service

     

       76
       76
       +
           (

     

       77
       77
       +
             set -x

     

       78
       78
       +
             grep -F 'ExecStart="${hello}/bin/hello" "--greeting" "hoi"' ${toplevel}/etc/systemd/system/foo.service >/dev/null

     

       79
       79
       +
       

     

       80
       80
       +
             grep -F 'ExecStart="${hello}/bin/hello" "--greeting" "hoi"' ${toplevel}/etc/systemd/system/bar.service >/dev/null

     

       81
       81
       +
             grep -F 'X-Bar=lol crossbar whatever' ${toplevel}/etc/systemd/system/bar.service >/dev/null

     

       82
       82
       +
       

     

       83
       83
       +
             grep    'ExecStart="${hello}/bin/hello" "--greeting" ".*database.*"' ${toplevel}/etc/systemd/system/bar-db.service >/dev/null

     

       84
       84
       +
             grep -F 'RestartSec=42' ${toplevel}/etc/systemd/system/bar-db.service >/dev/null

     

       85
       85
       +
       

     

       86
       86
       +
             [[ ! -e ${toplevel}/etc/systemd/system/foo.socket ]]

     

       87
       87
       +
             [[ ! -e ${toplevel}/etc/systemd/system/bar.socket ]]

     

       88
       88
       +
             [[ ! -e ${toplevel}/etc/systemd/system/bar-db.socket ]]

     

       89
       89
       +
           )

     

       90
       90
       +
           echo 🐬👍

     

       91
       91
       +
           touch $out

     

       92
       92
       +
         ''

nixos/modules/system/service/systemd/user.nix

···

       1
       1
       +
       # TBD, analogous to system.nix but for user units

     

       2
       2
       +
       {

     

       3
       3
       +
       }

+14

nixos/tests/all-tests.nix

···

       89
       89
        
           featureFlags.minimalModules = { };

     

       90
       90
        
         };

     

       91
       91
        
         evalMinimalConfig = module: nixosLib.evalModules { modules = [ module ]; };

     

       92
       92
       +
         evalSystem =

     

       93
       93
       +
           module:

     

       94
       94
       +
           import ../lib/eval-config.nix {

     

       95
       95
       +
             system = null;

     

       96
       96
       +
             modules = [

     

       97
       97
       +
               ../modules/misc/nixpkgs/read-only.nix

     

       98
       98
       +
               { nixpkgs.pkgs = pkgs; }

     

       99
       99
       +
               module

     

       100
       100
       +
             ];

     

       101
       101
       +
           };

     

       92
       102
        
       

     

       93
       103
        
         inherit

     

       94
       104
        
           (rec {

     
···

       589
       599
        
         gerrit = runTest ./gerrit.nix;

     

       590
       600
        
         geth = runTest ./geth.nix;

     

       591
       601
        
         ghostunnel = runTest ./ghostunnel.nix;

     

       602
       602
       +
         ghostunnel-modular = runTest ./ghostunnel-modular.nix;

     

       592
       603
        
         gitdaemon = runTest ./gitdaemon.nix;

     

       593
       604
        
         gitea = handleTest ./gitea.nix { giteaPackage = pkgs.gitea; };

     

       594
       605
        
         github-runner = runTest ./github-runner.nix;

     
···

       894
       905
        
         mjolnir = runTest ./matrix/mjolnir.nix;

     

       895
       906
        
         mobilizon = runTest ./mobilizon.nix;

     

       896
       907
        
         mod_perl = runTest ./mod_perl.nix;

     

       908
       908
       +
         modularService = pkgs.callPackage ../modules/system/service/systemd/test.nix {

     

       909
       909
       +
           inherit evalSystem;

     

       910
       910
       +
         };

     

       897
       911
        
         molly-brown = runTest ./molly-brown.nix;

     

       898
       912
        
         mollysocket = runTest ./mollysocket.nix;

     

       899
       913
        
         monado = runTest ./monado.nix;

+120

nixos/tests/ghostunnel-modular.nix

···

       1
       1
       +
       { hostPkgs, lib, ... }:

     

       2
       2
       +
       {

     

       3
       3
       +
         _class = "nixosTest";

     

       4
       4
       +
         name = "ghostunnel";

     

       5
       5
       +
         nodes = {

     

       6
       6
       +
           backend =

     

       7
       7
       +
             { pkgs, ... }:

     

       8
       8
       +
             {

     

       9
       9
       +
               services.nginx.enable = true;

     

       10
       10
       +
               services.nginx.virtualHosts."backend".root = pkgs.runCommand "webroot" { } ''

     

       11
       11
       +
                 mkdir $out

     

       12
       12
       +
                 echo hi >$out/hi.txt

     

       13
       13
       +
               '';

     

       14
       14
       +
               networking.firewall.allowedTCPPorts = [ 80 ];

     

       15
       15
       +
             };

     

       16
       16
       +
           service =

     

       17
       17
       +
             { pkgs, ... }:

     

       18
       18
       +
             {

     

       19
       19
       +
               system.services."ghostunnel-plain-old" = {

     

       20
       20
       +
                 imports = [ pkgs.ghostunnel.services.default ];

     

       21
       21
       +
                 ghostunnel = {

     

       22
       22
       +
                   listen = "0.0.0.0:443";

     

       23
       23
       +
                   cert = "/root/service-cert.pem";

     

       24
       24
       +
                   key = "/root/service-key.pem";

     

       25
       25
       +
                   disableAuthentication = true;

     

       26
       26
       +
                   target = "backend:80";

     

       27
       27
       +
                   unsafeTarget = true;

     

       28
       28
       +
                 };

     

       29
       29
       +
               };

     

       30
       30
       +
               system.services."ghostunnel-client-cert" = {

     

       31
       31
       +
                 imports = [ pkgs.ghostunnel.services.default ];

     

       32
       32
       +
                 ghostunnel = {

     

       33
       33
       +
                   listen = "0.0.0.0:1443";

     

       34
       34
       +
                   cert = "/root/service-cert.pem";

     

       35
       35
       +
                   key = "/root/service-key.pem";

     

       36
       36
       +
                   cacert = "/root/ca.pem";

     

       37
       37
       +
                   target = "backend:80";

     

       38
       38
       +
                   allowCN = [ "client" ];

     

       39
       39
       +
                   unsafeTarget = true;

     

       40
       40
       +
                 };

     

       41
       41
       +
               };

     

       42
       42
       +
               networking.firewall.allowedTCPPorts = [

     

       43
       43
       +
                 443

     

       44
       44
       +
                 1443

     

       45
       45
       +
               ];

     

       46
       46
       +
             };

     

       47
       47
       +
           client =

     

       48
       48
       +
             { pkgs, ... }:

     

       49
       49
       +
             {

     

       50
       50
       +
               environment.systemPackages = [

     

       51
       51
       +
                 pkgs.curl

     

       52
       52
       +
               ];

     

       53
       53
       +
             };

     

       54
       54
       +
         };

     

       55
       55
       +
       

     

       56
       56
       +
         testScript = ''

     

       57
       57
       +
       

     

       58
       58
       +
           # prepare certificates

     

       59
       59
       +
       

     

       60
       60
       +
           def cmd(command):

     

       61
       61
       +
             print(f"+{command}")

     

       62
       62
       +
             r = os.system(command)

     

       63
       63
       +
             if r != 0:

     

       64
       64
       +
               raise Exception(f"Command {command} failed with exit code {r}")

     

       65
       65
       +
       

     

       66
       66
       +
           # Create CA

     

       67
       67
       +
           cmd("${hostPkgs.openssl}/bin/openssl genrsa -out ca-key.pem 4096")

     

       68
       68
       +
           cmd("${hostPkgs.openssl}/bin/openssl req -new -x509 -days 365 -key ca-key.pem -sha256 -subj '/C=NL/ST=Zuid-Holland/L=The Hague/O=Stevige Balken en Planken B.V./OU=OpSec/CN=Certificate Authority' -out ca.pem")

     

       69
       69
       +
       

     

       70
       70
       +
           # Create service

     

       71
       71
       +
           cmd("${hostPkgs.openssl}/bin/openssl genrsa -out service-key.pem 4096")

     

       72
       72
       +
           cmd("${hostPkgs.openssl}/bin/openssl req -subj '/CN=service' -sha256 -new -key service-key.pem -out service.csr")

     

       73
       73
       +
           cmd("echo subjectAltName = DNS:service,IP:127.0.0.1 >> extfile.cnf")

     

       74
       74
       +
           cmd("echo extendedKeyUsage = serverAuth >> extfile.cnf")

     

       75
       75
       +
           cmd("${hostPkgs.openssl}/bin/openssl x509 -req -days 365 -sha256 -in service.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out service-cert.pem -extfile extfile.cnf")

     

       76
       76
       +
       

     

       77
       77
       +
           # Create client

     

       78
       78
       +
           cmd("${hostPkgs.openssl}/bin/openssl genrsa -out client-key.pem 4096")

     

       79
       79
       +
           cmd("${hostPkgs.openssl}/bin/openssl req -subj '/CN=client' -new -key client-key.pem -out client.csr")

     

       80
       80
       +
           cmd("echo extendedKeyUsage = clientAuth > extfile-client.cnf")

     

       81
       81
       +
           cmd("${hostPkgs.openssl}/bin/openssl x509 -req -days 365 -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out client-cert.pem -extfile extfile-client.cnf")

     

       82
       82
       +
       

     

       83
       83
       +
           cmd("ls -al")

     

       84
       84
       +
       

     

       85
       85
       +
           start_all()

     

       86
       86
       +
       

     

       87
       87
       +
           # Configuration

     

       88
       88
       +
           service.copy_from_host("ca.pem", "/root/ca.pem")

     

       89
       89
       +
           service.copy_from_host("service-cert.pem", "/root/service-cert.pem")

     

       90
       90
       +
           service.copy_from_host("service-key.pem", "/root/service-key.pem")

     

       91
       91
       +
           client.copy_from_host("ca.pem", "/root/ca.pem")

     

       92
       92
       +
           client.copy_from_host("service-cert.pem", "/root/service-cert.pem")

     

       93
       93
       +
           client.copy_from_host("client-cert.pem", "/root/client-cert.pem")

     

       94
       94
       +
           client.copy_from_host("client-key.pem", "/root/client-key.pem")

     

       95
       95
       +
       

     

       96
       96
       +
           backend.wait_for_unit("nginx.service")

     

       97
       97
       +
           service.wait_for_unit("multi-user.target")

     

       98
       98
       +
           service.wait_for_unit("multi-user.target")

     

       99
       99
       +
           client.wait_for_unit("multi-user.target")

     

       100
       100
       +
       

     

       101
       101
       +
           # Check assumptions before the real test

     

       102
       102
       +
           client.succeed("bash -c 'diff <(curl -v --no-progress-meter http://backend/hi.txt) <(echo hi)'")

     

       103
       103
       +
       

     

       104
       104
       +
           # Plain old simple TLS can connect, ignoring cert

     

       105
       105
       +
           client.succeed("bash -c 'diff <(curl -v --no-progress-meter --insecure https://service/hi.txt) <(echo hi)'")

     

       106
       106
       +
       

     

       107
       107
       +
           # Plain old simple TLS provides correct signature with its cert

     

       108
       108
       +
           client.succeed("bash -c 'diff <(curl -v --no-progress-meter --cacert /root/ca.pem https://service/hi.txt) <(echo hi)'")

     

       109
       109
       +
       

     

       110
       110
       +
           # Client can authenticate with certificate

     

       111
       111
       +
           client.succeed("bash -c 'diff <(curl -v --no-progress-meter --cert /root/client-cert.pem --key /root/client-key.pem --cacert /root/ca.pem https://service:1443/hi.txt) <(echo hi)'")

     

       112
       112
       +
       

     

       113
       113
       +
           # Client must authenticate with certificate

     

       114
       114
       +
           client.fail("bash -c 'diff <(curl -v --no-progress-meter --cacert /root/ca.pem https://service:1443/hi.txt) <(echo hi)'")

     

       115
       115
       +
         '';

     

       116
       116
       +
       

     

       117
       117
       +
         meta.maintainers = with lib.maintainers; [

     

       118
       118
       +
           roberth

     

       119
       119
       +
         ];

     

       120
       120
       +
       }

+13

pkgs/applications/editors/vim/plugins/generated.nix

···

       12025
       12025
        
           meta.hydraPlatforms = [ ];

     

       12026
       12026
        
         };

     

       12027
       12027
        
       

     

       12028
       12028
       +
         opencode-nvim = buildVimPlugin {

     

       12029
       12029
       +
           pname = "opencode.nvim";

     

       12030
       12030
       +
           version = "2025-07-24";

     

       12031
       12031
       +
           src = fetchFromGitHub {

     

       12032
       12032
       +
             owner = "NickvanDyke";

     

       12033
       12033
       +
             repo = "opencode.nvim";

     

       12034
       12034
       +
             rev = "db3aa9ca3b738600c81e29646a3356477dabaa87";

     

       12035
       12035
       +
             sha256 = "1yhspgja3zdnsf8r3ahci14cndk3bzxvq0w9jqggd7ya103nq6kz";

     

       12036
       12036
       +
           };

     

       12037
       12037
       +
           meta.homepage = "https://github.com/NickvanDyke/opencode.nvim/";

     

       12038
       12038
       +
           meta.hydraPlatforms = [ ];

     

       12039
       12039
       +
         };

     

       12040
       12040
       +
       

     

       12028
       12041
        
         openingh-nvim = buildVimPlugin {

     

       12029
       12042
        
           pname = "openingh.nvim";

     

       12030
       12043
        
           version = "2025-05-01";

pkgs/applications/editors/vim/plugins/vim-plugin-names

···

       923
       923
        
       https://github.com/rmehri01/onenord.nvim/,main,

     

       924
       924
        
       https://github.com/tyru/open-browser-github.vim/,,

     

       925
       925
        
       https://github.com/tyru/open-browser.vim/,,

     

       926
       926
       +
       https://github.com/NickvanDyke/opencode.nvim/,HEAD,

     

       926
       927
        
       https://github.com/Almo7aya/openingh.nvim/,,

     

       927
       928
        
       https://github.com/salkin-mada/openscad.nvim/,HEAD,

     

       928
       929
        
       https://github.com/chipsenkbeil/org-roam.nvim/,HEAD,

pkgs/applications/video/olive-editor/default.nix

···

       30
       30
        
               hash = "sha256-I2/JPmUBDb0bw7qbSZcAkYHB2q2Uo7En7ZurMwWhg/M=";

     

       31
       31
        
             }

     

       32
       32
        
           );

     

       33
       33
       +
       

     

       34
       34
       +
           # robin-map headers require c++17

     

       35
       35
       +
           cmakeFlags = (old.cmakeFlags or [ ]) ++ [ (lib.cmakeFeature "CMAKE_CXX_STANDARD" "17") ];

     

       33
       36
        
         });

     

       34
       37
        
       in

     

       35
       38

+2 -2

pkgs/by-name/as/astyle/package.nix

···

       9
       9
        
       

     

       10
       10
        
       stdenv.mkDerivation rec {

     

       11
       11
        
         pname = "astyle";

     

       12
       12
       -
         version = "3.6.9";

     

       12
       12
       +
         version = "3.6.10";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://sourceforge/${pname}/${pname}-${version}.tar.bz2";

     

       16
       16
       -
           hash = "sha256-tkRZdlTfW0AIe+SkZyPGUED3zlnzNp8bj2kPnBDKurw=";

     

       16
       16
       +
           hash = "sha256-HW7onAhKk93MKNGgVs2o0cNX0xjvjihEVtnwvSzrS20=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [ cmake ];

+2 -2

pkgs/by-name/bl/blender/package.nix

···

       58
       58
        
         opencolorio,

     

       59
       59
        
         openexr,

     

       60
       60
        
         openimagedenoise,

     

       61
       61
       -
         openimageio_2,

     

       61
       61
       +
         openimageio,

     

       62
       62
        
         openjpeg,

     

       63
       63
        
         openpgl,

     

       64
       64
        
         opensubdiv,

     
···

       250
       250
        
           (manifold.override { tbb_2021 = tbb; })

     

       251
       251
        
           opencolorio

     

       252
       252
        
           openexr

     

       253
       253
       -
           openimageio_2

     

       253
       253
       +
           openimageio

     

       254
       254
        
           openjpeg

     

       255
       255
        
           (openpgl.override { inherit tbb; })

     

       256
       256
        
           (opensubdiv.override { inherit cudaSupport; })

+3 -3

pkgs/by-name/ch/chhoto-url/package.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage (finalAttrs: {

     

       10
       10
        
         pname = "chhoto-url";

     

       11
       11
       -
         version = "6.2.10";

     

       11
       11
       +
         version = "6.2.11";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "SinTan1729";

     

       15
       15
        
           repo = "chhoto-url";

     

       16
       16
        
           tag = finalAttrs.version;

     

       17
       17
       -
           hash = "sha256-56tbSOoYRtmRzKqRDe951JXOlPymRGtEyGSZ0dWXOcw=";

     

       17
       17
       +
           hash = "sha256-3VQmTQ6ZlDTRL3nx/sQxWLKgW8ee0Ts+C1CiWkiX2/g=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         sourceRoot = "${finalAttrs.src.name}/actix";

     
···

       24
       24
        
             --replace-fail "./resources/" "${placeholder "out"}/share/chhoto-url/resources/"

     

       25
       25
        
         '';

     

       26
       26
        
       

     

       27
       27
       -
         cargoHash = "sha256-z5BFo6X3Lpb/PJPMQ+3m1RozvXeHLaY81PABAE7gTTA=";

     

       27
       27
       +
         cargoHash = "sha256-QIqLzk/vAOrW0ain0Oq9tnqzCSyK4yDOYsjmil3xPc4=";

     

       28
       28
        
       

     

       29
       29
        
         postInstall = ''

     

       30
       30
        
           mkdir -p $out/share/chhoto-url

+2 -2

pkgs/by-name/ch/chroma/package.nix

···

       10
       10
        
       

     

       11
       11
        
       buildGoModule rec {

     

       12
       12
        
         pname = "chroma";

     

       13
       13
       -
         version = "2.15.0";

     

       13
       13
       +
         version = "2.19.0";

     

       14
       14
        
       

     

       15
       15
        
         # To update:

     

       16
       16
        
         # nix-prefetch-git --rev v${version} https://github.com/alecthomas/chroma.git > src.json

     
···

       21
       21
        
           inherit (srcInfo) sha256;

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
       -
         vendorHash = "sha256:14jg809xz647yv6sc8rnnksg2bpnn75panj8a2kdk2v87yrpq2zr";

     

       24
       24
       +
         vendorHash = "sha256-Gqldcp68Rn4wkfQptbmKUjkwLSb+qaFboJNfmWVkrPU=";

     

       25
       25
        
       

     

       26
       26
        
         modRoot = "./cmd/chroma";

     

       27
       27

+5 -5

pkgs/by-name/ch/chroma/src.json

···

       1
       1
        
       {

     

       2
       2
        
         "url": "https://github.com/alecthomas/chroma.git",

     

       3
       3
       -
         "rev": "009385f9487ee14c8a54e49aaf4331fea0830310",

     

       4
       4
       -
         "date": "2024-12-30T09:27:18+11:00",

     

       5
       5
       -
         "path": "/nix/store/rr2cj4bmlfw803diwyfpbrpai35gifaw-chroma",

     

       6
       6
       -
         "sha256": "088w3aixwfk8s04iyb2mjn3kx5dl3gb9q14jzawabcdy2ar7iijn",

     

       7
       7
       -
         "hash": "sha256-VsZ4shK+saW4+pIEnNYbtJU+h5VVLB8J0Gg63qMaHCE=",

     

       3
       3
       +
         "rev": "adeac8f5dbfb6806a51bcf07eefd89fc8a0aee6a",

     

       4
       4
       +
         "date": "2025-07-01T09:59:45+10:00",

     

       5
       5
       +
         "path": "/nix/store/063ldbczafhxq02g5n28bxr1xnl6fwgd-chroma",

     

       6
       6
       +
         "sha256": "1r50gqbizi7l1l07syx9wgfyx1k8gzspmsbpk42jnwgw3h9dcw42",

     

       7
       7
       +
         "hash": "sha256-gnDWEhz8cSsFmXfpevV/aIbu3eOpe30ADfTEHxd+oOQ=",

     

       8
       8
        
         "fetchLFS": false,

     

       9
       9
        
         "fetchSubmodules": false,

     

       10
       10
        
         "deepClone": false,

+2 -2

pkgs/by-name/gh/gh-f/package.nix

···

       25
       25
        
       in

     

       26
       26
        
       stdenvNoCC.mkDerivation rec {

     

       27
       27
        
         pname = "gh-f";

     

       28
       28
       -
         version = "1.3.0";

     

       28
       28
       +
         version = "1.4.0";

     

       29
       29
        
       

     

       30
       30
        
         src = fetchFromGitHub {

     

       31
       31
        
           owner = "gennaro-tedesco";

     

       32
       32
        
           repo = "gh-f";

     

       33
       33
        
           rev = "v${version}";

     

       34
       34
       -
           hash = "sha256-CW6iAI5IomJoMuPBFq/3owhZJbcruKtOqoxzsh+FNVw=";

     

       34
       34
       +
           hash = "sha256-JlMJ5RplEtQ8ApN3x1Sl0Lkutb5kLpuMJrF96oKZC9k=";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
        
         nativeBuildInputs = [

pkgs/by-name/gh/ghostunnel/package.nix

···

       4
       4
        
         fetchFromGitHub,

     

       5
       5
        
         lib,

     

       6
       6
        
         nixosTests,

     

       7
       7
       +
         ghostunnel,

     

       7
       8
        
         apple-sdk_12,

     

       8
       9
        
         darwinMinVersionHook,

     

       9
       10
        
       }:

     
···

       37
       38
        
         passthru.tests = {

     

       38
       39
        
           nixos = nixosTests.ghostunnel;

     

       39
       40
        
           podman = nixosTests.podman-tls-ghostunnel;

     

       41
       41
       +
         };

     

       42
       42
       +
       

     

       43
       43
       +
         passthru.services.default = {

     

       44
       44
       +
           imports = [ ./service.nix ];

     

       45
       45
       +
           ghostunnel.package = ghostunnel; # FIXME: finalAttrs.finalPackage

     

       40
       46
        
         };

     

       41
       47
        
       

     

       42
       48
        
         meta = {

+241

pkgs/by-name/gh/ghostunnel/service.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         config,

     

       4
       4
       +
         options,

     

       5
       5
       +
         pkgs,

     

       6
       6
       +
         ...

     

       7
       7
       +
       }:

     

       8
       8
       +
       let

     

       9
       9
       +
         inherit (lib)

     

       10
       10
       +
           concatStringsSep

     

       11
       11
       +
           getExe

     

       12
       12
       +
           mkDefault

     

       13
       13
       +
           mkIf

     

       14
       14
       +
           mkOption

     

       15
       15
       +
           optional

     

       16
       16
       +
           types

     

       17
       17
       +
           ;

     

       18
       18
       +
         cfg = config.ghostunnel;

     

       19
       19
       +
       

     

       20
       20
       +
       in

     

       21
       21
       +
       {

     

       22
       22
       +
         # https://nixos.org/manual/nixos/unstable/#modular-services

     

       23
       23
       +
         _class = "service";

     

       24
       24
       +
         options = {

     

       25
       25
       +
           ghostunnel = {

     

       26
       26
       +
             package = mkOption {

     

       27
       27
       +
               description = "Package to use for ghostunnel";

     

       28
       28
       +
               type = types.package;

     

       29
       29
       +
             };

     

       30
       30
       +
       

     

       31
       31
       +
             listen = mkOption {

     

       32
       32
       +
               description = ''

     

       33
       33
       +
                 Address and port to listen on (can be HOST:PORT, unix:PATH).

     

       34
       34
       +
               '';

     

       35
       35
       +
               type = types.str;

     

       36
       36
       +
             };

     

       37
       37
       +
       

     

       38
       38
       +
             target = mkOption {

     

       39
       39
       +
               description = ''

     

       40
       40
       +
                 Address to forward connections to (can be HOST:PORT or unix:PATH).

     

       41
       41
       +
               '';

     

       42
       42
       +
               type = types.str;

     

       43
       43
       +
             };

     

       44
       44
       +
       

     

       45
       45
       +
             keystore = mkOption {

     

       46
       46
       +
               description = ''

     

       47
       47
       +
                 Path to keystore (combined PEM with cert/key, or PKCS12 keystore).

     

       48
       48
       +
       

     

       49
       49
       +
                 NB: storepass is not supported because it would expose credentials via `/proc/*/cmdline`.

     

       50
       50
       +
       

     

       51
       51
       +
                 Specify this or `cert` and `key`.

     

       52
       52
       +
               '';

     

       53
       53
       +
               type = types.nullOr types.str;

     

       54
       54
       +
               default = null;

     

       55
       55
       +
             };

     

       56
       56
       +
       

     

       57
       57
       +
             cert = mkOption {

     

       58
       58
       +
               description = ''

     

       59
       59
       +
                 Path to certificate (PEM with certificate chain).

     

       60
       60
       +
       

     

       61
       61
       +
                 Not required if `keystore` is set.

     

       62
       62
       +
               '';

     

       63
       63
       +
               type = types.nullOr types.str;

     

       64
       64
       +
               default = null;

     

       65
       65
       +
             };

     

       66
       66
       +
       

     

       67
       67
       +
             key = mkOption {

     

       68
       68
       +
               description = ''

     

       69
       69
       +
                 Path to certificate private key (PEM with private key).

     

       70
       70
       +
       

     

       71
       71
       +
                 Not required if `keystore` is set.

     

       72
       72
       +
               '';

     

       73
       73
       +
               type = types.nullOr types.str;

     

       74
       74
       +
               default = null;

     

       75
       75
       +
             };

     

       76
       76
       +
       

     

       77
       77
       +
             cacert = mkOption {

     

       78
       78
       +
               description = ''

     

       79
       79
       +
                 Path to CA bundle file (PEM/X509). Uses system trust store if `null`.

     

       80
       80
       +
               '';

     

       81
       81
       +
               type = types.nullOr types.str;

     

       82
       82
       +
             };

     

       83
       83
       +
       

     

       84
       84
       +
             disableAuthentication = mkOption {

     

       85
       85
       +
               description = ''

     

       86
       86
       +
                 Disable client authentication, no client certificate will be required.

     

       87
       87
       +
               '';

     

       88
       88
       +
               type = types.bool;

     

       89
       89
       +
               default = false;

     

       90
       90
       +
             };

     

       91
       91
       +
       

     

       92
       92
       +
             allowAll = mkOption {

     

       93
       93
       +
               description = ''

     

       94
       94
       +
                 If true, allow all clients, do not check client cert subject.

     

       95
       95
       +
               '';

     

       96
       96
       +
               type = types.bool;

     

       97
       97
       +
               default = false;

     

       98
       98
       +
             };

     

       99
       99
       +
       

     

       100
       100
       +
             allowCN = mkOption {

     

       101
       101
       +
               description = ''

     

       102
       102
       +
                 Allow client if common name appears in the list.

     

       103
       103
       +
               '';

     

       104
       104
       +
               type = types.listOf types.str;

     

       105
       105
       +
               default = [ ];

     

       106
       106
       +
             };

     

       107
       107
       +
       

     

       108
       108
       +
             allowOU = mkOption {

     

       109
       109
       +
               description = ''

     

       110
       110
       +
                 Allow client if organizational unit name appears in the list.

     

       111
       111
       +
               '';

     

       112
       112
       +
               type = types.listOf types.str;

     

       113
       113
       +
               default = [ ];

     

       114
       114
       +
             };

     

       115
       115
       +
       

     

       116
       116
       +
             allowDNS = mkOption {

     

       117
       117
       +
               description = ''

     

       118
       118
       +
                 Allow client if DNS subject alternative name appears in the list.

     

       119
       119
       +
               '';

     

       120
       120
       +
               type = types.listOf types.str;

     

       121
       121
       +
               default = [ ];

     

       122
       122
       +
             };

     

       123
       123
       +
       

     

       124
       124
       +
             allowURI = mkOption {

     

       125
       125
       +
               description = ''

     

       126
       126
       +
                 Allow client if URI subject alternative name appears in the list.

     

       127
       127
       +
               '';

     

       128
       128
       +
               type = types.listOf types.str;

     

       129
       129
       +
               default = [ ];

     

       130
       130
       +
             };

     

       131
       131
       +
       

     

       132
       132
       +
             extraArguments = mkOption {

     

       133
       133
       +
               description = "Extra arguments to pass to `ghostunnel server`";

     

       134
       134
       +
               type = types.listOf types.str;

     

       135
       135
       +
               default = [ ];

     

       136
       136
       +
             };

     

       137
       137
       +
       

     

       138
       138
       +
             unsafeTarget = mkOption {

     

       139
       139
       +
               description = ''

     

       140
       140
       +
                 If set, does not limit target to localhost, 127.0.0.1, [::1], or UNIX sockets.

     

       141
       141
       +
       

     

       142
       142
       +
                 This is meant to protect against accidental unencrypted traffic on

     

       143
       143
       +
                 untrusted networks.

     

       144
       144
       +
               '';

     

       145
       145
       +
               type = types.bool;

     

       146
       146
       +
               default = false;

     

       147
       147
       +
             };

     

       148
       148
       +
           };

     

       149
       149
       +
         };

     

       150
       150
       +
       

     

       151
       151
       +
         config = {

     

       152
       152
       +
           assertions = [

     

       153
       153
       +
             {

     

       154
       154
       +
               message = ''

     

       155
       155
       +
                 At least one access control flag is required.

     

       156
       156
       +
                 Set at least one of:

     

       157
       157
       +
                   - ${options.ghostunnel.disableAuthentication}

     

       158
       158
       +
                   - ${options.ghostunnel.allowAll}

     

       159
       159
       +
                   - ${options.ghostunnel.allowCN}

     

       160
       160
       +
                   - ${options.ghostunnel.allowOU}

     

       161
       161
       +
                   - ${options.ghostunnel.allowDNS}

     

       162
       162
       +
                   - ${options.ghostunnel.allowURI}

     

       163
       163
       +
               '';

     

       164
       164
       +
               assertion =

     

       165
       165
       +
                 cfg.disableAuthentication

     

       166
       166
       +
                 || cfg.allowAll

     

       167
       167
       +
                 || cfg.allowCN != [ ]

     

       168
       168
       +
                 || cfg.allowOU != [ ]

     

       169
       169
       +
                 || cfg.allowDNS != [ ]

     

       170
       170
       +
                 || cfg.allowURI != [ ];

     

       171
       171
       +
             }

     

       172
       172
       +
           ];

     

       173
       173
       +
       

     

       174
       174
       +
           ghostunnel = {

     

       175
       175
       +
             # Clients should not be authenticated with the public root certificates

     

       176
       176
       +
             # (afaict, it doesn't make sense), so we only provide that default when

     

       177
       177
       +
             # client cert auth is disabled.

     

       178
       178
       +
             cacert = mkIf cfg.disableAuthentication (mkDefault null);

     

       179
       179
       +
           };

     

       180
       180
       +
       

     

       181
       181
       +
           # TODO assertions

     

       182
       182
       +
       

     

       183
       183
       +
           process = {

     

       184
       184
       +
             argv =

     

       185
       185
       +
               # Use a shell if credentials need to be pulled from the environment.

     

       186
       186
       +
               optional

     

       187
       187
       +
                 (builtins.any (v: v != null) [

     

       188
       188
       +
                   cfg.keystore

     

       189
       189
       +
                   cfg.cert

     

       190
       190
       +
                   cfg.key

     

       191
       191
       +
                   cfg.cacert

     

       192
       192
       +
                 ])

     

       193
       193
       +
                 (

     

       194
       194
       +
                   pkgs.writeScript "load-credentials" ''

     

       195
       195
       +
                     #!${pkgs.runtimeShell}

     

       196
       196
       +
                     exec $@ ${

     

       197
       197
       +
                       concatStringsSep " " (

     

       198
       198
       +
                         optional (cfg.keystore != null) "--keystore=$CREDENTIALS_DIRECTORY/keystore"

     

       199
       199
       +
                         ++ optional (cfg.cert != null) "--cert=$CREDENTIALS_DIRECTORY/cert"

     

       200
       200
       +
                         ++ optional (cfg.key != null) "--key=$CREDENTIALS_DIRECTORY/key"

     

       201
       201
       +
                         ++ optional (cfg.cacert != null) "--cacert=$CREDENTIALS_DIRECTORY/cacert"

     

       202
       202
       +
                       )

     

       203
       203
       +
                     }

     

       204
       204
       +
                   ''

     

       205
       205
       +
                 )

     

       206
       206
       +
               ++ [

     

       207
       207
       +
                 (getExe cfg.package)

     

       208
       208
       +
                 "server"

     

       209
       209
       +
                 "--listen"

     

       210
       210
       +
                 cfg.listen

     

       211
       211
       +
                 "--target"

     

       212
       212
       +
                 cfg.target

     

       213
       213
       +
               ]

     

       214
       214
       +
               ++ optional cfg.allowAll "--allow-all"

     

       215
       215
       +
               ++ map (v: "--allow-cn=${v}") cfg.allowCN

     

       216
       216
       +
               ++ map (v: "--allow-ou=${v}") cfg.allowOU

     

       217
       217
       +
               ++ map (v: "--allow-dns=${v}") cfg.allowDNS

     

       218
       218
       +
               ++ map (v: "--allow-uri=${v}") cfg.allowURI

     

       219
       219
       +
               ++ optional cfg.disableAuthentication "--disable-authentication"

     

       220
       220
       +
               ++ optional cfg.unsafeTarget "--unsafe-target"

     

       221
       221
       +
               ++ cfg.extraArguments;

     

       222
       222
       +
           };

     

       223
       223
       +
       

     

       224
       224
       +
           # refine the service

     

       225
       225
       +
           systemd.service = {

     

       226
       226
       +
             after = [ "network.target" ];

     

       227
       227
       +
             wants = [ "network.target" ];

     

       228
       228
       +
             wantedBy = [ "multi-user.target" ];

     

       229
       229
       +
             serviceConfig = {

     

       230
       230
       +
               Restart = "always";

     

       231
       231
       +
               AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" ];

     

       232
       232
       +
               DynamicUser = true;

     

       233
       233
       +
               LoadCredential =

     

       234
       234
       +
                 optional (cfg.keystore != null) "keystore:${cfg.keystore}"

     

       235
       235
       +
                 ++ optional (cfg.cert != null) "cert:${cfg.cert}"

     

       236
       236
       +
                 ++ optional (cfg.key != null) "key:${cfg.key}"

     

       237
       237
       +
                 ++ optional (cfg.cacert != null) "cacert:${cfg.cacert}";

     

       238
       238
       +
             };

     

       239
       239
       +
           };

     

       240
       240
       +
         };

     

       241
       241
       +
       }

+3 -3

pkgs/by-name/gi/gickup/package.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGoModule rec {

     

       9
       9
        
         pname = "gickup";

     

       10
       10
       -
         version = "0.10.38";

     

       10
       10
       +
         version = "0.10.39";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "cooperspencer";

     

       14
       14
        
           repo = "gickup";

     

       15
       15
        
           tag = "v${version}";

     

       16
       16
       -
           hash = "sha256-vthr4nkwuhvGXxH2P0uHeuQpjQFNTpGFHF+eXG2jiqk=";

     

       16
       16
       +
           hash = "sha256-Aalt/oiNzV2a8Ix/ruL4r3q0W1EY1UTe9IVPWNL+lLA=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         vendorHash = "sha256-RtuEpvux+8oJ829WEvz5OPfnYvFCdNo/9GCXhjXurRM=";

     

       19
       19
       +
         vendorHash = "sha256-Xtreh7nHovBYh0PnFYn2VuYGN8GQSmy6EPnZnHSdt/o=";

     

       20
       20
        
       

     

       21
       21
        
         ldflags = [ "-X main.version=${version}" ];

     

       22
       22

+2 -2

pkgs/by-name/gp/gpupad/package.nix

···

       7
       7
        
         glslang,

     

       8
       8
        
         imath,

     

       9
       9
        
         ktx-tools,

     

       10
       10
       -
         openimageio_2,

     

       10
       10
       +
         openimageio,

     

       11
       11
        
         qt6Packages,

     

       12
       12
        
         spdlog,

     

       13
       13
        
         spirv-cross,

     
···

       42
       42
        
           glslang

     

       43
       43
        
           imath # needed for openimageio

     

       44
       44
        
           ktx-tools

     

       45
       45
       -
           openimageio_2

     

       45
       45
       +
           openimageio

     

       46
       46
        
           qt6Packages.qtbase

     

       47
       47
        
           qt6Packages.qtdeclarative

     

       48
       48
        
           qt6Packages.qtmultimedia

+3 -3

pkgs/by-name/in/inputplumber/package.nix

···

       10
       10
        
       

     

       11
       11
        
       rustPlatform.buildRustPackage rec {

     

       12
       12
        
         pname = "inputplumber";

     

       13
       13
       -
         version = "0.60.2";

     

       13
       13
       +
         version = "0.60.7";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "ShadowBlip";

     

       17
       17
        
           repo = "InputPlumber";

     

       18
       18
        
           tag = "v${version}";

     

       19
       19
       -
           hash = "sha256-zcy9scs7oRRLKm/FL6BfO64IstWY4HmTRxG/jJG0jLw=";

     

       19
       19
       +
           hash = "sha256-3o5Y6fbshC3oTerf8M+yuo01BbQAilkT7TdrlwO6YBs=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         useFetchCargoVendor = true;

     

       23
       23
       -
         cargoHash = "sha256-fw7pM6HSy/8fNTYu7MqKiTl/2jdyDOLDBNhd0rpzb6M=";

     

       23
       23
       +
         cargoHash = "sha256-Tk3NCcturMHIs9hdGqwC87kqnhg/PvriCNSkYcq9+aM=";

     

       24
       24
        
       

     

       25
       25
        
         nativeBuildInputs = [

     

       26
       26
        
           pkg-config

+2 -2

pkgs/by-name/li/libdwarf/package.nix

···

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation (finalAttrs: {

     

       13
       13
        
         pname = "libdwarf";

     

       14
       14
       -
         version = "2.0.0";

     

       14
       14
       +
         version = "2.1.0";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "davea42";

     

       18
       18
        
           repo = "libdwarf-code";

     

       19
       19
        
           tag = "v${finalAttrs.version}";

     

       20
       20
       -
           hash = "sha256-SsFg+7zGBEGxDSzfiIP5bxdttlBkhEiEQWaU12hINas=";

     

       20
       20
       +
           hash = "sha256-Q+ke5vRSBFZirCIBu8M88LzBQW851kjkW4vUgE89ejQ=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [

+4 -4

pkgs/by-name/ma/maa-assistant-arknights/pin.json

···

       1
       1
        
       {

     

       2
       2
        
         "stable": {

     

       3
       3
       -
           "version": "5.18.3",

     

       4
       4
       -
           "hash": "sha256-we4mWtMemszIpTehk74hbqjisX1vTk94tLdGGNiz4c8="

     

       3
       3
       +
           "version": "5.20.0",

     

       4
       4
       +
           "hash": "sha256-XqzCxzmNJHG+aYBJoeAAryFx3XctrGBk6QqoonCbrWU="

     

       5
       5
        
         },

     

       6
       6
        
         "beta": {

     

       7
       7
       -
           "version": "5.18.3",

     

       8
       8
       -
           "hash": "sha256-we4mWtMemszIpTehk74hbqjisX1vTk94tLdGGNiz4c8="

     

       7
       7
       +
           "version": "5.20.0",

     

       8
       8
       +
           "hash": "sha256-XqzCxzmNJHG+aYBJoeAAryFx3XctrGBk6QqoonCbrWU="

     

       9
       9
        
         }

     

       10
       10
        
       }

+3 -3

pkgs/by-name/me/mergiraf/package.nix

···

       11
       11
        
       

     

       12
       12
        
       rustPlatform.buildRustPackage (finalAttrs: {

     

       13
       13
        
         pname = "mergiraf";

     

       14
       14
       -
         version = "0.12.1";

     

       14
       14
       +
         version = "0.13.0";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitea {

     

       17
       17
        
           domain = "codeberg.org";

     

       18
       18
        
           owner = "mergiraf";

     

       19
       19
        
           repo = "mergiraf";

     

       20
       20
        
           tag = "v${finalAttrs.version}";

     

       21
       21
       -
           hash = "sha256-09C5A9ToH3zzUlUcLDd/5wOOkWs4jmjaqI9HpzGebUU=";

     

       21
       21
       +
           hash = "sha256-MPmpS4iLur05jkSUrGl6NCtzRO/8Pch9pRNuT6psNRo=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         useFetchCargoVendor = true;

     

       25
       25
       -
         cargoHash = "sha256-TFGFHK35pary9nGG3XB474Bv2B8YW2X06NvInBLmcIA=";

     

       25
       25
       +
         cargoHash = "sha256-nT9HsG9eRBf4mRr7fqmRSQVI+yz+yr7wKCSQHG5JtD4=";

     

       26
       26
        
       

     

       27
       27
        
         nativeCheckInputs = [ git ];

     

       28
       28

+1 -1

pkgs/by-name/ni/nixos-render-docs/src/nixos_render_docs/redirects.py

···

       94
       94
        
                 - The first element of an identifier's redirects list must denote its current location.

     

       95
       95
        
               """

     

       96
       96
        
               xref_targets = {}

     

       97
       97
       -
               ignored_identifier_patterns = ("opt-", "auto-generated-", "function-library-")

     

       97
       97
       +
               ignored_identifier_patterns = ("opt-", "auto-generated-", "function-library-", "service-opt-", "systemd-service-opt")

     

       98
       98
        
               for id, target in initial_xref_targets.items():

     

       99
       99
        
                   # filter out automatically generated identifiers from module options and library documentation

     

       100
       100
        
                   if id.startswith(ignored_identifier_patterns):

+4 -4

pkgs/by-name/ol/olympus-unwrapped/package.nix

···

       31
       31
        
       

     

       32
       32
        
         phome = "$out/lib/olympus";

     

       33
       33
        
         # The following variables are to be updated by the update script.

     

       34
       34
       -
         version = "25.07.12.01";

     

       35
       35
       -
         buildId = "4934"; # IMPORTANT: This line is matched with regex in update.sh.

     

       36
       36
       -
         rev = "17634d29b91b737580c878ba96f73bd077fbfba0";

     

       34
       34
       +
         version = "25.07.23.01";

     

       35
       35
       +
         buildId = "4972"; # IMPORTANT: This line is matched with regex in update.sh.

     

       36
       36
       +
         rev = "2d4876fa93063df39ba8e2d6c97b57223f7b3b4f";

     

       37
       37
        
       in

     

       38
       38
        
       buildDotnetModule {

     

       39
       39
        
         pname = "olympus-unwrapped";

     
···

       44
       44
        
           owner = "EverestAPI";

     

       45
       45
        
           repo = "Olympus";

     

       46
       46
        
           fetchSubmodules = true; # Required. See upstream's README.

     

       47
       47
       -
           hash = "sha256-Z6OWO6WCHhmmGI8dF23yiLNBy11Mutu941jY/0pxIkQ=";

     

       47
       47
       +
           hash = "sha256-30Lir9erklCPIEsreIWwjrSkuZtr5mJpqxXAMXawYyk=";

     

       48
       48
        
         };

     

       49
       49
        
       

     

       50
       50
        
         nativeBuildInputs = [

+2 -2

pkgs/by-name/op/opengamepadui/package.nix

···

       23
       23
        
       

     

       24
       24
        
       stdenv.mkDerivation (finalAttrs: {

     

       25
       25
        
         pname = "opengamepadui";

     

       26
       26
       -
         version = "0.40.3";

     

       26
       26
       +
         version = "0.40.4";

     

       27
       27
        
       

     

       28
       28
        
         buildType = if withDebug then "debug" else "release";

     

       29
       29
        
       

     
···

       31
       31
        
           owner = "ShadowBlip";

     

       32
       32
        
           repo = "OpenGamepadUI";

     

       33
       33
        
           tag = "v${finalAttrs.version}";

     

       34
       34
       -
           hash = "sha256-ggCVNWh36q/clYMzObhhxU39qacWSb6urgXOI9yfQeo=";

     

       34
       34
       +
           hash = "sha256-o6n3b4dh3IHaRk2Zi7rt3gzKTZWt6s9L9WcG0WoCQ3U=";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
        
         cargoDeps = rustPlatform.fetchCargoVendor {

-15

pkgs/by-name/op/openimageio/2.nix

···

       1
       1
       -
       { fetchFromGitHub, openimageio }:

     

       2
       2
       -
       

     

       3
       3
       -
       let

     

       4
       4
       -
         version = "2.5.17.0";

     

       5
       5
       -
       in

     

       6
       6
       -
       openimageio.overrideAttrs {

     

       7
       7
       -
         inherit version;

     

       8
       8
       -
       

     

       9
       9
       -
         src = fetchFromGitHub {

     

       10
       10
       -
           owner = "AcademySoftwareFoundation";

     

       11
       11
       -
           repo = "OpenImageIO";

     

       12
       12
       -
           tag = "v${version}";

     

       13
       13
       -
           hash = "sha256-d5LqRcqWj6E9jJYY/Pa5e7/MeuQGMjUo/hMCYRKsKeU=";

     

       14
       14
       -
         };

     

       15
       15
       -
       }

+4 -13

pkgs/by-name/pc/pcsx2/package.nix

···

       15
       15
        
         libwebp,

     

       16
       16
        
         llvmPackages,

     

       17
       17
        
         lz4,

     

       18
       18
       -
         makeWrapper,

     

       19
       18
        
         pkg-config,

     

       20
       19
        
         qt6,

     

       21
       20
        
         shaderc,

     
···

       36
       35
        
         pcsx2_patches = fetchFromGitHub {

     

       37
       36
        
           owner = "PCSX2";

     

       38
       37
        
           repo = "pcsx2_patches";

     

       39
       39
       -
           rev = "6448ff90bbf2fddb4498dcfdae0e6d3ec8c23479";

     

       40
       40
       -
           hash = "sha256-ZXAZekllZHYjfU1q1QrbEdRlRAUAB6VOXLeAfn1GqW0=";

     

       38
       38
       +
           rev = "9b193aa0a61f5e93d3bd4124b111e8f296ef9fa8";

     

       39
       39
       +
           hash = "sha256-1hhdjFxJCNfeO/FIAnjRHESfiyzkErYddZqpRxzG7VQ=";

     

       41
       40
        
         };

     

       42
       41
        
       

     

       43
       42
        
         inherit (qt6)

     
···

       50
       49
        
       in

     

       51
       50
        
       llvmPackages.stdenv.mkDerivation (finalAttrs: {

     

       52
       51
        
         pname = "pcsx2";

     

       53
       53
       -
         version = "2.3.424";

     

       52
       52
       +
         version = "2.4.0";

     

       54
       53
        
         src = fetchFromGitHub {

     

       55
       54
        
           pname = "pcsx2-source";

     

       56
       55
        
           owner = "PCSX2";

     

       57
       56
        
           repo = "pcsx2";

     

       58
       57
        
           tag = "v${finalAttrs.version}";

     

       59
       59
       -
           hash = "sha256-EdFkSsat6O/1tXtJVHOPviseSaixd5LB1TNtfqhqR1E=";

     

       58
       58
       +
           hash = "sha256-R+BdywkZKxR/+Z+o1512O3A1mg9A6s7i+JZjFyUbJVs=";

     

       60
       59
        
         };

     

       61
       60
        
       

     

       62
       61
        
         patches = [

     
···

       132
       131
        
       

     

       133
       132
        
         preFixup = ''

     

       134
       133
        
           qtWrapperArgs+=("''${gappsWrapperArgs[@]}")

     

       135
       135
       -
         '';

     

       136
       136
       -
       

     

       137
       137
       -
         # https://github.com/PCSX2/pcsx2/pull/10200

     

       138
       138
       -
         # Can't avoid the double wrapping, the binary wrapper from qtWrapperArgs doesn't support --run

     

       139
       139
       -
         postFixup = ''

     

       140
       140
       -
           source "${makeWrapper}/nix-support/setup-hook"

     

       141
       141
       -
           wrapProgram $out/bin/pcsx2-qt \

     

       142
       142
       -
             --run 'if [[ -z $I_WANT_A_BROKEN_WAYLAND_UI ]]; then export QT_QPA_PLATFORM=xcb; fi'

     

       143
       134
        
         '';

     

       144
       135
        
       

     

       145
       136
        
         passthru = {

+8 -4

pkgs/by-name/pc/pcsx2/update.sh

···

       1
       1
        
       #!/usr/bin/env nix-shell

     

       2
       2
       -
       #!nix-shell -i bash -p bash nix-update common-updater-scripts coreutils

     

       2
       2
       +
       #!nix-shell -i bash -p bash nix-update common-updater-scripts coreutils jq

     

       3
       3
        
       

     

       4
       4
        
       set -ex

     

       5
       5
        
       

     

       6
       6
       -
       latestRev=`git ls-remote -b https://github.com/PCSX2/pcsx2_patches main | cut -f1`

     

       6
       6
       +
       latestPatchesRev=`git ls-remote -b https://github.com/PCSX2/pcsx2_patches main | cut -f1`

     

       7
       7
        
       

     

       8
       8
        
       update-source-version pcsx2 \

     

       9
       9
        
         --ignore-same-version \

     

       10
       10
       -
         --rev=$latestRev \

     

       10
       10
       +
         --rev=$latestPatchesRev \

     

       11
       11
        
         --source-key=pcsx2_patches

     

       12
       12
       -
       nix-update --version=unstable pcsx2

     

       12
       12
       +
       

     

       13
       13
       +
       latestVersion="`curl "https://api.github.com/repos/PCSX2/pcsx2/releases/latest" \

     

       14
       14
       +
         | jq -r ".tag_name[1:]"`"

     

       15
       15
       +
       

     

       16
       16
       +
       nix-update pcsx2 --version=$latestVersion

+3 -3

pkgs/by-name/pl/playwright-mcp/package.nix

···

       8
       8
        
       

     

       9
       9
        
       buildNpmPackage rec {

     

       10
       10
        
         pname = "playwright-mcp";

     

       11
       11
       -
         version = "0.0.29";

     

       11
       11
       +
         version = "0.0.31";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "Microsoft";

     

       15
       15
        
           repo = "playwright-mcp";

     

       16
       16
        
           tag = "v${version}";

     

       17
       17
       -
           hash = "sha256-owSoE3+jSg09dFpM5wv7FJovzsX5ZMp/9IIQhkmSZt0=";

     

       17
       17
       +
           hash = "sha256-Hw4OUZCHoquX6Ixv7GlsHcKxqOdJEQYfuDPzqYkVNAk=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         npmDepsHash = "sha256-jweIBhlVci8CFBIYlFp0opc1ilWMcHt0is4qgTiYNcQ=";

     

       20
       20
       +
         npmDepsHash = "sha256-70/t/mgSBwMv9C3VusbjIMMyy3e3npxQLXqKbdL9xa4=";

     

       21
       21
        
       

     

       22
       22
        
         postInstall = ''

     

       23
       23
        
           rm -r $out/lib/node_modules/@playwright/mcp/node_modules/playwright

+3 -3

pkgs/by-name/re/redpanda-client/package.nix

···

       7
       7
        
         stdenv,

     

       8
       8
        
       }:

     

       9
       9
        
       let

     

       10
       10
       -
         version = "25.1.7";

     

       10
       10
       +
         version = "25.1.9";

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "redpanda-data";

     

       13
       13
        
           repo = "redpanda";

     

       14
       14
        
           rev = "v${version}";

     

       15
       15
       -
           sha256 = "sha256-GRWLEzf0YfSk96oDCuthMNmu0C1KJCk10Uz7eApS4mk=";

     

       15
       15
       +
           sha256 = "sha256-X7pBbR2XCyHB4V0Z/PjZ10o/heXswyhzVj1yp+jvUEM=";

     

       16
       16
        
         };

     

       17
       17
        
       in

     

       18
       18
        
       buildGoModule rec {

     
···

       20
       20
        
         inherit doCheck src version;

     

       21
       21
        
         modRoot = "./src/go/rpk";

     

       22
       22
        
         runVend = false;

     

       23
       23
       -
         vendorHash = "sha256-DevAHiNcxSbgNwr2Jm7yXhNWflXvqWZOlaYHj+xY0Tw=";

     

       23
       23
       +
         vendorHash = "sha256-I/jUlOYUXOSmAD2r8lBlnEBYlxf+V6gSICgnMXosP+4=";

     

       24
       24
        
       

     

       25
       25
        
         ldflags = [

     

       26
       26
        
           ''-X "github.com/redpanda-data/redpanda/src/go/rpk/pkg/cli/cmd/version.version=${version}"''

+2 -2

pkgs/by-name/ro/robin-map/package.nix

···

       7
       7
        
       

     

       8
       8
        
       stdenv.mkDerivation rec {

     

       9
       9
        
         pname = "robin-map";

     

       10
       10
       -
         version = "1.3.0";

     

       10
       10
       +
         version = "1.4.0";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "Tessil";

     

       14
       14
        
           repo = "robin-map";

     

       15
       15
        
           tag = "v${version}";

     

       16
       16
       -
           hash = "sha256-dspOWp/8oNR0p5XRnqO7WtPcCx54/y8m1cDho4UBYyc=";

     

       16
       16
       +
           hash = "sha256-Hkgxiq2i0TuqMK/bI5OMOn3LkmSE40NimDjK1FBZpsA=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [

+2 -2

pkgs/by-name/sa/saga/package.nix

···

       33
       33
        
       

     

       34
       34
        
       stdenv.mkDerivation rec {

     

       35
       35
        
         pname = "saga";

     

       36
       36
       -
         version = "9.9.0";

     

       36
       36
       +
         version = "9.9.1";

     

       37
       37
        
       

     

       38
       38
        
         src = fetchurl {

     

       39
       39
        
           url = "mirror://sourceforge/saga-gis/saga-${version}.tar.gz";

     

       40
       40
       -
           hash = "sha256-xS9h8QGm6PH8rx0qXmvolDpH9fy8ma7HlBVbQo5pX4Q=";

     

       40
       40
       +
           hash = "sha256-InypyVCk08tsByKaIBRFWldwRz1AkNCgFD3DL4OG84w=";

     

       41
       41
        
         };

     

       42
       42
        
       

     

       43
       43
        
         sourceRoot = "saga-${version}/saga-gis";

+6 -2

pkgs/development/beam-modules/elixir-ls/launch.sh.patch

···

       1
       1
        
       diff --git c/scripts/launch.sh w/scripts/launch.sh

     

       2
       2
       -
       index 21afbb1e..6b61f0b4 100755

     

       2
       2
       +
       index 21afbb1e..8bc5c382 100755

     

       3
       3
        
       --- c/scripts/launch.sh

     

       4
       4
        
       +++ w/scripts/launch.sh

     

       5
       5
        
       @@ -1,125 +1,4 @@

     
···

       129
       129
        
        

     

       130
       130
        
        # In case that people want to tweak the path, which Elixir to use, or

     

       131
       131
        
        # whatever prior to launching the language server or the debug adapter, we

     

       132
       132
       -
       @@ -138,29 +17,18 @@ fi

     

       132
       132
       +
       @@ -138,29 +17,22 @@ fi

     

       133
       133
        
        # script so we can correctly configure the Erlang library path to

     

       134
       134
        
        # include the local .ez files, and then do what we were asked to do.

     

       135
       135
        
        

     
···

       165
       165
        
       +# ensure elixir stdlib can be found

     

       166
       166
        
       +ELX_STDLIB_PATH=${ELX_STDLIB_PATH:-@elixir@/lib/elixir}

     

       167
       167
        
       +export ELX_STDLIB_PATH

     

       168
       168
       +
       +

     

       169
       169
       +
       +# ensure our elixir is in the path

     

       170
       170
       +
       +PATH="@elixir@/bin:$PATH"

     

       171
       171
       +
       +export PATH

     

       168
       172
        
       +

     

       169
       173
        
       +source "$SCRIPTPATH/exec.bash"

+2 -2

pkgs/development/libraries/embree/2.x.nix

···

       7
       7
        
         ispc,

     

       8
       8
        
         tbb_2020,

     

       9
       9
        
         glfw,

     

       10
       10
       -
         openimageio_2,

     

       10
       10
       +
         openimageio,

     

       11
       11
        
         libjpeg,

     

       12
       12
        
         libpng,

     

       13
       13
        
         libpthreadstubs,

     
···

       38
       38
        
           # tbb_2021 is not backward compatible

     

       39
       39
        
           tbb_2020

     

       40
       40
        
           glfw

     

       41
       41
       -
           openimageio_2

     

       41
       41
       +
           openimageio

     

       42
       42
        
           libjpeg

     

       43
       43
        
           libpng

     

       44
       44
        
           libX11

pkgs/development/libraries/libinput/default.nix

···

       152
       152
        
           maintainers = with maintainers; [ codyopel ];

     

       153
       153
        
           teams = [ teams.freedesktop ];

     

       154
       154
        
           changelog = "https://gitlab.freedesktop.org/libinput/libinput/-/releases/${version}";

     

       155
       155
       +
           badPlatforms = [

     

       156
       156
       +
             # Mandatory shared library.

     

       157
       157
       +
             lib.systems.inspect.platformPatterns.isStatic

     

       158
       158
       +
           ];

     

       155
       159
        
         };

     

       156
       160
        
       }

+30 -6

pkgs/development/python-modules/imageio/default.nix

···

       4
       4
        
         buildPythonPackage,

     

       5
       5
        
         fetchFromGitHub,

     

       6
       6
        
         isPyPy,

     

       7
       7
       -
         replaceVars,

     

       8
       7
        
       

     

       9
       8
        
         # build-system

     

       10
       9
        
         setuptools,

     
···

       26
       25
        
       

     

       27
       26
        
         # tests

     

       28
       27
        
         pytestCheckHook,

     

       28
       28
       +
         gitMinimal,

     

       29
       29
        
         fsspec,

     

       30
       30
        
       }:

     

       31
       31
        
       

     

       32
       32
       +
       let

     

       33
       33
       +
         test_images = fetchFromGitHub {

     

       34
       34
       +
           owner = "imageio";

     

       35
       35
       +
           repo = "test_images";

     

       36
       36
       +
           rev = "f676c96b1af7e04bb1eed1e4551e058eb2f14acd";

     

       37
       37
       +
           leaveDotGit = true;

     

       38
       38
       +
           hash = "sha256-Kh8DowuhcCT5C04bE5yJa2C+efilLxP0AM31XjnHRf4=";

     

       39
       39
       +
         };

     

       40
       40
       +
         libgl = "${libGL.out}/lib/libGL${stdenv.hostPlatform.extensions.sharedLibrary}";

     

       41
       41
       +
       in

     

       42
       42
       +
       

     

       32
       43
        
       buildPythonPackage rec {

     

       33
       44
        
         pname = "imageio";

     

       34
       45
        
         version = "2.37.0";

     
···

       41
       52
        
           hash = "sha256-/nxJxZrTYX7F2grafIWwx9SyfR47ZXyaUwPHMEOdKkI=";

     

       42
       53
        
         };

     

       43
       54
        
       

     

       44
       44
       -
         patches = lib.optionals (!stdenv.hostPlatform.isDarwin) [

     

       45
       45
       -
           (replaceVars ./libgl-path.patch {

     

       46
       46
       -
             libgl = "${libGL.out}/lib/libGL${stdenv.hostPlatform.extensions.sharedLibrary}";

     

       47
       47
       -
           })

     

       48
       48
       -
         ];

     

       55
       55
       +
         postPatch = lib.optionalString (!stdenv.hostPlatform.isDarwin) ''

     

       56
       56
       +
           substituteInPlace tests/test_core.py \

     

       57
       57
       +
             --replace-fail 'ctypes.util.find_library("GL")' '"${libgl}"'

     

       58
       58
       +
         '';

     

       49
       59
        
       

     

       50
       60
        
         build-system = [ setuptools ];

     

       51
       61
        
       

     
···

       77
       87
        
       

     

       78
       88
        
         nativeCheckInputs = [

     

       79
       89
        
           fsspec

     

       90
       90
       +
           gitMinimal

     

       80
       91
        
           psutil

     

       81
       92
        
           pytestCheckHook

     

       82
       93
        
         ]

     

       83
       94
        
         ++ fsspec.optional-dependencies.github

     

       84
       95
        
         ++ lib.flatten (builtins.attrValues optional-dependencies);

     

       85
       96
        
       

     

       97
       97
       +
         pytestFlags = [ "--test-images=file://${test_images}" ];

     

       98
       98
       +
       

     

       99
       99
       +
         # These should have had `needs_internet` mark applied but don't so far.

     

       100
       100
       +
         # See https://github.com/imageio/imageio/pull/1142

     

       101
       101
       +
         disabledTests = [

     

       102
       102
       +
           "test_read_stream"

     

       103
       103
       +
           "test_uri_reading"

     

       104
       104
       +
           "test_trim_filter"

     

       105
       105
       +
         ];

     

       106
       106
       +
       

     

       86
       107
        
         disabledTestMarks = [ "needs_internet" ];

     

       108
       108
       +
       

     

       109
       109
       +
         # These tests require the old and vulnerable freeimage binaries; skip.

     

       110
       110
       +
         disabledTestPaths = [ "tests/test_freeimage.py" ];

     

       87
       111
        
       

     

       88
       112
        
         preCheck = ''

     

       89
       113
        
           export IMAGEIO_USERDIR=$(mktemp -d)

-13

pkgs/development/python-modules/imageio/libgl-path.patch

···

       1
       1
       -
       diff --git a/tests/test_core.py b/tests/test_core.py

     

       2
       2
       -
       index 2cdbb3a..032974c 100644

     

       3
       3
       -
       --- a/tests/test_core.py

     

       4
       4
       -
       +++ b/tests/test_core.py

     

       5
       5
       -
       @@ -129,7 +129,7 @@ def test_findlib2():

     

       6
       6
       -
            open(os.path.join(fi_dir, "notalib.test.so"), "wb")

     

       7
       7
       -
        

     

       8
       8
       -
            # Loading libs

     

       9
       9
       -
       -    gllib = ctypes.util.find_library("GL")

     

       10
       10
       -
       +    gllib = "@libgl@"

     

       11
       11
       -
            core.load_lib([gllib], [])

     

       12
       12
       -
            # Fail

     

       13
       13
       -
            raises(ValueError, core.load_lib, [], [])  # Nothing given

+5 -13

pkgs/development/python-modules/materialx/default.nix

···

       8
       8
        
         libX11,

     

       9
       9
        
         libXt,

     

       10
       10
        
         libGL,

     

       11
       11
       -
         openimageio_2,

     

       11
       11
       +
         openimageio,

     

       12
       12
        
         imath,

     

       13
       13
        
         python,

     

       14
       14
        
         apple-sdk_14,

     
···

       16
       16
        
       

     

       17
       17
        
       buildPythonPackage rec {

     

       18
       18
        
         pname = "materialx";

     

       19
       19
       -
         version = "1.38.10";

     

       19
       19
       +
         version = "1.39.3";

     

       20
       20
        
       

     

       21
       21
       -
         # nixpkgs-update: no auto update

     

       22
       22
       -
         # Updates are disabled due to API breakage in 1.39+ that breaks almost all

     

       23
       23
       -
         # consumers.

     

       24
       21
        
         src = fetchFromGitHub {

     

       25
       22
        
           owner = "AcademySoftwareFoundation";

     

       26
       23
        
           repo = "MaterialX";

     

       27
       24
        
           rev = "v${version}";

     

       28
       28
       -
           hash = "sha256-/kMHmW2dptZNtjuhE5s+jvPRIdtY+FRiVtMU+tiBgQo=";

     

       25
       25
       +
           hash = "sha256-ceVYD/dyb3SEEENoJZxjn94DGmUj6IYSNLjsJvmPM84=";

     

       29
       26
        
         };

     

       30
       27
        
       

     

       31
       28
        
         format = "other";

     
···

       36
       33
        
         ];

     

       37
       34
        
       

     

       38
       35
        
         buildInputs = [

     

       39
       39
       -
           openimageio_2

     

       36
       36
       +
           openimageio

     

       40
       37
        
           imath

     

       41
       38
        
         ]

     

       42
       39
        
         ++ lib.optionals stdenv.hostPlatform.isDarwin [

     
···

       50
       47
        
       

     

       51
       48
        
         cmakeFlags = [

     

       52
       49
        
           (lib.cmakeBool "MATERIALX_BUILD_OIIO" true)

     

       50
       50
       +
           (lib.cmakeBool "MATERIALX_BUILD_SHARED_LIBS" true)

     

       53
       51
        
           (lib.cmakeBool "MATERIALX_BUILD_PYTHON" true)

     

       54
       52
        
           (lib.cmakeBool "MATERIALX_BUILD_GEN_MSL" (

     

       55
       53
        
             stdenv.hostPlatform.isLinux || stdenv.hostPlatform.isDarwin

     
···

       65
       63
        
           # required for cmake to find the bindings, when included in other projects

     

       66
       64
        
           ln -s $out/python $target_dir

     

       67
       65
        
         '';

     

       68
       68
       -
       

     

       69
       69
       -
         # Update to 1.39 has major API changes and downstream software

     

       70
       70
       -
         # needs to adapt, first. So, do not include in mass updates. For reference, see

     

       71
       71
       -
         # https://github.com/NixOS/nixpkgs/pull/326466#issuecomment-2293029160

     

       72
       72
       -
         # and https://github.com/NixOS/nixpkgs/issues/380230

     

       73
       73
       -
         passthru.skipBulkUpdate = true;

     

       74
       66
        
       

     

       75
       67
        
         meta = {

     

       76
       68
        
           changelog = "https://github.com/AcademySoftwareFoundation/MaterialX/blob/${src.rev}/CHANGELOG.md";

+2 -2

pkgs/development/python-modules/playwright/default.nix

···

       22
       22
        
       buildPythonPackage rec {

     

       23
       23
        
         pname = "playwright";

     

       24
       24
        
         # run ./pkgs/development/python-modules/playwright/update.sh to update

     

       25
       25
       -
         version = "1.53.0";

     

       25
       25
       +
         version = "1.54.0";

     

       26
       26
        
         pyproject = true;

     

       27
       27
        
         disabled = pythonOlder "3.9";

     

       28
       28
        
       

     
···

       30
       30
        
           owner = "microsoft";

     

       31
       31
        
           repo = "playwright-python";

     

       32
       32
        
           tag = "v${version}";

     

       33
       33
       -
           hash = "sha256-jFS2Luq/9mRsXZ65H3VLw+sTBplVNVy/yZYrpF5Hc0M=";

     

       33
       33
       +
           hash = "sha256-xyuofDL0hWL8Gn4sYNLKte8q/4bMo+3aSbYaf5iWiBk=";

     

       34
       34
        
         };

     

       35
       35
        
       

     

       36
       36
        
         patches = [

+17 -1

pkgs/development/python-modules/playwright/update.sh

···

       22
       22
        
       temp_dir=$(mktemp -d)

     

       23
       23
        
       trap 'rm -rf "$temp_dir"' EXIT

     

       24
       24
        
       

     

       25
       25
       +
       # Update playwright-mcp package

     

       26
       26
       +
       mcp_version=$(curl ${GITHUB_TOKEN:+" -u \":$GITHUB_TOKEN\""} -s https://api.github.com/repos/microsoft/playwright-mcp/releases/latest | jq -r '.tag_name | sub("^v"; "")')

     

       27
       27
       +
       update-source-version playwright-mcp "$mcp_version"

     

       28
       28
       +
       

     

       29
       29
       +
       # Update npmDepsHash for playwright-mcp

     

       30
       30
       +
       pushd "$temp_dir" >/dev/null

     

       31
       31
       +
       curl -fsSL -o package-lock.json "https://raw.githubusercontent.com/microsoft/playwright-mcp/v${mcp_version}/package-lock.json"

     

       32
       32
       +
       mcp_npm_hash=$(prefetch-npm-deps package-lock.json)

     

       33
       33
       +
       rm -f package-lock.json

     

       34
       34
       +
       popd >/dev/null

     

       35
       35
       +
       

     

       36
       36
       +
       mcp_package_file="$root/../../../by-name/pl/playwright-mcp/package.nix"

     

       37
       37
       +
       sed -E 's#\bnpmDepsHash = ".*?"#npmDepsHash = "'"$mcp_npm_hash"'"#' -i "$mcp_package_file"

     

       25
       38
        
       

     

       26
       39
        
       

     

       27
       40
        
       # update binaries of browsers, used by playwright.

     
···

       47
       60
        
               fi

     

       48
       61
        
           else

     

       49
       62
        
               if [ "$name" = "ffmpeg" ] || [ "$name" = "chromium-headless-shell" ]; then

     

       63
       63
       +
                   suffix="linux"

     

       64
       64
       +
               elif [ "$name" = "chromium" ]; then

     

       65
       65
       +
                   stripRoot="true"

     

       50
       66
        
                   suffix="linux"

     

       51
       67
        
               elif [ "$name" = "firefox" ]; then

     

       52
       68
        
                   stripRoot="true"

     
···

       81
       97
        
             )

     

       82
       98
        
           ' > "$playwright_dir/browsers.json"

     

       83
       99
        
       

     

       84
       84
       -
       # We currently use Chromium from nixpkgs, so we don't need to download it here

     

       100
       100
       +
       update_browser "chromium" "linux"

     

       85
       101
        
       update_browser "chromium-headless-shell" "linux"

     

       86
       102
        
       update_browser "firefox" "linux"

     

       87
       103
        
       update_browser "webkit" "linux"

+8 -8

pkgs/development/web/playwright/browsers.json

···

       2
       2
        
         "comment": "This file is kept up to date via update.sh",

     

       3
       3
        
         "browsers": {

     

       4
       4
        
           "chromium": {

     

       5
       5
       -
             "revision": "1179",

     

       6
       6
       -
             "browserVersion": "138.0.7204.23"

     

       5
       5
       +
             "revision": "1181",

     

       6
       6
       +
             "browserVersion": "139.0.7258.5"

     

       7
       7
        
           },

     

       8
       8
        
           "chromium-headless-shell": {

     

       9
       9
       -
             "revision": "1179",

     

       10
       10
       -
             "browserVersion": "138.0.7204.23"

     

       9
       9
       +
             "revision": "1181",

     

       10
       10
       +
             "browserVersion": "139.0.7258.5"

     

       11
       11
        
           },

     

       12
       12
        
           "firefox": {

     

       13
       13
       -
             "revision": "1488",

     

       14
       14
       -
             "browserVersion": "139.0"

     

       13
       13
       +
             "revision": "1489",

     

       14
       14
       +
             "browserVersion": "140.0.2"

     

       15
       15
        
           },

     

       16
       16
        
           "webkit": {

     

       17
       17
       -
             "revision": "2182",

     

       17
       17
       +
             "revision": "2191",

     

       18
       18
        
             "revisionOverrides": {

     

       19
       19
        
               "debian11-x64": "2105",

     

       20
       20
        
               "debian11-arm64": "2105",

     
···

       29
       29
        
               "ubuntu20.04-x64": "2092",

     

       30
       30
        
               "ubuntu20.04-arm64": "2092"

     

       31
       31
        
             },

     

       32
       32
       -
             "browserVersion": "18.5"

     

       32
       32
       +
             "browserVersion": "26.0"

     

       33
       33
        
           },

     

       34
       34
        
           "ffmpeg": {

     

       35
       35
        
             "revision": "1011",

+4 -4

pkgs/development/web/playwright/chromium-headless-shell.nix

···

       30
       30
        
             stripRoot = false;

     

       31
       31
        
             hash =

     

       32
       32
        
               {

     

       33
       33
       -
                 x86_64-linux = "sha256-C545VC0RxFYfKf8XArfVoI2yzrGyfR7vxjryJHfcfBQ=";

     

       34
       34
       -
                 aarch64-linux = "sha256-i+HVf/6Qz2nCLLzPxbRYVFjDDOhd5ETYuHje5YsmsAo=";

     

       33
       33
       +
                 x86_64-linux = "sha256-AYh2urKZdjXCELimYaFihWp0FbDLf4uRrKLJZVxug5M=";

     

       34
       34
       +
                 aarch64-linux = "sha256-diBiy0z51BxGK0PcfQOf1aryUcZesKu/UHBSZUjqwMk=";

     

       35
       35
        
               }

     

       36
       36
        
               .${system} or throwSystem;

     

       37
       37
        
           };

     
···

       66
       66
        
           stripRoot = false;

     

       67
       67
        
           hash =

     

       68
       68
        
             {

     

       69
       69
       -
               x86_64-darwin = "sha256-2pe1LS3WXRG/V2k/BNN1MmOOdGoA0WCFhUpZW8TUhic=";

     

       70
       70
       -
               aarch64-darwin = "sha256-U07QnHFPQXyO3VGWfZvcP8cJEmVJAJ7imj+6DQlN9vQ=";

     

       69
       69
       +
               x86_64-darwin = "sha256-vIJuDjkasUYlMW0aCOyztyrlh5kvcwNR9GBaoa/yh/M=";

     

       70
       70
       +
               aarch64-darwin = "sha256-6Q6nz0H2749srdMF/puk/gnG1gQBEnWe9cQO3owL2OU=";

     

       71
       71
        
             }

     

       72
       72
        
             .${system} or throwSystem;

     

       73
       73
        
         };

+4 -4

pkgs/development/web/playwright/chromium.nix

···

       41
       41
        
             url = "https://playwright.azureedge.net/builds/chromium/${revision}/chromium-${suffix}.zip";

     

       42
       42
        
             hash =

     

       43
       43
        
               {

     

       44
       44
       -
                 x86_64-linux = "sha256-7oQQCAIt1VJiMNFEJO40K8oENK/L0BICXm2D/3fZ8bA=";

     

       45
       45
       -
                 aarch64-linux = "sha256-1OmByLX2jNHXAzWdXF8Od7S7pj/jl4wwvOQcsZc5R7o=";

     

       44
       44
       +
                 x86_64-linux = "sha256-R7nMCVpUqgRwtB0syhfIK81maiTVWr8lYBLp4bR8VBg=";

     

       45
       45
       +
                 aarch64-linux = "sha256-4fc4X7QwBigktmEeseuqIyEeV70Dy3eO/femXrftMd0=";

     

       46
       46
        
               }

     

       47
       47
        
               .${system} or throwSystem;

     

       48
       48
        
           };

     
···

       109
       109
        
           stripRoot = false;

     

       110
       110
        
           hash =

     

       111
       111
        
             {

     

       112
       112
       -
               x86_64-darwin = "sha256-KOoCbygsZZzGNKD8ICcGg0iM2h0HVgXq0I4JMPaUJR8=";

     

       113
       113
       -
               aarch64-darwin = "sha256-2naFzKWmo6el+AqljzILO+hUq/E2g81Dt1fwq79EYO8=";

     

       112
       112
       +
               x86_64-darwin = "sha256-0u1AStbUTX+qgUmg2DvL59B4b265WywDaBV+MdSuaNE=";

     

       113
       113
       +
               aarch64-darwin = "sha256-4pg4wmNTF8mw+APmdpvYlFxb9zc6OUh11oW5gCRKETY=";

     

       114
       114
        
             }

     

       115
       115
        
             .${system} or throwSystem;

     

       116
       116
        
         };

+4 -4

pkgs/development/web/playwright/driver.nix

···

       27
       27
        
           }

     

       28
       28
        
           .${system} or throwSystem;

     

       29
       29
        
       

     

       30
       30
       -
         version = "1.53.1";

     

       30
       30
       +
         version = "1.54.1";

     

       31
       31
        
       

     

       32
       32
        
         src = fetchFromGitHub {

     

       33
       33
        
           owner = "Microsoft";

     

       34
       34
        
           repo = "playwright";

     

       35
       35
        
           rev = "v${version}";

     

       36
       36
       -
           hash = "sha256-N5BS8zpoQGUf5gly0fyutaK76CAhbwOGAUofGnfkmnM=";

     

       36
       36
       +
           hash = "sha256-xwyREgelHLkpbUXOZTppKK7L6dE4jx0d/lbDWSKGzTY=";

     

       37
       37
        
         };

     

       38
       38
        
       

     

       39
       39
        
         babel-bundle = buildNpmPackage {

     
···

       70
       70
        
           pname = "utils-bundle-core";

     

       71
       71
        
           inherit version src;

     

       72
       72
        
           sourceRoot = "${src.name}/packages/playwright-core/bundles/utils";

     

       73
       73
       -
           npmDepsHash = "sha256-3hdOmvs/IGAgW7vhldms9Q9/ZQfbjbc+xP+JEtGJ7g8=";

     

       73
       73
       +
           npmDepsHash = "sha256-gEm2oTxj4QIiGnIOPffOLh3BYSngpGToF89ObnDYBqs=";

     

       74
       74
        
           dontNpmBuild = true;

     

       75
       75
        
           installPhase = ''

     

       76
       76
        
             cp -r . "$out"

     
···

       92
       92
        
           inherit version src;

     

       93
       93
        
       

     

       94
       94
        
           sourceRoot = "${src.name}"; # update.sh depends on sourceRoot presence

     

       95
       95
       -
           npmDepsHash = "sha256-a1s1l8PG0ViVqYOksB2dkID/AHczMjLNQJW88+yB0B0=";

     

       95
       95
       +
           npmDepsHash = "sha256-4bsX8Q8V3CBpIsyqMYTzfERQQPY5zlPf7CoqR6UkUHU=";

     

       96
       96
        
       

     

       97
       97
        
           nativeBuildInputs = [

     

       98
       98
        
             cacert

+4 -4

pkgs/development/web/playwright/firefox.nix

···

       17
       17
        
             }.zip";

     

       18
       18
        
             hash =

     

       19
       19
        
               {

     

       20
       20
       -
                 x86_64-linux = "sha256-L9bIldFCqZ/jnNKkJk6nS0HNaJefzTMQIJ6VLUE9ugc=";

     

       21
       21
       -
                 aarch64-linux = "sha256-iuiS59f8j3K+grBU7ZtZPfU4r2Dp7s0JJHf2n/4r30U=";

     

       20
       20
       +
                 x86_64-linux = "sha256-j7gOuXMyftNQencgfpk8Y4ED2LuT7TAa30IPyzmir48=";

     

       21
       21
       +
                 aarch64-linux = "sha256-deIUGKBrp56TsDr61cbNbRRSRcVpSoa6pdmMk4oB/Eg=";

     

       22
       22
        
               }

     

       23
       23
        
               .${system} or throwSystem;

     

       24
       24
        
           };

     
···

       41
       41
        
           stripRoot = false;

     

       42
       42
        
           hash =

     

       43
       43
        
             {

     

       44
       44
       -
               x86_64-darwin = "sha256-K0eW1kC1tckJu0crD89hDhK8PHyQUB0YUYN9DdX0HKw=";

     

       45
       45
       -
               aarch64-darwin = "sha256-n1Uy59r6wxmung8QKvw3JeyF3ec/avCVp9fI+bck/iA=";

     

       44
       44
       +
               x86_64-darwin = "sha256-ljgFoyqCg9kma2cDFodNjbkAeEylIzVdWkS1vU/9Rbg=";

     

       45
       45
       +
               aarch64-darwin = "sha256-W2J5APPWEkmoDgBEox6/ygg2xyWpOHZESXFG0tZbj1M=";

     

       46
       46
        
             }

     

       47
       47
        
             .${system} or throwSystem;

     

       48
       48
        
         };

+9 -5

pkgs/development/web/playwright/webkit.nix

···

       102
       102
        
                 hash = "sha256-X4fbYTMS+kHfZRbeGzSdBW5jQKw8UN44FEyFRUtw0qo=";

     

       103
       103
        
               })

     

       104
       104
        
             ];

     

       105
       105
       -
             postPatch = "";

     

       105
       105
       +
             postPatch = ''

     

       106
       106
       +
               # Fix multiple definition errors by using C++17 instead of C++11

     

       107
       107
       +
               substituteInPlace CMakeLists.txt \

     

       108
       108
       +
                 --replace "set(CMAKE_CXX_STANDARD 11)" "set(CMAKE_CXX_STANDARD 17)"

     

       109
       109
       +
             '';

     

       106
       110
        
             postInstall = "";

     

       107
       111
        
       

     

       108
       112
        
             cmakeFlags = [

     
···

       125
       129
        
             stripRoot = false;

     

       126
       130
        
             hash =

     

       127
       131
        
               {

     

       128
       128
       -
                 x86_64-linux = "sha256-lwH783B3/laqw0IdGBnVzvySRoF0AwZsSolaqUKmsM4=";

     

       129
       129
       -
                 aarch64-linux = "sha256-qtvP0bc5rcZcz6SqigfdrjhTWEmvT4k11I1GW1Eoj/Q=";

     

       132
       132
       +
                 x86_64-linux = "sha256-OSVHFGdcQrzmhLPdXF61tKmip/6/D+uaQgSBBQiOIZI=";

     

       133
       133
       +
                 aarch64-linux = "sha256-b8XwVMCwSbujyqgkJKIPAVNX83Qmmsthprr2x9XSb10=";

     

       130
       134
        
               }

     

       131
       135
        
               .${system} or throwSystem;

     

       132
       136
        
           };

     
···

       206
       210
        
           stripRoot = false;

     

       207
       211
        
           hash =

     

       208
       212
        
             {

     

       209
       209
       -
               x86_64-darwin = "sha256-p1+Pk+Zhf2OPEmEWCEd0tA7CdoMcOgYp69SnQXufFJ0=";

     

       210
       210
       -
               aarch64-darwin = "sha256-tEfKvJuGe4htZLSOn94eKeBtWXYkjl73iJSY4BWJMKo=";

     

       213
       213
       +
               x86_64-darwin = "sha256-shjhozJS2VbBjpjJVlM9hwBzGWwgva1qhfEUhY8t9Bk=";

     

       214
       214
       +
               aarch64-darwin = "sha256-ZRl86L/OOTNPWfZDl6JQfuXL41kI/Wir99/JIbf7T7M=";

     

       211
       215
        
             }

     

       212
       216
        
             .${system} or throwSystem;

     

       213
       217
        
         };

+6 -6

pkgs/top-level/aliases.nix

···

       766
       766
        
         gcj6 = throw "gcj6 has been removed from Nixpkgs, as it is unmaintained and obsolete"; # Added 2024-09-13

     

       767
       767
        
         gcolor2 = throw "'gcolor2' has been removed due to lack of maintenance upstream and depending on gtk2. Consider using 'gcolor3' or 'eyedropper' instead"; # Added 2024-09-15

     

       768
       768
        
         gdome2 = throw "'gdome2' has been removed from nixpkgs, as it is umaintained and obsolete"; # Added 2024-12-29

     

       769
       769
       -
         geocode-glib = "throw 'geocode-glib' has been removed, as it was unused and used outdated libraries"; # Added 2025-04-16

     

       769
       769
       +
         geocode-glib = throw "throw 'geocode-glib' has been removed, as it was unused and used outdated libraries"; # Added 2025-04-16

     

       770
       770
        
         geos_3_11 = throw "geos_3_11 has been removed from nixpgks. Please use a more recent 'geos' instead.";

     

       771
       771
        
         gfbgraph = throw "'gfbgraph' has been removed as it was archived upstream and unused in nixpkgs"; # Added 2025-04-20

     

       772
       772
        
         gfortran48 = throw "'gfortran48' has been removed from nixpkgs"; # Added 2024-09-10

     
···

       893
       893
        
         gsignond = throw "'gsignond' and its plugins have been removed due to lack of maintenance upstream"; # added 2025-04-17

     

       894
       894
        
         gsignondPlugins = throw "'gsignondPlugins' have been removed alongside 'gsignond' due to lack of maintenance upstream and depending on libsoup_2"; # added 2025-04-17

     

       895
       895
        
         gtetrinet = throw "'gtetrinet' has been removed because it depends on GNOME 2 libraries"; # Added 2024-06-27

     

       896
       896
       -
         gtk-engine-bluecurve = "'gtk-engine-bluecurve' has been removed as it has been archived upstream."; # Added 2024-12-04

     

       896
       896
       +
         gtk-engine-bluecurve = throw "'gtk-engine-bluecurve' has been removed as it has been archived upstream."; # Added 2024-12-04

     

       897
       897
        
         gtk2fontsel = throw "'gtk2fontsel' has been removed due to lack of maintenance upstream. GTK now has a built-in font chooser so it's no longer needed for newer apps"; # Added 2024-10-19

     

       898
       898
        
         gtkcord4 = dissent; # Added 2024-03-10

     

       899
       899
        
         gtkextra = throw "'gtkextra' has been removed due to lack of maintenance upstream."; # Added 2025-06-10

     
···

       1810
       1810
        
         schildichat-desktop = schildichat-web;

     

       1811
       1811
        
         schildichat-desktop-wayland = schildichat-web;

     

       1812
       1812
        
         scitoken-cpp = scitokens-cpp; # Added 2024-02-12

     

       1813
       1813
       -
         scry = "'scry' has been removed as it was archived upstream. Use 'crystalline' instead"; # Added 2025-02-12

     

       1813
       1813
       +
         scry = throw "'scry' has been removed as it was archived upstream. Use 'crystalline' instead"; # Added 2025-02-12

     

       1814
       1814
        
         semeru-bin-16 = throw "Semeru 16 has been removed as it has reached its end of life"; # Added 2024-08-01

     

       1815
       1815
        
         semeru-jre-bin-16 = throw "Semeru 16 has been removed as it has reached its end of life"; # Added 2024-08-01

     

       1816
       1816
        
         sensu = throw "sensu has been removed as the upstream project is deprecated. Consider using `sensu-go`"; # Added 2024-10-28

     
···

       1996
       1996
        
         timelens = throw "'timelens' has been removed due to lack of upstream maintenance"; # Added 2025-01-25

     

       1997
       1997
        
         tix = tclPackages.tix; # Added 2024-10-02

     

       1998
       1998
        
         tkcvs = tkrev; # Added 2022-03-07

     

       1999
       1999
       -
         tkgate = "'tkgate' has been removed as it is unmaintained"; # Added 2025-05-17

     

       1999
       1999
       +
         tkgate = throw "'tkgate' has been removed as it is unmaintained"; # Added 2025-05-17

     

       2000
       2000
        
         tkimg = tclPackages.tkimg; # Added 2024-10-02

     

       2001
       2001
       -
         todiff = "'todiff' was removed due to lack of known users"; # Added 2025-01-25

     

       2001
       2001
       +
         todiff = throw "'todiff' was removed due to lack of known users"; # Added 2025-01-25

     

       2002
       2002
        
         toil = throw "toil was removed as it was broken and requires obsolete versions of libraries"; # Added 2024-09-22

     

       2003
       2003
        
         tokodon = plasma5Packages.tokodon;

     

       2004
       2004
        
         tokyo-night-gtk = tokyonight-gtk-theme; # Added 2024-01-28

     
···

       2049
       2049
        
         ubootBeagleboneBlack = throw "'ubootBeagleboneBlack' has been renamed to/replaced by 'ubootAmx335xEVM'"; # Converted to throw 2024-10-17

     

       2050
       2050
        
         ubuntu_font_family = ubuntu-classic; # Added 2024-02-19

     

       2051
       2051
        
         uclibc = uclibc-ng; # Added 2022-06-16

     

       2052
       2052
       -
         unicap = "'unicap' has been removed because it is unmaintained"; # Added 2025-05-17

     

       2052
       2052
       +
         unicap = throw "'unicap' has been removed because it is unmaintained"; # Added 2025-05-17

     

       2053
       2053
        
         unicorn-emu = throw "'unicorn-emu' has been renamed to/replaced by 'unicorn'"; # Converted to throw 2024-10-17

     

       2054
       2054
        
         uniffi-bindgen = throw "uniffi-bindgen has been removed since upstream no longer provides a standalone package for the CLI";

     

       2055
       2055
        
         unifi-poller = unpoller; # Added 2022-11-24

-2

pkgs/top-level/all-packages.nix

···

       13331
       13331
        
           inherit (darwin) DarwinTools;

     

       13332
       13332
        
         };

     

       13333
       13333
        
       

     

       13334
       13334
       -
         openimageio_2 = callPackage ../by-name/op/openimageio/2.nix { };

     

       13335
       13335
       -
       

     

       13336
       13334
        
         open-music-kontrollers = lib.recurseIntoAttrs {

     

       13337
       13335
        
           eteroj = callPackage ../applications/audio/open-music-kontrollers/eteroj.nix { };

     

       13338
       13336
        
           jit = callPackage ../applications/audio/open-music-kontrollers/jit.nix { };