commit b9700f766a10803c28e12009f768df565898aa67 · pyrox.dev/nixpkgs

+5 -1

nixos/tests/all-tests.nix

···

       537
       537
        
         gancio = runTest ./gancio.nix;

     

       538
       538
        
         garage_1 = import ./garage {

     

       539
       539
        
           inherit runTest;

     

       540
       540
       -
           package = pkgs.garage_1_x;

     

       540
       540
       +
           package = pkgs.garage_1;

     

       541
       541
       +
         };

     

       542
       542
       +
         garage_2 = import ./garage {

     

       543
       543
       +
           inherit runTest;

     

       544
       544
       +
           package = pkgs.garage_2;

     

       541
       545
        
         };

     

       542
       546
        
         gatus = runTest ./gatus.nix;

     

       543
       547
        
         getaddrinfo = runTest ./getaddrinfo.nix;

+20 -76

nixos/tests/garage/basic.nix

···

       1
       1
       -
       { mkNode, ... }:

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         mkNode,

     

       4
       4
       +
         package,

     

       5
       5
       +
         testScriptSetup,

     

       6
       6
       +
         ...

     

       7
       7
       +
       }:

     

       2
       8
        
       {

     

       3
       9
        
         name = "garage-basic";

     

       4
       10
        
       

     

       5
       11
        
         nodes = {

     

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

     

       12
       12
       +
           single_node = mkNode {

     

       13
       13
       +
             extraSettings =

     

       14
       14
       +
               if (lib.versionAtLeast package.version "2") then

     

       15
       15
       +
                 {

     

       16
       16
       +
                   replication_factor = 1;

     

       17
       17
       +
                   consistency_mode = "consistent";

     

       18
       18
       +
                 }

     

       19
       19
       +
               else

     

       20
       20
       +
                 {

     

       21
       21
       +
                   replication_mode = "none";

     

       22
       22
       +
                 };

     

       23
       23
       +
           };

     

       7
       24
        
         };

     

       8
       25
        
       

     

       9
       26
        
         testScript = # python

     

       10
       27
        
           ''

     

       11
       11
       -
             from typing import List

     

       12
       12
       -
             from dataclasses import dataclass

     

       13
       13
       -
             import re

     

       14
       14
       -
       

     

       15
       15
       -
             start_all()

     

       16
       16
       -
       

     

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

     

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

     

       19
       19
       -
       

     

       20
       20
       -
             @dataclass

     

       21
       21
       -
             class S3Key:

     

       22
       22
       -
                key_name: str

     

       23
       23
       -
                key_id: str

     

       24
       24
       -
                secret_key: str

     

       25
       25
       -
       

     

       26
       26
       -
             @dataclass

     

       27
       27
       -
             class GarageNode:

     

       28
       28
       -
                node_id: str

     

       29
       29
       -
                host: str

     

       30
       30
       -
       

     

       31
       31
       -
             def get_node_fqn(machine: Machine) -> GarageNode:

     

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

     

       33
       33
       -
               return GarageNode(node_id=node_id, host=host)

     

       34
       34
       -
       

     

       35
       35
       -
             def get_node_id(machine: Machine) -> str:

     

       36
       36
       -
               return get_node_fqn(machine).node_id

     

       37
       37
       -
       

     

       38
       38
       -
             def get_layout_version(machine: Machine) -> int:

     

       39
       39
       -
               version_data = machine.succeed("garage layout show")

     

       40
       40
       -
               m = cur_version_regex.search(version_data)

     

       41
       41
       -
               if m and m.group('ver') is not None:

     

       42
       42
       -
                 return int(m.group('ver')) + 1

     

       43
       43
       -
               else:

     

       44
       44
       -
                 raise ValueError('Cannot find current layout version')

     

       45
       45
       -
       

     

       46
       46
       -
             def apply_garage_layout(machine: Machine, layouts: List[str]):

     

       47
       47
       -
                for layout in layouts:

     

       48
       48
       -
                   machine.succeed(f"garage layout assign {layout}")

     

       49
       49
       -
                version = get_layout_version(machine)

     

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

     

       51
       51
       -
       

     

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

     

       53
       53
       -
                output = machine.succeed(f"garage key create {key_name}")

     

       54
       54
       -
                m = key_creation_regex.match(output)

     

       55
       55
       -
                if not m or not m.group('key_id') or not m.group('secret_key'):

     

       56
       56
       -
                   raise ValueError('Cannot parse API key data')

     

       57
       57
       -
                return S3Key(key_name=key_name, key_id=m.group('key_id'), secret_key=m.group('secret_key'))

     

       58
       58
       -
       

     

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

     

       60
       60
       -
                output = machine.succeed(f"garage key info {key_pattern}")

     

       61
       61
       -
                m = key_creation_regex.match(output)

     

       62
       62
       -
                if not m or not m.group('key_name') or not m.group('key_id') or not m.group('secret_key'):

     

       63
       63
       -
                    raise ValueError('Cannot parse API key data')

     

       64
       64
       -
                return S3Key(key_name=m.group('key_name'), key_id=m.group('key_id'), secret_key=m.group('secret_key'))

     

       65
       65
       -
       

     

       66
       66
       -
             def test_bucket_writes(node):

     

       67
       67
       -
               node.succeed("garage bucket create test-bucket")

     

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

     

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

     

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

     

       71
       71
       -
               assert other_s3_key.secret_key == other_s3_key.secret_key

     

       72
       72
       -
               node.succeed(

     

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

     

       74
       74
       -
               )

     

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

     

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

     

       77
       77
       -
       

     

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

     

       79
       79
       -
               if url is None:

     

       80
       80
       -
                  url = f"{bucket}.web.garage"

     

       81
       81
       -
       

     

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

     

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

     

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

     

       28
       28
       +
             ${testScriptSetup}

     

       85
       29
        
       

     

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

     

       87
       31
        
               single_node.wait_for_unit("garage.service")

+85

nixos/tests/garage/common.nix

···

       1
       1
       +
       { ... }:

     

       2
       2
       +
       {

     

       3
       3
       +
         _module.args.testScriptSetup = # python

     

       4
       4
       +
           ''

     

       5
       5
       +
             from typing import List

     

       6
       6
       +
             from dataclasses import dataclass

     

       7
       7
       +
             import re

     

       8
       8
       +
       

     

       9
       9
       +
             start_all()

     

       10
       10
       +
       

     

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

     

       12
       12
       +
       

     

       13
       13
       +
             @dataclass

     

       14
       14
       +
             class S3Key:

     

       15
       15
       +
                key_name: str

     

       16
       16
       +
                key_id: str

     

       17
       17
       +
                secret_key: str

     

       18
       18
       +
       

     

       19
       19
       +
             @dataclass

     

       20
       20
       +
             class GarageNode:

     

       21
       21
       +
                node_id: str

     

       22
       22
       +
                host: str

     

       23
       23
       +
       

     

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

     

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

     

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

     

       27
       27
       +
       

     

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

     

       29
       29
       +
               return get_node_fqn(machine).node_id

     

       30
       30
       +
       

     

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

     

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

     

       33
       33
       +
               m = cur_version_regex.search(version_data)

     

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

     

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

     

       36
       36
       +
               else:

     

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

     

       38
       38
       +
       

     

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

     

       40
       40
       +
                for layout in layouts:

     

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

     

       42
       42
       +
                version = get_layout_version(machine)

     

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

     

       44
       44
       +
       

     

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

     

       46
       46
       +
                output = machine.succeed(f"garage key create {key_name}")

     

       47
       47
       +
                return parse_api_key_data(output)

     

       48
       48
       +
       

     

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

     

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

     

       51
       51
       +
                return parse_api_key_data(output)

     

       52
       52
       +
       

     

       53
       53
       +
             def parse_api_key_data(text) -> S3Key:

     

       54
       54
       +
               key_creation_regex = re.compile(r'Key name: \s*(?P<key_name>.*)|' r'Key ID: \s*(?P<key_id>.*)|' r'Secret key: \s*(?P<secret_key>.*)', re.IGNORECASE)

     

       55
       55
       +
               fields = {}

     

       56
       56
       +
               for match in key_creation_regex.finditer(text):

     

       57
       57
       +
                 for key, value in match.groupdict().items():

     

       58
       58
       +
                   if value:

     

       59
       59
       +
                     fields[key] = value.strip()

     

       60
       60
       +
               try:

     

       61
       61
       +
                 return S3Key(**fields)

     

       62
       62
       +
               except TypeError as e:

     

       63
       63
       +
                 raise ValueError(f"Cannot parse API key data. Missing required field(s): {e}")

     

       64
       64
       +
       

     

       65
       65
       +
             def test_bucket_writes(node):

     

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

     

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

     

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

     

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

     

       70
       70
       +
               assert other_s3_key.secret_key == other_s3_key.secret_key

     

       71
       71
       +
               node.succeed(

     

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

     

       73
       73
       +
               )

     

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

     

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

     

       76
       76
       +
       

     

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

     

       78
       78
       +
               if url is None:

     

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

     

       80
       80
       +
       

     

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

     

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

     

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

     

       84
       84
       +
           '';

     

       85
       85
       +
       }

+6 -6

nixos/tests/garage/default.nix

···

       5
       5
        
       let

     

       6
       6
        
         mkNode =

     

       7
       7
        
           {

     

       8
       8
       -
             replicationMode,

     

       9
       8
        
             publicV6Address ? "::1",

     

       9
       9
       +
             extraSettings ? { },

     

       10
       10
        
           }:

     

       11
       11
        
           { pkgs, ... }:

     

       12
       12
        
           {

     
···

       26
       26
        
               enable = true;

     

       27
       27
        
               inherit package;

     

       28
       28
        
               settings = {

     

       29
       29
       -
                 replication_mode = replicationMode;

     

       30
       30
       -
       

     

       31
       29
        
                 rpc_bind_addr = "[::]:3901";

     

       32
       30
        
                 rpc_public_addr = "[${publicV6Address}]:3901";

     

       33
       31
        
                 rpc_secret = "5c1915fa04d0b6739675c61bf5907eb0fe3d9c69850c83820f51b4d25d13868c";

     
···

       43
       41
        
                   root_domain = ".web.garage";

     

       44
       42
        
                   index = "index.html";

     

       45
       43
        
                 };

     

       46
       46
       -
               };

     

       44
       44
       +
               } // extraSettings;

     

       47
       45
        
             };

     

       48
       46
        
             environment.systemPackages = [ pkgs.minio-client ];

     

       49
       47
        
       

     
···

       54
       52
        
       {

     

       55
       53
        
         basic = runTest {

     

       56
       54
        
           imports = [

     

       55
       55
       +
             ./common.nix

     

       57
       56
        
             ./basic.nix

     

       58
       57
        
           ];

     

       59
       58
        
           _module.args = {

     

       60
       60
       -
             inherit mkNode;

     

       59
       59
       +
             inherit mkNode package;

     

       61
       60
        
           };

     

       62
       61
        
         };

     

       63
       62
        
       

     

       64
       63
        
         with-3node-replication = runTest {

     

       65
       64
        
           imports = [

     

       65
       65
       +
             ./common.nix

     

       66
       66
        
             ./with-3node-replication.nix

     

       67
       67
        
           ];

     

       68
       68
        
           _module.args = {

     

       69
       69
       -
             inherit mkNode;

     

       69
       69
       +
             inherit mkNode package;

     

       70
       70
        
           };

     

       71
       71
        
         };

     

       72
       72
        
       }

+24 -78

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

···

       1
       1
       -
       { mkNode, ... }:

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         mkNode,

     

       4
       4
       +
         package,

     

       5
       5
       +
         testScriptSetup,

     

       6
       6
       +
         ...

     

       7
       7
       +
       }:

     

       8
       8
       +
       let

     

       9
       9
       +
         extraSettings =

     

       10
       10
       +
           if (lib.versionAtLeast package.version "2") then

     

       11
       11
       +
             {

     

       12
       12
       +
               replication_factor = 3;

     

       13
       13
       +
               consistency_mode = "consistent";

     

       14
       14
       +
             }

     

       15
       15
       +
           else

     

       16
       16
       +
             {

     

       17
       17
       +
               replication_mode = "3";

     

       18
       18
       +
             };

     

       19
       19
       +
       in

     

       2
       20
        
       {

     

       3
       21
        
         name = "garage-3node-replication";

     

       4
       22
        
       

     

       5
       23
        
         nodes = {

     

       6
       24
        
           node1 = mkNode {

     

       7
       7
       -
             replicationMode = "3";

     

       25
       25
       +
             inherit extraSettings;

     

       8
       26
        
             publicV6Address = "fc00:1::1";

     

       9
       27
        
           };

     

       10
       28
        
           node2 = mkNode {

     

       11
       11
       -
             replicationMode = "3";

     

       29
       29
       +
             inherit extraSettings;

     

       12
       30
        
             publicV6Address = "fc00:1::2";

     

       13
       31
        
           };

     

       14
       32
        
           node3 = mkNode {

     

       15
       15
       -
             replicationMode = "3";

     

       33
       33
       +
             inherit extraSettings;

     

       16
       34
        
             publicV6Address = "fc00:1::3";

     

       17
       35
        
           };

     

       18
       36
        
           node4 = mkNode {

     

       19
       19
       -
             replicationMode = "3";

     

       37
       37
       +
             inherit extraSettings;

     

       20
       38
        
             publicV6Address = "fc00:1::4";

     

       21
       39
        
           };

     

       22
       40
        
         };

     

       23
       41
        
       

     

       24
       42
        
         testScript = # python

     

       25
       43
        
           ''

     

       26
       26
       -
             from typing import List

     

       27
       27
       -
             from dataclasses import dataclass

     

       28
       28
       -
             import re

     

       29
       29
       -
             start_all()

     

       30
       30
       -
       

     

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

     

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

     

       33
       33
       -
       

     

       34
       34
       -
             @dataclass

     

       35
       35
       -
             class S3Key:

     

       36
       36
       -
                key_name: str

     

       37
       37
       -
                key_id: str

     

       38
       38
       -
                secret_key: str

     

       39
       39
       -
       

     

       40
       40
       -
             @dataclass

     

       41
       41
       -
             class GarageNode:

     

       42
       42
       -
                node_id: str

     

       43
       43
       -
                host: str

     

       44
       44
       -
       

     

       45
       45
       -
             def get_node_fqn(machine: Machine) -> GarageNode:

     

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

     

       47
       47
       -
               return GarageNode(node_id=node_id, host=host)

     

       48
       48
       -
       

     

       49
       49
       -
             def get_node_id(machine: Machine) -> str:

     

       50
       50
       -
               return get_node_fqn(machine).node_id

     

       51
       51
       -
       

     

       52
       52
       -
             def get_layout_version(machine: Machine) -> int:

     

       53
       53
       -
               version_data = machine.succeed("garage layout show")

     

       54
       54
       -
               m = cur_version_regex.search(version_data)

     

       55
       55
       -
               if m and m.group('ver') is not None:

     

       56
       56
       -
                 return int(m.group('ver')) + 1

     

       57
       57
       -
               else:

     

       58
       58
       -
                 raise ValueError('Cannot find current layout version')

     

       59
       59
       -
       

     

       60
       60
       -
             def apply_garage_layout(machine: Machine, layouts: List[str]):

     

       61
       61
       -
                for layout in layouts:

     

       62
       62
       -
                   machine.succeed(f"garage layout assign {layout}")

     

       63
       63
       -
                version = get_layout_version(machine)

     

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

     

       65
       65
       -
       

     

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

     

       67
       67
       -
                output = machine.succeed(f"garage key create {key_name}")

     

       68
       68
       -
                m = key_creation_regex.match(output)

     

       69
       69
       -
                if not m or not m.group('key_id') or not m.group('secret_key'):

     

       70
       70
       -
                   raise ValueError('Cannot parse API key data')

     

       71
       71
       -
                return S3Key(key_name=key_name, key_id=m.group('key_id'), secret_key=m.group('secret_key'))

     

       72
       72
       -
       

     

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

     

       74
       74
       -
                output = machine.succeed(f"garage key info {key_pattern}")

     

       75
       75
       -
                m = key_creation_regex.match(output)

     

       76
       76
       -
                if not m or not m.group('key_name') or not m.group('key_id') or not m.group('secret_key'):

     

       77
       77
       -
                    raise ValueError('Cannot parse API key data')

     

       78
       78
       -
                return S3Key(key_name=m.group('key_name'), key_id=m.group('key_id'), secret_key=m.group('secret_key'))

     

       79
       79
       -
       

     

       80
       80
       -
             def test_bucket_writes(node):

     

       81
       81
       -
               node.succeed("garage bucket create test-bucket")

     

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

     

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

     

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

     

       85
       85
       -
               assert other_s3_key.secret_key == other_s3_key.secret_key

     

       86
       86
       -
               node.succeed(

     

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

     

       88
       88
       -
               )

     

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

     

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

     

       91
       91
       -
       

     

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

     

       93
       93
       -
               if url is None:

     

       94
       94
       -
                  url = f"{bucket}.web.garage"

     

       95
       95
       -
       

     

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

     

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

     

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

     

       44
       44
       +
             ${testScriptSetup}

     

       99
       45
        
       

     

       100
       46
        
             with subtest("Garage works as a multi-node S3 storage"):

     

       101
       47
        
               nodes = ('node1', 'node2', 'node3', 'node4')

pkgs/tools/filesystems/garage/default.nix

···

       137
       137
        
           cargoHash = "sha256-vcvD0Fn/etnAuXrM3+rj16cqpEmW2nzRmrjXsftKTFE=";

     

       138
       138
        
         };

     

       139
       139
        
       

     

       140
       140
       +
         garage_2_0_0 = generic {

     

       141
       141
       +
           version = "2.0.0";

     

       142
       142
       +
           hash = "sha256-dn7FoouF+5qmW6fcC20bKQSc6D2G9yrWdBK3uN3bF58=";

     

       143
       143
       +
           cargoHash = "sha256-6VM/EesrUIaQOeDGqzb0kOqMz4hW7zBJUnaRQ9C3cqc=";

     

       144
       144
       +
         };

     

       145
       145
       +
       

     

       140
       146
        
         garage_0_8 = garage_0_8_7;

     

       141
       147
        
       

     

       142
       148
        
         garage_0_9 = garage_0_9_4;

     

       143
       149
        
       

     

       144
       150
        
         garage_1_x = garage_1_2_0;

     

       151
       151
       +
         garage_1 = garage_1_x;

     

       152
       152
       +
       

     

       153
       153
       +
         garage_2 = garage_2_0_0;

     

       145
       154
        
       

     

       146
       155
        
         garage = garage_1_x;

     

       147
       156
        
       }

pkgs/top-level/all-packages.nix

···

       3038
       3038
        
           garage_0_9

     

       3039
       3039
        
           garage_0_8_7

     

       3040
       3040
        
           garage_0_9_4

     

       3041
       3041
       +
       

     

       3041
       3042
        
           garage_1_2_0

     

       3042
       3043
        
           garage_1_x

     

       3044
       3044
       +
           garage_1

     

       3045
       3045
       +
       

     

       3046
       3046
       +
           garage_2_0_0

     

       3047
       3047
       +
           garage_2

     

       3043
       3048
        
           ;

     

       3044
       3049
        
       

     

       3045
       3050
        
         gaugePlugins = recurseIntoAttrs (callPackage ../by-name/ga/gauge/plugins { });