commit 6355c63f9f49434a98f7549aec152f2611a701c2 · pyrox.dev/nixpkgs

nixos/doc/manual/release-notes/rl-2505.section.md

···

       342
       342
        
       

     

       343
       343
        
       - `bind.cacheNetworks` now only controls access for recursive queries, where it previously controlled access for all queries.

     

       344
       344
        
       

     

       345
       345
       +
       - The paperless module now has an option for regular automatic export of

     

       346
       346
       +
         documents data using the integrated document exporter.

     

       347
       347
       +
       

     

       345
       348
        
       - Caddy can now be built with plugins by using `caddy.withPlugins`, a `passthru` function that accepts an attribute set as a parameter. The `plugins` argument represents a list of Caddy plugins, with each Caddy plugin being a versioned module. The `hash` argument represents the `vendorHash` of the resulting Caddy source code with the plugins added.

     

       346
       349
        
       

     

       347
       350
        
         Example:

+72 -4

nixos/modules/services/misc/paperless.nix

···

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

     

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

     

       2
       2
        
       let

     

       3
       3
        
         cfg = config.services.paperless;

     

       4
       4
        
       

     
···

       82
       82
        
         };

     

       83
       83
        
       in

     

       84
       84
        
       {

     

       85
       85
       -
         meta.maintainers = with lib.maintainers; [ leona SuperSandro2000 erikarvstedt ];

     

       85
       85
       +
         meta.maintainers = with lib.maintainers; [ leona SuperSandro2000 erikarvstedt atemu theuni ];

     

       86
       86
        
       

     

       87
       87
        
         imports = [

     

       88
       88
        
           (lib.mkRenamedOptionModule [ "services" "paperless-ng" ] [ "services" "paperless" ])

     
···

       252
       252
        
               '';

     

       253
       253
        
             };

     

       254
       254
        
           };

     

       255
       255
       +
       

     

       256
       256
       +
           exporter = {

     

       257
       257
       +
             enable = lib.mkEnableOption "regular automatic document exports";

     

       258
       258
       +
       

     

       259
       259
       +
             directory = lib.mkOption {

     

       260
       260
       +
               type = lib.types.str;

     

       261
       261
       +
               default = cfg.dataDir + "/export";

     

       262
       262
       +
               defaultText = "\${dataDir}/export";

     

       263
       263
       +
               description = "Directory to store export.";

     

       264
       264
       +
             };

     

       265
       265
       +
       

     

       266
       266
       +
             onCalendar = lib.mkOption {

     

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

     

       268
       268
       +
               default = "01:30:00";

     

       269
       269
       +
               description = ''

     

       270
       270
       +
                 When to run the exporter. See {manpage}`systemd.time(7)`.

     

       271
       271
       +
       

     

       272
       272
       +
                 `null` disables the timer; allowing you to run the

     

       273
       273
       +
                 `paperless-exporter` service through other means.

     

       274
       274
       +
               '';

     

       275
       275
       +
             };

     

       276
       276
       +
       

     

       277
       277
       +
             settings = lib.mkOption {

     

       278
       278
       +
               type = with lib.types; attrsOf anything;

     

       279
       279
       +
               default = {

     

       280
       280
       +
                 "no-progress-bar" = true;

     

       281
       281
       +
                 "no-color" = true;

     

       282
       282
       +
                 "compare-checksums" = true;

     

       283
       283
       +
                 "delete" = true;

     

       284
       284
       +
               };

     

       285
       285
       +
               description = "Settings to pass to the document exporter as CLI arguments.";

     

       286
       286
       +
             };

     

       287
       287
       +
           };

     

       255
       288
        
         };

     

       256
       289
        
       

     

       257
       257
       -
         config = lib.mkIf cfg.enable {

     

       290
       290
       +
         config = lib.mkIf cfg.enable (lib.mkMerge [ {

     

       258
       291
        
           services.redis.servers.paperless.enable = lib.mkIf enableRedis true;

     

       259
       292
        
       

     

       260
       293
        
           services.postgresql = lib.mkIf cfg.database.createLocally {

     
···

       439
       472
        
               gid = config.ids.gids.paperless;

     

       440
       473
        
             };

     

       441
       474
        
           };

     

       442
       442
       -
         };

     

       475
       475
       +
         }

     

       476
       476
       +
       

     

       477
       477
       +
         (lib.mkIf cfg.exporter.enable {

     

       478
       478
       +
           systemd.tmpfiles.rules = [

     

       479
       479
       +
             "d '${cfg.exporter.directory}' - ${cfg.user} ${config.users.users.${cfg.user}.group} - -"

     

       480
       480
       +
           ];

     

       481
       481
       +
       

     

       482
       482
       +
           services.paperless.exporter.settings = options.services.paperless.exporter.settings.default;

     

       483
       483
       +
       

     

       484
       484
       +
           systemd.services.paperless-exporter = {

     

       485
       485
       +
             startAt = lib.defaultTo [] cfg.exporter.onCalendar;

     

       486
       486
       +
             serviceConfig = {

     

       487
       487
       +
               User = cfg.user;

     

       488
       488
       +
               WorkingDirectory = cfg.dataDir;

     

       489
       489
       +
             };

     

       490
       490
       +
             unitConfig = let

     

       491
       491
       +
               services = [

     

       492
       492
       +
                 "paperless-consumer.service"

     

       493
       493
       +
                 "paperless-scheduler.service"

     

       494
       494
       +
                 "paperless-task-queue.service"

     

       495
       495
       +
                 "paperless-web.service" ];

     

       496
       496
       +
             in {

     

       497
       497
       +
               # Shut down the paperless services while the exporter runs

     

       498
       498
       +
               Conflicts = services;

     

       499
       499
       +
               After = services;

     

       500
       500
       +
               # Bring them back up afterwards, regardless of pass/fail

     

       501
       501
       +
               OnFailure = services;

     

       502
       502
       +
               OnSuccess = services;

     

       503
       503
       +
             };

     

       504
       504
       +
             enableStrictShellChecks = true;

     

       505
       505
       +
             script = ''

     

       506
       506
       +
               ./paperless-manage document_exporter ${cfg.exporter.directory} ${lib.cli.toGNUCommandLineShell {} cfg.exporter.settings}

     

       507
       507
       +
             '';

     

       508
       508
       +
           };

     

       509
       509
       +
         })

     

       510
       510
       +
         ]);

     

       443
       511
        
       }

+28

nixos/tests/paperless.nix

···

       8
       8
        
             services.paperless = {

     

       9
       9
        
               enable = true;

     

       10
       10
        
               passwordFile = builtins.toFile "password" "admin";

     

       11
       11
       +
       

     

       12
       12
       +
               exporter = {

     

       13
       13
       +
                 enable = true;

     

       14
       14
       +
       

     

       15
       15
       +
                 settings = {

     

       16
       16
       +
                   "no-color" = lib.mkForce false; # override a default option

     

       17
       17
       +
                   "no-thumbnail" = true; # add a new option

     

       18
       18
       +
                 };

     

       19
       19
       +
               };

     

       11
       20
        
             };

     

       12
       21
        
           };

     

       13
       22
        
           postgres = { config, pkgs, ... }: {

     
···

       72
       81
        
       

     

       73
       82
        
               metadata = json.loads(node.succeed("curl -u admin:admin -fs localhost:28981/api/documents/3/metadata/"))

     

       74
       83
        
               assert "original_checksum" in metadata

     

       84
       84
       +
       

     

       85
       85
       +
             with subtest("Exporter"):

     

       86
       86
       +
                 node.succeed("systemctl start --wait paperless-exporter")

     

       87
       87
       +
                 node.wait_for_unit("paperless-web.service")

     

       88
       88
       +
                 node.wait_for_unit("paperless-consumer.service")

     

       89
       89
       +
                 node.wait_for_unit("paperless-scheduler.service")

     

       90
       90
       +
                 node.wait_for_unit("paperless-task-queue.service")

     

       91
       91
       +
       

     

       92
       92
       +
                 node.succeed("ls -lah /var/lib/paperless/export/manifest.json")

     

       93
       93
       +
       

     

       94
       94
       +
                 timers = node.succeed("systemctl list-timers paperless-exporter")

     

       95
       95
       +
                 print(timers)

     

       96
       96
       +
                 assert "paperless-exporter.timer paperless-exporter.service" in timers, "missing timer"

     

       97
       97
       +
                 assert "1 timers listed." in timers, "incorrect number of timers"

     

       98
       98
       +
       

     

       99
       99
       +
                 # Double check that our attrset option override works as expected

     

       100
       100
       +
                 cmdline = node.succeed("grep 'paperless-manage' $(systemctl cat paperless-exporter | grep ExecStart | cut -f 2 -d=)")

     

       101
       101
       +
                 print(f"Exporter command line {cmdline!r}")

     

       102
       102
       +
                 assert cmdline.strip() == "./paperless-manage document_exporter /var/lib/paperless/export --compare-checksums --delete --no-progress-bar --no-thumbnail", "Unexpected exporter command line"

     

       75
       103
        
       

     

       76
       104
        
           test_paperless(simple)

     

       77
       105
        
           simple.send_monitor_command("quit")