commit 0a4c03ed81dc80e0ab71410ed488c8308d43e8dc · pyrox.dev/nixpkgs

+10

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

···

       211
       211
        
           services.nextcloud.phpOptions."realpath_cache_size" = "0";

     

       212
       212
        
           ```

     

       213
       213
        
       

     

       214
       214
       +
         - **Empty Files on chunked uploads**

     

       215
       215
       +
       

     

       216
       216
       +
           Due to a limitation of PHP-FPM, Nextcloud is unable to handle chunked

     

       217
       217
       +
           uploads. See upstream issue

     

       218
       218
       +
           [nextcloud/server#7995](https://github.com/nextcloud/server/issues/7995)

     

       219
       219
       +
           for details.

     

       220
       220
       +
       

     

       221
       221
       +
           A workaround is to disable chunked uploads with

     

       222
       222
       +
           {option}`nextcloud.nginx.enableFastcgiRequestBuffering`.

     

       223
       223
       +
       

     

       214
       224
        
       ## Using an alternative webserver as reverse-proxy (e.g. `httpd`) {#module-services-nextcloud-httpd}

     

       215
       225
        
       

     

       216
       226
        
       By default, `nginx` is used as reverse-proxy for `nextcloud`.

+18 -1

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

···

       986
       986
        
                 directive and header.

     

       987
       987
        
               '';

     

       988
       988
        
             };

     

       989
       989
       +
             enableFastcgiRequestBuffering = mkOption {

     

       990
       990
       +
               type = types.bool;

     

       991
       991
       +
               default = false;

     

       992
       992
       +
               description = ''

     

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

     

       994
       994
       +
                 for `PUT` requests with the `Transfer-Encoding: chunked` header set and

     

       995
       995
       +
                 an unspecified `Content-Length`. Without request buffering for these requests,

     

       996
       996
       +
                 Nextcloud will create files with zero bytes length as described in

     

       997
       997
       +
                 [nextcloud/server#7995](https://github.com/nextcloud/server/issues/7995).

     

       998
       998
       +
       

     

       999
       999
       +
                 ::: {.note}

     

       1000
       1000
       +
                 Please keep in mind that upstream suggests to not enable this as it might

     

       1001
       1001
       +
                 lead to timeouts on large files being uploaded as described in the

     

       1002
       1002
       +
                 [administrator manual](https://docs.nextcloud.com/server/latest/admin_manual/configuration_files/big_file_upload_configuration.html#nginx).

     

       1003
       1003
       +
                 :::

     

       1004
       1004
       +
               '';

     

       1005
       1005
       +
             };

     

       989
       1006
        
           };

     

       990
       1007
        
       

     

       991
       1008
        
           cli.memoryLimit = mkOption {

     
···

       1476
       1493
        
                     fastcgi_param front_controller_active true;

     

       1477
       1494
        
                     fastcgi_pass unix:${fpm.socket};

     

       1478
       1495
        
                     fastcgi_intercept_errors on;

     

       1479
       1479
       -
                     fastcgi_request_buffering off;

     

       1496
       1496
       +
                     fastcgi_request_buffering ${if cfg.nginx.enableFastcgiRequestBuffering then "on" else "off"};

     

       1480
       1497
        
                     fastcgi_read_timeout ${builtins.toString cfg.fastcgiTimeout}s;

     

       1481
       1498
        
                   '';

     

       1482
       1499
        
                 };

+13

nixos/tests/nextcloud/basic.nix

···

       62
       62
        
                     startAt = "20:00";

     

       63
       63
        
                   };

     

       64
       64
        
                   phpExtraExtensions = all: [ all.bz2 ];

     

       65
       65
       +
                   nginx.enableFastcgiRequestBuffering = true;

     

       65
       66
        
                 };

     

       66
       67
        
       

     

       67
       68
        
                 specialisation.withoutMagick.configuration = {

     
···

       90
       91
        
               nexcloudWithImagick = findInClosure "imagick" nodes.nextcloud.system.build.vm;

     

       91
       92
        
               nextcloudWithoutImagick = findInClosure "imagick" nodes.nextcloud.specialisation.withoutMagick.configuration.system.build.vm;

     

       92
       93
        
             in

     

       94
       94
       +
             # python

     

       93
       95
        
             ''

     

       94
       96
        
               with subtest("File is in proper nextcloud home"):

     

       95
       97
        
                   nextcloud.succeed("test -f ${nodes.nextcloud.services.nextcloud.datadir}/data/root/files/test-shared-file")

     
···

       103
       105
        
       

     

       104
       106
        
               with subtest("Ensure SSE is disabled by default"):

     

       105
       107
        
                   nextcloud.succeed("grep -vE '^HBEGIN:oc_encryption_module' /var/lib/nextcloud-data/data/root/files/test-shared-file")

     

       108
       108
       +
       

     

       109
       109
       +
               with subtest("Create non-empty files with Transfer-Encoding: chunked"):

     

       110
       110
       +
                   client.succeed(

     

       111
       111
       +
                     'dd if=/dev/urandom of=testfile.bin bs=1M count=10',

     

       112
       112
       +
                     'curl --fail -v -X PUT --header "Transfer-Encoding: chunked" --data-binary @testfile.bin "http://nextcloud/remote.php/webdav/testfile.bin" -u ${config.adminuser}:${config.adminpass}',

     

       113
       113
       +
                   )

     

       114
       114
       +
       

     

       115
       115
       +
                   # Verify the local and remote copies of the file are identical.

     

       116
       116
       +
                   client_hash = client.succeed("nix-hash testfile.bin").strip()

     

       117
       117
       +
                   nextcloud_hash = nextcloud.succeed("nix-hash /var/lib/nextcloud-data/data/root/files/testfile.bin").strip()

     

       118
       118
       +
                   t.assertEqual(client_hash, nextcloud_hash)

     

       106
       119
        
             '';

     

       107
       120
        
         }

     

       108
       121
        
       )