commit 1db2175e7ab291b64590076dcad16354bdf6a6e3 · pyrox.dev/nixpkgs

+15

nixos/doc/manual/from_md/release-notes/rl-2305.section.xml

···

       409
       409
        
             </listitem>

     

       410
       410
        
             <listitem>

     

       411
       411
        
               <para>

     

       412
       412
       +
                 <link xlink:href="https://garagehq.deuxfleurs.fr/">Garage</link>

     

       413
       413
       +
                 version is based on

     

       414
       414
       +
                 <link xlink:href="options.html#opt-system.stateVersion">system.stateVersion</link>,

     

       415
       415
       +
                 existing installations will keep using version 0.7. New

     

       416
       416
       +
                 installations will use version 0.8. In order to upgrade a

     

       417
       417
       +
                 Garage cluster, please follow

     

       418
       418
       +
                 <link xlink:href="https://garagehq.deuxfleurs.fr/documentation/cookbook/upgrading/">upstream

     

       419
       419
       +
                 instructions</link> and force

     

       420
       420
       +
                 <link xlink:href="options.html#opt-services.garage.package">services.garage.package</link>

     

       421
       421
       +
                 or upgrade accordingly

     

       422
       422
       +
                 <link xlink:href="options.html#opt-system.stateVersion">system.stateVersion</link>.

     

       423
       423
       +
               </para>

     

       424
       424
       +
             </listitem>

     

       425
       425
       +
             <listitem>

     

       426
       426
       +
               <para>

     

       412
       427
        
                 Resilio sync secret keys can now be provided using a secrets

     

       413
       428
        
                 file at runtime, preventing these secrets from ending up in

     

       414
       429
        
                 the Nix store.

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

···

       111
       111
        
       

     

       112
       112
        
       - A new option `recommendedBrotliSettings` has been added to `services.nginx`. Learn more about compression in Brotli format [here](https://github.com/google/ngx_brotli/blob/master/README.md).

     

       113
       113
        
       

     

       114
       114
       +
       - [Garage](https://garagehq.deuxfleurs.fr/) version is based on [system.stateVersion](options.html#opt-system.stateVersion), existing installations will keep using version 0.7. New installations will use version 0.8. In order to upgrade a Garage cluster, please follow [upstream instructions](https://garagehq.deuxfleurs.fr/documentation/cookbook/upgrading/) and force [services.garage.package](options.html#opt-services.garage.package) or upgrade accordingly [system.stateVersion](options.html#opt-system.stateVersion).

     

       115
       115
       +
       

     

       114
       116
        
       - Resilio sync secret keys can now be provided using a secrets file at runtime, preventing these secrets from ending up in the Nix store.

     

       115
       117
        
       

     

       116
       118
        
       - The `firewall` and `nat` module now has a nftables based implementation. Enable `networking.nftables` to use it.

+139

nixos/modules/services/web-servers/garage-doc.xml

···

       1
       1
       +
       <chapter xmlns="http://docbook.org/ns/docbook"

     

       2
       2
       +
                xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       3
       +
                xmlns:xi="http://www.w3.org/2001/XInclude"

     

       4
       4
       +
                version="5.0"

     

       5
       5
       +
                xml:id="module-services-garage">

     

       6
       6
       +
        <title>Garage</title>

     

       7
       7
       +
        <para>

     

       8
       8
       +
         <link xlink:href="https://garagehq.deuxfleurs.fr/">Garage</link>

     

       9
       9
       +
         is an open-source, self-hostable S3 store, simpler than MinIO, for geodistributed stores.

     

       10
       10
       +
         The server setup can be automated using

     

       11
       11
       +
         <link linkend="opt-services.garage.enable">services.garage</link>. A

     

       12
       12
       +
          client configured to your local Garage instance is available in

     

       13
       13
       +
          the global environment as <literal>garage-manage</literal>.

     

       14
       14
       +
        </para>

     

       15
       15
       +
        <para>

     

       16
       16
       +
         The current default by NixOS is <package>garage_0_8</package> which is also the latest

     

       17
       17
       +
         major version available.

     

       18
       18
       +
        </para>

     

       19
       19
       +
        <section xml:id="module-services-garage-upgrade-scenarios">

     

       20
       20
       +
         <title>General considerations on upgrades</title>

     

       21
       21
       +
       

     

       22
       22
       +
         <para>

     

       23
       23
       +
           Garage provides a cookbook documentation on how to upgrade:

     

       24
       24
       +
          <link xlink:href="https://garagehq.deuxfleurs.fr/documentation/cookbook/upgrading/">https://garagehq.deuxfleurs.fr/documentation/cookbook/upgrading/</link>

     

       25
       25
       +
         </para>

     

       26
       26
       +
       

     

       27
       27
       +
        <warning>

     

       28
       28
       +
          <para>Garage has two types of upgrades: patch-level upgrades and minor/major version upgrades.</para>

     

       29
       29
       +
       

     

       30
       30
       +
          <para>In all cases, you should read the changelog and ideally test the upgrade on a staging cluster.</para>

     

       31
       31
       +
       

     

       32
       32
       +
          <para>Checking the health of your cluster can be achieved using <literal>garage-manage repair</literal>.</para>

     

       33
       33
       +
         </warning>

     

       34
       34
       +
       

     

       35
       35
       +
       

     

       36
       36
       +
        <warning>

     

       37
       37
       +
          <para>Until 1.0 is released, patch-level upgrades are considered as minor version upgrades.

     

       38
       38
       +
          Minor version upgrades are considered as major version upgrades.

     

       39
       39
       +
           i.e. 0.6 to 0.7 is a major version upgrade.</para>

     

       40
       40
       +
        </warning>

     

       41
       41
       +
       

     

       42
       42
       +
        <itemizedlist>

     

       43
       43
       +
         <listitem>

     

       44
       44
       +
          <formalpara>

     

       45
       45
       +
           <title>Straightforward upgrades (patch-level upgrades)</title>

     

       46
       46
       +
           <para>

     

       47
       47
       +
            Upgrades must be performed one by one, i.e. for each node, stop it, upgrade it : change <link linkend="opt-system.stateVersion">stateVersion</link> or <link linkend="opt-services.garage.package">services.garage.package</link>, restart it if it was not already by switching.

     

       48
       48
       +
           </para>

     

       49
       49
       +
          </formalpara>

     

       50
       50
       +
         </listitem>

     

       51
       51
       +
       

     

       52
       52
       +
         <listitem>

     

       53
       53
       +
          <formalpara>

     

       54
       54
       +
           <title>Multiple version upgrades</title>

     

       55
       55
       +
           <para>

     

       56
       56
       +
            Garage do not provide any guarantee on moving more than one major-version forward.

     

       57
       57
       +
            E.g., if you're on <literal>0.7</literal>, you cannot upgrade to <literal>0.9</literal>.

     

       58
       58
       +
            You need to upgrade to <literal>0.8</literal> first.

     

       59
       59
       +
       

     

       60
       60
       +
            As long as <link linkend="opt-system.stateVersion">stateVersion</link> is declared properly,

     

       61
       61
       +
            this is enforced automatically. The module will issue a warning to remind the user to upgrade to latest

     

       62
       62
       +
            Garage <emphasis>after</emphasis> that deploy.

     

       63
       63
       +
          </para>

     

       64
       64
       +
         </formalpara>

     

       65
       65
       +
        </listitem>

     

       66
       66
       +
       </itemizedlist>

     

       67
       67
       +
       </section>

     

       68
       68
       +
       

     

       69
       69
       +
       <section xml:id="module-services-garage-advanced-upgrades">

     

       70
       70
       +
        <title>Advanced upgrades (minor/major version upgrades)</title>

     

       71
       71
       +
        <para>Here are some baseline instructions to handle advanced upgrades in Garage, when in doubt, please refer to upstream instructions.</para>

     

       72
       72
       +
       

     

       73
       73
       +
        <itemizedlist>

     

       74
       74
       +
          <listitem><para>Disable API and web access to Garage.</para></listitem>

     

       75
       75
       +
          <listitem><para>Perform <literal>garage-manage repair --all-nodes --yes tables</literal> and <literal>garage-manage repair --all-nodes --yes blocks</literal>.</para></listitem>

     

       76
       76
       +
          <listitem><para>Verify the resulting logs and check that data is synced properly between all nodes.

     

       77
       77
       +
           If you have time, do additional checks (<literal>scrub</literal>, <literal>block_refs</literal>, etc.).</para></listitem>

     

       78
       78
       +
          <listitem><para>Check if queues are empty by <literal>garage-manage stats</literal> or through monitoring tools.</para></listitem>

     

       79
       79
       +
          <listitem><para>Run <literal>systemctl stop garage</literal> to stop the actual Garage version.</para></listitem>

     

       80
       80
       +
          <listitem><para>Backup the metadata folder of ALL your nodes, e.g. for a metadata directory (the default one) in <literal>/var/lib/garage/meta</literal>,

     

       81
       81
       +
           you can run <literal>pushd /var/lib/garage; tar -acf meta-v0.7.tar.zst meta/; popd</literal>.</para></listitem>

     

       82
       82
       +
          <listitem><para>Run the offline migration: <literal>nix-shell -p garage_0_8 --run "garage offline-repair --yes"</literal>, this can take some time depending on how many objects are stored in your cluster.</para></listitem>

     

       83
       83
       +
          <listitem><para>Bump Garage version in your NixOS configuration, either by changing <link linkend="opt-system.stateVersion">stateVersion</link> or bumping <link linkend="opt-services.garage.package">services.garage.package</link>, this should restart Garage automatically.</para></listitem>

     

       84
       84
       +
          <listitem><para>Perform <literal>garage-manage repair --all-nodes --yes tables</literal> and <literal>garage-manage repair --all-nodes --yes blocks</literal>.</para></listitem>

     

       85
       85
       +
          <listitem><para>Wait for a full table sync to run.</para></listitem>

     

       86
       86
       +
        </itemizedlist>

     

       87
       87
       +
       

     

       88
       88
       +
        <para>

     

       89
       89
       +
          Your upgraded cluster should be in a working state, re-enable API and web access.

     

       90
       90
       +
        </para>

     

       91
       91
       +
       </section>

     

       92
       92
       +
       

     

       93
       93
       +
       <section xml:id="module-services-garage-maintainer-info">

     

       94
       94
       +
         <title>Maintainer information</title>

     

       95
       95
       +
       

     

       96
       96
       +
         <para>

     

       97
       97
       +
          As stated in the previous paragraph, we must provide a clean upgrade-path for Garage

     

       98
       98
       +
          since it cannot move more than one major version forward on a single upgrade. This chapter

     

       99
       99
       +
          adds some notes how Garage updates should be rolled out in the future.

     

       100
       100
       +
       

     

       101
       101
       +
          This is inspired from how Nextcloud does it.

     

       102
       102
       +
         </para>

     

       103
       103
       +
       

     

       104
       104
       +
         <para>

     

       105
       105
       +
          While patch-level updates are no problem and can be done directly in the

     

       106
       106
       +
          package-expression (and should be backported to supported stable branches after that),

     

       107
       107
       +
          major-releases should be added in a new attribute (e.g. Garage <literal>v0.8.0</literal>

     

       108
       108
       +
          should be available in <literal>nixpkgs</literal> as <literal>pkgs.garage_0_8_0</literal>).

     

       109
       109
       +
          To provide simple upgrade paths it's generally useful to backport those as well to stable

     

       110
       110
       +
          branches. As long as the package-default isn't altered, this won't break existing setups.

     

       111
       111
       +
          After that, the versioning-warning in the <literal>garage</literal>-module should be

     

       112
       112
       +
          updated to make sure that the

     

       113
       113
       +
          <link linkend="opt-services.garage.package">package</link>-option selects the latest version

     

       114
       114
       +
          on fresh setups.

     

       115
       115
       +
         </para>

     

       116
       116
       +
       

     

       117
       117
       +
         <para>

     

       118
       118
       +
          If major-releases will be abandoned by upstream, we should check first if those are needed

     

       119
       119
       +
          in NixOS for a safe upgrade-path before removing those. In that case we shold keep those

     

       120
       120
       +
          packages, but mark them as insecure in an expression like this (in

     

       121
       121
       +
          <literal>&lt;nixpkgs/pkgs/tools/filesystem/garage/default.nix&gt;</literal>):

     

       122
       122
       +
       <programlisting>/* ... */

     

       123
       123
       +
       {

     

       124
       124
       +
         garage_0_7_3 = generic {

     

       125
       125
       +
           version = "0.7.3";

     

       126
       126
       +
           sha256 = "0000000000000000000000000000000000000000000000000000";

     

       127
       127
       +
           eol = true;

     

       128
       128
       +
         };

     

       129
       129
       +
       }</programlisting>

     

       130
       130
       +
         </para>

     

       131
       131
       +
       

     

       132
       132
       +
         <para>

     

       133
       133
       +
          Ideally we should make sure that it's possible to jump two NixOS versions forward:

     

       134
       134
       +
          i.e. the warnings and the logic in the module should guard a user to upgrade from a

     

       135
       135
       +
          Garage on e.g. 22.11 to a Garage on 23.11.

     

       136
       136
       +
         </para>

     

       137
       137
       +
        </section>

     

       138
       138
       +
       

     

       139
       139
       +
       </chapter>

+9 -4

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

···

       8
       8
        
         configFile = toml.generate "garage.toml" cfg.settings;

     

       9
       9
        
       in

     

       10
       10
        
       {

     

       11
       11
       -
         meta.maintainers = [ maintainers.raitobezarius ];

     

       11
       11
       +
         meta = {

     

       12
       12
       +
           doc = ./garage-doc.xml;

     

       13
       13
       +
           maintainers = with pkgs.lib.maintainers; [ raitobezarius ];

     

       14
       14
       +
         };

     

       12
       15
        
       

     

       13
       16
        
         options.services.garage = {

     

       14
       17
        
           enable = mkEnableOption (lib.mdDoc "Garage Object Storage (S3 compatible)");

     
···

       56
       59
        
           };

     

       57
       60
        
       

     

       58
       61
        
           package = mkOption {

     

       59
       59
       -
             default = pkgs.garage;

     

       60
       60
       -
             defaultText = literalExpression "pkgs.garage";

     

       62
       62
       +
             # TODO: when 23.05 is released and if Garage 0.9 is the default, put a stateVersion check.

     

       63
       63
       +
             default = if versionAtLeast stateVersion "23.05" then pkgs.garage_0_8_0

     

       64
       64
       +
                       else pkgs.garage_0_7;

     

       65
       65
       +
             defaultText = literalExpression "pkgs.garage_0_7";

     

       61
       66
        
             type = types.package;

     

       62
       62
       -
             description = lib.mdDoc "Garage package to use.";

     

       67
       67
       +
             description = lib.mdDoc "Garage package to use, if you are upgrading from a major version, please read NixOS and Garage release notes for upgrade instructions.";

     

       63
       68
        
           };

     

       64
       69
        
         };

     

       65
       70

+1 -1

nixos/tests/all-tests.nix

···

       229
       229
        
         fsck = handleTest ./fsck.nix {};

     

       230
       230
        
         ft2-clone = handleTest ./ft2-clone.nix {};

     

       231
       231
        
         mimir = handleTest ./mimir.nix {};

     

       232
       232
       -
         garage = handleTest ./garage.nix {};

     

       232
       232
       +
         garage = handleTest ./garage {};

     

       233
       233
        
         gerrit = handleTest ./gerrit.nix {};

     

       234
       234
        
         geth = handleTest ./geth.nix {};

     

       235
       235
        
         ghostunnel = handleTest ./ghostunnel.nix {};

+5 -53

nixos/tests/garage.nix nixos/tests/garage/with-3node-replication.nix

···

       1
       1
       -
       import ./make-test-python.nix ({ pkgs, ...} :

     

       2
       2
       -
       let

     

       3
       3
       -
           mkNode = { replicationMode, publicV6Address ? "::1" }: { pkgs, ... }: {

     

       4
       4
       -
             networking.interfaces.eth1.ipv6.addresses = [{

     

       5
       5
       -
               address = publicV6Address;

     

       6
       6
       -
               prefixLength = 64;

     

       7
       7
       -
             }];

     

       8
       8
       -
       

     

       9
       9
       -
             networking.firewall.allowedTCPPorts = [ 3901 3902 ];

     

       10
       10
       -
       

     

       11
       11
       -
             services.garage = {

     

       12
       12
       -
               enable = true;

     

       13
       13
       -
               settings = {

     

       14
       14
       -
                 replication_mode = replicationMode;

     

       15
       15
       -
       

     

       16
       16
       -
                 rpc_bind_addr = "[::]:3901";

     

       17
       17
       -
                 rpc_public_addr = "[${publicV6Address}]:3901";

     

       18
       18
       -
                 rpc_secret = "5c1915fa04d0b6739675c61bf5907eb0fe3d9c69850c83820f51b4d25d13868c";

     

       19
       19
       -
       

     

       20
       20
       -
                 s3_api = {

     

       21
       21
       -
                   s3_region = "garage";

     

       22
       22
       -
                   api_bind_addr = "[::]:3900";

     

       23
       23
       -
                   root_domain = ".s3.garage";

     

       24
       24
       -
                 };

     

       25
       25
       -
       

     

       26
       26
       -
                 s3_web = {

     

       27
       27
       -
                   bind_addr = "[::]:3902";

     

       28
       28
       -
                   root_domain = ".web.garage";

     

       29
       29
       -
                   index = "index.html";

     

       30
       30
       -
                 };

     

       31
       31
       -
               };

     

       32
       32
       -
             };

     

       33
       33
       -
             environment.systemPackages = [ pkgs.minio-client ];

     

       34
       34
       -
       

     

       35
       35
       -
             # Garage requires at least 1GiB of free disk space to run.

     

       36
       36
       -
             virtualisation.diskSize = 2 * 1024;

     

       37
       37
       -
           };

     

       38
       38
       -
       

     

       39
       39
       -
       

     

       40
       40
       -
       in {

     

       41
       41
       -
         name = "garage";

     

       1
       1
       +
       args@{ mkNode, ... }:

     

       2
       2
       +
       (import ../make-test-python.nix ({ pkgs, ...} :

     

       3
       3
       +
       {

     

       4
       4
       +
         name = "garage-3node-replication";

     

       42
       5
        
         meta = {

     

       43
       6
        
           maintainers = with pkgs.lib.maintainers; [ raitobezarius ];

     

       44
       7
        
         };

     

       45
       8
        
       

     

       46
       9
        
         nodes = {

     

       47
       47
       -
           single_node = mkNode { replicationMode = "none"; };

     

       48
       10
        
           node1 = mkNode { replicationMode = 3; publicV6Address = "fc00:1::1"; };

     

       49
       11
        
           node2 = mkNode { replicationMode = 3; publicV6Address = "fc00:1::2"; };

     

       50
       12
        
           node3 = mkNode { replicationMode = 3; publicV6Address = "fc00:1::3"; };

     
···

       126
       88
        
             node.succeed(f'echo hello world | mc pipe test-garage/{bucket}/index.html')

     

       127
       89
        
             assert (node.succeed(f"curl -H 'Host: {url}' http://localhost:3902")).strip() == 'hello world'

     

       128
       90
        
       

     

       129
       129
       -
           with subtest("Garage works as a single-node S3 storage"):

     

       130
       130
       -
             single_node.wait_for_unit("garage.service")

     

       131
       131
       -
             single_node.wait_for_open_port(3900)

     

       132
       132
       -
             # Now Garage is initialized.

     

       133
       133
       -
             single_node_id = get_node_id(single_node)

     

       134
       134
       -
             apply_garage_layout(single_node, [f'-z qemutest -c 1 "{single_node_id}"'])

     

       135
       135
       -
             # Now Garage is operational.

     

       136
       136
       -
             test_bucket_writes(single_node)

     

       137
       137
       -
             test_bucket_over_http(single_node)

     

       138
       138
       -
       

     

       139
       91
        
           with subtest("Garage works as a multi-node S3 storage"):

     

       140
       92
        
             nodes = ('node1', 'node2', 'node3', 'node4')

     

       141
       93
        
             rev_machines = {m.name: m for m in machines}

     
···

       166
       118
        
             for node in nodes:

     

       167
       119
        
                test_bucket_over_http(get_machine(node))

     

       168
       120
        
         '';

     

       169
       169
       -
       })

     

       121
       121
       +
       })) args

+98

nixos/tests/garage/basic.nix

···

       1
       1
       +
       args@{ mkNode, ... }:

     

       2
       2
       +
       (import ../make-test-python.nix ({ pkgs, ...} : {

     

       3
       3
       +
         name = "garage-basic";

     

       4
       4
       +
         meta = {

     

       5
       5
       +
           maintainers = with pkgs.lib.maintainers; [ raitobezarius ];

     

       6
       6
       +
         };

     

       7
       7
       +
       

     

       8
       8
       +
         nodes = {

     

       9
       9
       +
           single_node = mkNode { replicationMode = "none"; };

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         testScript = ''

     

       13
       13
       +
           from typing import List

     

       14
       14
       +
           from dataclasses import dataclass

     

       15
       15
       +
           import re

     

       16
       16
       +
       

     

       17
       17
       +
           start_all()

     

       18
       18
       +
       

     

       19
       19
       +
           cur_version_regex = re.compile('Current cluster layout version: (?P<ver>\d*)')

     

       20
       20
       +
           key_creation_regex = re.compile('Key name: (?P<key_name>.*)\nKey ID: (?P<key_id>.*)\nSecret key: (?P<secret_key>.*)')

     

       21
       21
       +
       

     

       22
       22
       +
           @dataclass

     

       23
       23
       +
           class S3Key:

     

       24
       24
       +
              key_name: str

     

       25
       25
       +
              key_id: str

     

       26
       26
       +
              secret_key: str

     

       27
       27
       +
       

     

       28
       28
       +
           @dataclass

     

       29
       29
       +
           class GarageNode:

     

       30
       30
       +
              node_id: str

     

       31
       31
       +
              host: str

     

       32
       32
       +
       

     

       33
       33
       +
           def get_node_fqn(machine: Machine) -> GarageNode:

     

       34
       34
       +
             node_id, host = machine.succeed("garage node id").split('@')

     

       35
       35
       +
             return GarageNode(node_id=node_id, host=host)

     

       36
       36
       +
       

     

       37
       37
       +
           def get_node_id(machine: Machine) -> str:

     

       38
       38
       +
             return get_node_fqn(machine).node_id

     

       39
       39
       +
       

     

       40
       40
       +
           def get_layout_version(machine: Machine) -> int:

     

       41
       41
       +
             version_data = machine.succeed("garage layout show")

     

       42
       42
       +
             m = cur_version_regex.search(version_data)

     

       43
       43
       +
             if m and m.group('ver') is not None:

     

       44
       44
       +
               return int(m.group('ver')) + 1

     

       45
       45
       +
             else:

     

       46
       46
       +
               raise ValueError('Cannot find current layout version')

     

       47
       47
       +
       

     

       48
       48
       +
           def apply_garage_layout(machine: Machine, layouts: List[str]):

     

       49
       49
       +
              for layout in layouts:

     

       50
       50
       +
                 machine.succeed(f"garage layout assign {layout}")

     

       51
       51
       +
              version = get_layout_version(machine)

     

       52
       52
       +
              machine.succeed(f"garage layout apply --version {version}")

     

       53
       53
       +
       

     

       54
       54
       +
           def create_api_key(machine: Machine, key_name: str) -> S3Key:

     

       55
       55
       +
              output = machine.succeed(f"garage key new --name {key_name}")

     

       56
       56
       +
              m = key_creation_regex.match(output)

     

       57
       57
       +
              if not m or not m.group('key_id') or not m.group('secret_key'):

     

       58
       58
       +
                 raise ValueError('Cannot parse API key data')

     

       59
       59
       +
              return S3Key(key_name=key_name, key_id=m.group('key_id'), secret_key=m.group('secret_key'))

     

       60
       60
       +
       

     

       61
       61
       +
           def get_api_key(machine: Machine, key_pattern: str) -> S3Key:

     

       62
       62
       +
              output = machine.succeed(f"garage key info {key_pattern}")

     

       63
       63
       +
              m = key_creation_regex.match(output)

     

       64
       64
       +
              if not m or not m.group('key_name') or not m.group('key_id') or not m.group('secret_key'):

     

       65
       65
       +
                  raise ValueError('Cannot parse API key data')

     

       66
       66
       +
              return S3Key(key_name=m.group('key_name'), key_id=m.group('key_id'), secret_key=m.group('secret_key'))

     

       67
       67
       +
       

     

       68
       68
       +
           def test_bucket_writes(node):

     

       69
       69
       +
             node.succeed("garage bucket create test-bucket")

     

       70
       70
       +
             s3_key = create_api_key(node, "test-api-key")

     

       71
       71
       +
             node.succeed("garage bucket allow --read --write test-bucket --key test-api-key")

     

       72
       72
       +
             other_s3_key = get_api_key(node, 'test-api-key')

     

       73
       73
       +
             assert other_s3_key.secret_key == other_s3_key.secret_key

     

       74
       74
       +
             node.succeed(

     

       75
       75
       +
               f"mc alias set test-garage http://[::1]:3900 {s3_key.key_id} {s3_key.secret_key} --api S3v4"

     

       76
       76
       +
             )

     

       77
       77
       +
             node.succeed("echo test | mc pipe test-garage/test-bucket/test.txt")

     

       78
       78
       +
             assert node.succeed("mc cat test-garage/test-bucket/test.txt").strip() == "test"

     

       79
       79
       +
       

     

       80
       80
       +
           def test_bucket_over_http(node, bucket='test-bucket', url=None):

     

       81
       81
       +
             if url is None:

     

       82
       82
       +
                url = f"{bucket}.web.garage"

     

       83
       83
       +
       

     

       84
       84
       +
             node.succeed(f'garage bucket website --allow {bucket}')

     

       85
       85
       +
             node.succeed(f'echo hello world | mc pipe test-garage/{bucket}/index.html')

     

       86
       86
       +
             assert (node.succeed(f"curl -H 'Host: {url}' http://localhost:3902")).strip() == 'hello world'

     

       87
       87
       +
       

     

       88
       88
       +
           with subtest("Garage works as a single-node S3 storage"):

     

       89
       89
       +
             single_node.wait_for_unit("garage.service")

     

       90
       90
       +
             single_node.wait_for_open_port(3900)

     

       91
       91
       +
             # Now Garage is initialized.

     

       92
       92
       +
             single_node_id = get_node_id(single_node)

     

       93
       93
       +
             apply_garage_layout(single_node, [f'-z qemutest -c 1 "{single_node_id}"'])

     

       94
       94
       +
             # Now Garage is operational.

     

       95
       95
       +
             test_bucket_writes(single_node)

     

       96
       96
       +
             test_bucket_over_http(single_node)

     

       97
       97
       +
         '';

     

       98
       98
       +
       })) args

+54

nixos/tests/garage/default.nix

···

       1
       1
       +
       { system ? builtins.currentSystem

     

       2
       2
       +
       , config ? { }

     

       3
       3
       +
       , pkgs ? import ../../.. { inherit system config; }

     

       4
       4
       +
       }:

     

       5
       5
       +
       with pkgs.lib;

     

       6
       6
       +
       

     

       7
       7
       +
       let

     

       8
       8
       +
           mkNode = package: { replicationMode, publicV6Address ? "::1" }: { pkgs, ... }: {

     

       9
       9
       +
             networking.interfaces.eth1.ipv6.addresses = [{

     

       10
       10
       +
               address = publicV6Address;

     

       11
       11
       +
               prefixLength = 64;

     

       12
       12
       +
             }];

     

       13
       13
       +
       

     

       14
       14
       +
             networking.firewall.allowedTCPPorts = [ 3901 3902 ];

     

       15
       15
       +
       

     

       16
       16
       +
             services.garage = {

     

       17
       17
       +
               enable = true;

     

       18
       18
       +
               inherit package;

     

       19
       19
       +
               settings = {

     

       20
       20
       +
                 replication_mode = replicationMode;

     

       21
       21
       +
       

     

       22
       22
       +
                 rpc_bind_addr = "[::]:3901";

     

       23
       23
       +
                 rpc_public_addr = "[${publicV6Address}]:3901";

     

       24
       24
       +
                 rpc_secret = "5c1915fa04d0b6739675c61bf5907eb0fe3d9c69850c83820f51b4d25d13868c";

     

       25
       25
       +
       

     

       26
       26
       +
                 s3_api = {

     

       27
       27
       +
                   s3_region = "garage";

     

       28
       28
       +
                   api_bind_addr = "[::]:3900";

     

       29
       29
       +
                   root_domain = ".s3.garage";

     

       30
       30
       +
                 };

     

       31
       31
       +
       

     

       32
       32
       +
                 s3_web = {

     

       33
       33
       +
                   bind_addr = "[::]:3902";

     

       34
       34
       +
                   root_domain = ".web.garage";

     

       35
       35
       +
                   index = "index.html";

     

       36
       36
       +
                 };

     

       37
       37
       +
               };

     

       38
       38
       +
             };

     

       39
       39
       +
             environment.systemPackages = [ pkgs.minio-client ];

     

       40
       40
       +
       

     

       41
       41
       +
             # Garage requires at least 1GiB of free disk space to run.

     

       42
       42
       +
             virtualisation.diskSize = 2 * 1024;

     

       43
       43
       +
           };

     

       44
       44
       +
       in

     

       45
       45
       +
         foldl

     

       46
       46
       +
         (matrix: ver: matrix // {

     

       47
       47
       +
           "basic${toString ver}" = import ./basic.nix { inherit system pkgs; mkNode = mkNode pkgs."garage_${ver}"; };

     

       48
       48
       +
           "with-3node-replication${toString ver}" = import ./with-3node-replication.nix { inherit system pkgs; mkNode = mkNode pkgs."garage_${ver}"; };

     

       49
       49
       +
         })

     

       50
       50
       +
         {}

     

       51
       51
       +
         [

     

       52
       52
       +
           "0_7_3"

     

       53
       53
       +
           "0_8_0"

     

       54
       54
       +
         ]

+78 -38

pkgs/tools/filesystems/garage/default.nix

···

       1
       1
        
       { lib, stdenv, rustPlatform, fetchFromGitea, openssl, pkg-config, protobuf

     

       2
       2
       -
       , testers, Security, garage }:

     

       2
       2
       +
       , testers, Security, garage, nixosTests }:

     

       3
       3
       +
       let

     

       4
       4
       +
         generic = { version, sha256, cargoSha256, eol ? false }: rustPlatform.buildRustPackage {

     

       5
       5
       +
           pname = "garage";

     

       6
       6
       +
           inherit version;

     

       3
       7
        
       

     

       4
       4
       -
       rustPlatform.buildRustPackage rec {

     

       5
       5
       -
         pname = "garage";

     

       6
       6
       -
         version = "0.7.3";

     

       8
       8
       +
           src = fetchFromGitea {

     

       9
       9
       +
             domain = "git.deuxfleurs.fr";

     

       10
       10
       +
             owner = "Deuxfleurs";

     

       11
       11
       +
             repo = "garage";

     

       12
       12
       +
             rev = "v${version}";

     

       13
       13
       +
             inherit sha256;

     

       14
       14
       +
           };

     

       7
       15
        
       

     

       8
       8
       -
         src = fetchFromGitea {

     

       9
       9
       -
           domain = "git.deuxfleurs.fr";

     

       10
       10
       -
           owner = "Deuxfleurs";

     

       11
       11
       -
           repo = "garage";

     

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

     

       13
       13
       -
           sha256 = "sha256-WDhe2L+NalMoIy2rhfmv8KCNDMkcqBC9ezEKKocihJg=";

     

       14
       14
       -
         };

     

       16
       16
       +
           inherit cargoSha256;

     

       15
       17
        
       

     

       16
       16
       -
         cargoSha256 = "sha256-5m4c8/upBYN8nuysDhGKEnNVJjEGC+yLrraicrAQOfI=";

     

       18
       18
       +
           nativeBuildInputs = [ protobuf pkg-config ];

     

       17
       19
        
       

     

       18
       18
       -
         nativeBuildInputs = [ protobuf pkg-config ];

     

       20
       20
       +
           buildInputs = [

     

       21
       21
       +
             openssl

     

       22
       22
       +
           ] ++ lib.optional stdenv.isDarwin Security;

     

       19
       23
        
       

     

       20
       20
       -
         buildInputs = [

     

       21
       21
       -
           openssl

     

       22
       22
       -
         ] ++ lib.optional stdenv.isDarwin Security;

     

       24
       24
       +
           OPENSSL_NO_VENDOR = true;

     

       23
       25
        
       

     

       24
       24
       -
         OPENSSL_NO_VENDOR = true;

     

       26
       26
       +
           # See https://git.deuxfleurs.fr/Deuxfleurs/garage/src/tag/v0.7.2/default.nix#L84-L98

     

       27
       27
       +
           # on version changes for checking if changes are required here

     

       28
       28
       +
           buildFeatures = [

     

       29
       29
       +
             "kubernetes-discovery"

     

       30
       30
       +
           ] ++

     

       31
       31
       +
           (lib.optional (lib.versionAtLeast version "0.8") [

     

       32
       32
       +
             "bundled-libs"

     

       33
       33
       +
             "sled"

     

       34
       34
       +
             "metrics"

     

       35
       35
       +
             "k2v"

     

       36
       36
       +
             "telemetry-otlp"

     

       37
       37
       +
             "lmdb"

     

       38
       38
       +
             "sqlite"

     

       39
       39
       +
           ]);

     

       25
       40
        
       

     

       26
       26
       -
         # See https://git.deuxfleurs.fr/Deuxfleurs/garage/src/tag/v0.7.2/default.nix#L84-L98

     

       27
       27
       -
         # on version changes for checking if changes are required here

     

       28
       28
       -
         buildFeatures = [

     

       29
       29
       -
           "kubernetes-discovery"

     

       30
       30
       -
         ];

     

       41
       41
       +
           # To make integration tests pass, we include the optional k2v feature here,

     

       42
       42
       +
           # but not in buildFeatures. See:

     

       43
       43
       +
           # https://garagehq.deuxfleurs.fr/documentation/reference-manual/k2v/

     

       44
       44
       +
           checkFeatures = [

     

       45
       45
       +
             "k2v"

     

       46
       46
       +
             "kubernetes-discovery"

     

       47
       47
       +
           ] ++

     

       48
       48
       +
           (lib.optional (lib.versionAtLeast version "0.8") [

     

       49
       49
       +
             "bundled-libs"

     

       50
       50
       +
             "sled"

     

       51
       51
       +
             "metrics"

     

       52
       52
       +
             "telemetry-otlp"

     

       53
       53
       +
             "lmdb"

     

       54
       54
       +
             "sqlite"

     

       55
       55
       +
           ]);

     

       31
       56
        
       

     

       32
       32
       -
         # To make integration tests pass, we include the optional k2v feature here,

     

       33
       33
       -
         # but not in buildFeatures. See:

     

       34
       34
       -
         # https://garagehq.deuxfleurs.fr/documentation/reference-manual/k2v/

     

       35
       35
       -
         checkFeatures = [

     

       36
       36
       -
           "k2v"

     

       37
       37
       -
           "kubernetes-discovery"

     

       38
       38
       -
         ];

     

       57
       57
       +
           passthru = nixosTests.garage;

     

       39
       58
        
       

     

       40
       40
       -
         passthru = {

     

       41
       41
       -
           tests.version = testers.testVersion { package = garage; };

     

       59
       59
       +
           meta = {

     

       60
       60
       +
             description = "S3-compatible object store for small self-hosted geo-distributed deployments";

     

       61
       61
       +
             homepage = "https://garagehq.deuxfleurs.fr";

     

       62
       62
       +
             license = lib.licenses.agpl3Only;

     

       63
       63
       +
             maintainers = with lib.maintainers; [ nickcao _0x4A6F teutat3s raitobezarius ];

     

       64
       64
       +
             knownVulnerabilities = (lib.optional eol "Garage version ${version} is EOL");

     

       65
       65
       +
           };

     

       42
       66
        
         };

     

       67
       67
       +
       in

     

       68
       68
       +
         rec {

     

       69
       69
       +
           # Until Garage hits 1.0, 0.7.3 is equivalent to 7.3.0 for now, therefore

     

       70
       70
       +
           # we have to keep all the numbers in the version to handle major/minor/patch level.

     

       71
       71
       +
           # for <1.0.

     

       43
       72
        
       

     

       44
       44
       -
         meta = {

     

       45
       45
       -
           description = "S3-compatible object store for small self-hosted geo-distributed deployments";

     

       46
       46
       -
           homepage = "https://garagehq.deuxfleurs.fr";

     

       47
       47
       -
           license = lib.licenses.agpl3Only;

     

       48
       48
       -
           maintainers = with lib.maintainers; [ nickcao _0x4A6F teutat3s ];

     

       49
       49
       -
         };

     

       50
       50
       -
       }

     

       73
       73
       +
           garage_0_7_3 = generic {

     

       74
       74
       +
             version = "0.7.3";

     

       75
       75
       +
             sha256 = "sha256-WDhe2L+NalMoIy2rhfmv8KCNDMkcqBC9ezEKKocihJg=";

     

       76
       76
       +
             cargoSha256 = "sha256-5m4c8/upBYN8nuysDhGKEnNVJjEGC+yLrraicrAQOfI=";

     

       77
       77
       +
           };

     

       78
       78
       +
       

     

       79
       79
       +
           garage_0_7 = garage_0_7_3;

     

       80
       80
       +
       

     

       81
       81
       +
           garage_0_8_0 = generic {

     

       82
       82
       +
             version = "0.8.0";

     

       83
       83
       +
             sha256 = "sha256-c2RhHfg0+YV2E9Ckl1YSc+0nfzbHPIt0JgtT0DND9lA=";

     

       84
       84
       +
             cargoSha256 = "sha256-vITXckNOiJbMuQW6/8p7dsZThkjxg/zUy3AZBbn33no=";

     

       85
       85
       +
           };

     

       86
       86
       +
       

     

       87
       87
       +
           garage_0_8 = garage_0_8_0;

     

       88
       88
       +
       

     

       89
       89
       +
           garage = garage_0_8;

     

       90
       90
       +
         }

+5 -2

pkgs/top-level/all-packages.nix

···

       7355
       7355
        
       

     

       7356
       7356
        
         gaphor = python3Packages.callPackage ../tools/misc/gaphor { };

     

       7357
       7357
        
       

     

       7358
       7358
       -
         garage = callPackage ../tools/filesystems/garage {

     

       7358
       7358
       +
         inherit (callPackage ../tools/filesystems/garage {

     

       7359
       7359
        
           inherit (darwin.apple_sdk.frameworks) Security;

     

       7360
       7360
       -
         };

     

       7360
       7360
       +
         })

     

       7361
       7361
       +
           garage

     

       7362
       7362
       +
             garage_0_7 garage_0_8

     

       7363
       7363
       +
             garage_0_7_3 garage_0_8_0;

     

       7361
       7364
        
       

     

       7362
       7365
        
         garmin-plugin = callPackage ../applications/misc/garmin-plugin {};

     

       7363
       7366