[Notes] [Git][BuildStream/buildstream][master] 4 commits: Move bwrap checks in platform/linux.py



Title: GitLab

Benjamin Schubert pushed to branch master at BuildStream / buildstream

Commits:

8 changed files:

Changes:

  • buildstream/_platform/linux.py
    ... ... @@ -18,9 +18,9 @@
    18 18
     #        Tristan Maat <tristan maat codethink co uk>
    
    19 19
     
    
    20 20
     import os
    
    21
    +import shutil
    
    21 22
     import subprocess
    
    22 23
     
    
    23
    -from .. import _site
    
    24 24
     from .. import utils
    
    25 25
     from ..sandbox import SandboxDummy
    
    26 26
     
    
    ... ... @@ -37,12 +37,19 @@ class Linux(Platform):
    37 37
             self._gid = os.getegid()
    
    38 38
     
    
    39 39
             self._have_fuse = os.path.exists("/dev/fuse")
    
    40
    -        self._bwrap_exists = _site.check_bwrap_version(0, 0, 0)
    
    41
    -        self._have_good_bwrap = _site.check_bwrap_version(0, 1, 2)
    
    42 40
     
    
    43
    -        self._local_sandbox_available = self._have_fuse and self._have_good_bwrap
    
    41
    +        bwrap_version = self._get_bwrap_version()
    
    44 42
     
    
    45
    -        self._die_with_parent_available = _site.check_bwrap_version(0, 1, 8)
    
    43
    +        if bwrap_version is None:
    
    44
    +            self._bwrap_exists = False
    
    45
    +            self._have_good_bwrap = False
    
    46
    +            self._die_with_parent_available = False
    
    47
    +        else:
    
    48
    +            self._bwrap_exists = True
    
    49
    +            self._have_good_bwrap = (0, 1, 2) <= bwrap_version
    
    50
    +            self._die_with_parent_available = (0, 1, 8) <= bwrap_version
    
    51
    +
    
    52
    +        self._local_sandbox_available = self._have_fuse and self._have_good_bwrap
    
    46 53
     
    
    47 54
             if self._local_sandbox_available:
    
    48 55
                 self._user_ns_available = self._check_user_ns_available()
    
    ... ... @@ -112,3 +119,21 @@ class Linux(Platform):
    112 119
                 output = ''
    
    113 120
     
    
    114 121
             return output == 'root'
    
    122
    +
    
    123
    +    def _get_bwrap_version(self):
    
    124
    +        # Get the current bwrap version
    
    125
    +        #
    
    126
    +        # returns None if no bwrap was found
    
    127
    +        # otherwise returns a tuple of 3 int: major, minor, patch
    
    128
    +        bwrap_path = shutil.which('bwrap')
    
    129
    +
    
    130
    +        if not bwrap_path:
    
    131
    +            return None
    
    132
    +
    
    133
    +        cmd = [bwrap_path, "--version"]
    
    134
    +        try:
    
    135
    +            version = str(subprocess.check_output(cmd).split()[1], "utf-8")
    
    136
    +        except subprocess.CalledProcessError:
    
    137
    +            return None
    
    138
    +
    
    139
    +        return tuple(int(x) for x in version.split("."))

  • buildstream/_site.py
    ... ... @@ -18,8 +18,6 @@
    18 18
     #        Tristan Van Berkom <tristan vanberkom codethink co uk>
    
    19 19
     
    
    20 20
     import os
    
    21
    -import shutil
    
    22
    -import subprocess
    
    23 21
     
    
    24 22
     #
    
    25 23
     # Private module declaring some info about where the buildstream
    
    ... ... @@ -46,44 +44,3 @@ build_all_template = os.path.join(root, 'data', 'build-all.sh.in')
    46 44
     
    
    47 45
     # Module building script template
    
    48 46
     build_module_template = os.path.join(root, 'data', 'build-module.sh.in')
    49
    -
    
    50
    -# Cached bwrap version
    
    51
    -_bwrap_major = None
    
    52
    -_bwrap_minor = None
    
    53
    -_bwrap_patch = None
    
    54
    -
    
    55
    -
    
    56
    -# check_bwrap_version()
    
    57
    -#
    
    58
    -# Checks the version of installed bwrap against the requested version
    
    59
    -#
    
    60
    -# Args:
    
    61
    -#    major (int): The required major version
    
    62
    -#    minor (int): The required minor version
    
    63
    -#    patch (int): The required patch level
    
    64
    -#
    
    65
    -# Returns:
    
    66
    -#    (bool): Whether installed bwrap meets the requirements
    
    67
    -#
    
    68
    -def check_bwrap_version(major, minor, patch):
    
    69
    -    # pylint: disable=global-statement
    
    70
    -
    
    71
    -    global _bwrap_major
    
    72
    -    global _bwrap_minor
    
    73
    -    global _bwrap_patch
    
    74
    -
    
    75
    -    # Parse bwrap version and save into cache, if not already cached
    
    76
    -    if _bwrap_major is None:
    
    77
    -        bwrap_path = shutil.which('bwrap')
    
    78
    -        if not bwrap_path:
    
    79
    -            return False
    
    80
    -        cmd = [bwrap_path, "--version"]
    
    81
    -        try:
    
    82
    -            version = str(subprocess.check_output(cmd).split()[1], "utf-8")
    
    83
    -        except subprocess.CalledProcessError:
    
    84
    -            # Failure trying to run bubblewrap
    
    85
    -            return False
    
    86
    -        _bwrap_major, _bwrap_minor, _bwrap_patch = map(int, version.split("."))
    
    87
    -
    
    88
    -    # Check whether the installed version meets the requirements
    
    89
    -    return (_bwrap_major, _bwrap_minor, _bwrap_patch) >= (major, minor, patch)

  • buildstream/sandbox/_sandboxdummy.py
    ... ... @@ -42,4 +42,5 @@ class SandboxDummy(Sandbox):
    42 42
                                    "'{}'".format(command[0]),
    
    43 43
                                    reason='missing-command')
    
    44 44
     
    
    45
    -        raise SandboxError("This platform does not support local builds: {}".format(self._reason))
    45
    +        raise SandboxError("This platform does not support local builds: {}".format(self._reason),
    
    46
    +                           reason="unavailable-local-sandbox")

  • conftest.py
    ... ... @@ -23,6 +23,8 @@ import shutil
    23 23
     
    
    24 24
     import pytest
    
    25 25
     
    
    26
    +from buildstream._platform.platform import Platform
    
    27
    +
    
    26 28
     
    
    27 29
     def pytest_addoption(parser):
    
    28 30
         parser.addoption('--integration', action='store_true', default=False,
    
    ... ... @@ -52,3 +54,8 @@ def integration_cache(request):
    52 54
             shutil.rmtree(os.path.join(cache_dir, 'artifacts'))
    
    53 55
         except FileNotFoundError:
    
    54 56
             pass
    
    57
    +
    
    58
    +
    
    59
    +@pytest.fixture(autouse=True)
    
    60
    +def clean_platform_cache():
    
    61
    +    Platform._instance = None

  • tests/sandboxes/missing-dependencies/elements/base.bst
    1
    +kind: import
    
    2
    +sources:
    
    3
    +- kind: local
    
    4
    +  path: files/base/

  • tests/sandboxes/missing-dependencies/files/base/bin/sh
    1
    +# This is the original bash

  • tests/sandboxes/missing-dependencies/project.conf
    1
    +# Project config for missing dependencies test
    
    2
    +name: test
    
    3
    +
    
    4
    +element-path: elements

  • tests/sandboxes/missing_dependencies.py
    1
    +import os
    
    2
    +import pytest
    
    3
    +from tests.testutils import cli
    
    4
    +from tests.testutils.site import IS_LINUX
    
    5
    +
    
    6
    +from buildstream import _yaml
    
    7
    +from buildstream._exceptions import ErrorDomain
    
    8
    +
    
    9
    +
    
    10
    +# Project directory
    
    11
    +DATA_DIR = os.path.join(
    
    12
    +    os.path.dirname(os.path.realpath(__file__)),
    
    13
    +    "missing-dependencies",
    
    14
    +)
    
    15
    +
    
    16
    +
    
    17
    +@pytest.mark.skipif(not IS_LINUX, reason='Only available on Linux')
    
    18
    +@pytest.mark.datafiles(DATA_DIR)
    
    19
    +def test_missing_brwap_has_nice_error_message(cli, datafiles):
    
    20
    +    project = os.path.join(datafiles.dirname, datafiles.basename)
    
    21
    +    element_path = os.path.join(project, 'elements', 'element.bst')
    
    22
    +
    
    23
    +    # Write out our test target
    
    24
    +    element = {
    
    25
    +        'kind': 'script',
    
    26
    +        'depends': [
    
    27
    +            {
    
    28
    +                'filename': 'base.bst',
    
    29
    +                'type': 'build',
    
    30
    +            },
    
    31
    +        ],
    
    32
    +        'config': {
    
    33
    +            'commands': [
    
    34
    +                'false',
    
    35
    +            ],
    
    36
    +        },
    
    37
    +    }
    
    38
    +    _yaml.dump(element, element_path)
    
    39
    +
    
    40
    +    # Build without access to host tools, this should fail with a nice error
    
    41
    +    result = cli.run(
    
    42
    +        project=project, args=['build', 'element.bst'], env={'PATH': ''})
    
    43
    +    result.assert_task_error(ErrorDomain.SANDBOX, 'unavailable-local-sandbox')
    
    44
    +    assert "not found" in result.stderr
    
    45
    +
    
    46
    +
    
    47
    +@pytest.mark.skipif(not IS_LINUX, reason='Only available on Linux')
    
    48
    +@pytest.mark.datafiles(DATA_DIR)
    
    49
    +def test_old_brwap_has_nice_error_message(cli, datafiles, tmp_path):
    
    50
    +    bwrap = tmp_path.joinpath('bin/bwrap')
    
    51
    +    bwrap.parent.mkdir()
    
    52
    +    with bwrap.open('w') as fp:
    
    53
    +        fp.write('''
    
    54
    +            #!/bin/sh
    
    55
    +            echo bubblewrap 0.0.1
    
    56
    +        '''.strip())
    
    57
    +
    
    58
    +    bwrap.chmod(0o755)
    
    59
    +
    
    60
    +    project = os.path.join(datafiles.dirname, datafiles.basename)
    
    61
    +    element_path = os.path.join(project, 'elements', 'element3.bst')
    
    62
    +
    
    63
    +    # Write out our test target
    
    64
    +    element = {
    
    65
    +        'kind': 'script',
    
    66
    +        'depends': [
    
    67
    +            {
    
    68
    +                'filename': 'base.bst',
    
    69
    +                'type': 'build',
    
    70
    +            },
    
    71
    +        ],
    
    72
    +        'config': {
    
    73
    +            'commands': [
    
    74
    +                'false',
    
    75
    +            ],
    
    76
    +        },
    
    77
    +    }
    
    78
    +    _yaml.dump(element, element_path)
    
    79
    +
    
    80
    +    # Build without access to host tools, this should fail with a nice error
    
    81
    +    result = cli.run(
    
    82
    +        project=project,
    
    83
    +        args=['--debug', '--verbose', 'build', 'element3.bst'],
    
    84
    +        env={'PATH': str(tmp_path.joinpath('bin'))})
    
    85
    +    result.assert_task_error(ErrorDomain.SANDBOX, 'unavailable-local-sandbox')
    
    86
    +    assert "too old" in result.stderr



  • [Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]