[Notes] [Git][BuildStream/buildstream][bschubert/cleanup-local-state] 6

Benjamin Schubert pushed to branch bschubert/cleanup-local-state at BuildStream / buildstream

Commits:

118644b2

by Tom Pollard at 2019-02-13T13:37:32Z

Add cli main & user conf option for 'cache-buildtrees' context

_context.py: Add cache_buildtrees global user context, the default
of which is set to by default to 'always' via the addition of
cache-buildtrees to userconfig.yaml cache group. 'failure' & 'never'
can be given as valid options.

app.py & cli.py: Add --cache-buildtrees as a bst main option, which
when passed with a valid option can override the default or user
defined context for cache_buildtrees.

tests/completions/completions.py: Update for the added flag.

b546bac1

by Tom Pollard at 2019-02-13T13:37:32Z

_frontend/cli.py: Ensure failed buildtree warning is correct

not _cached_sucess() could resolve to true if the element wasn't
cached at all. switch to _cached_failure() to ensure condition
reflects expected artifact state

d2029444

by Tom Pollard at 2019-02-13T13:37:32Z

Provide configuration for the optional creation of buildtrees

Artifacts can be cached explicitly with an empty `build tree` when
built via the cli main options or user config for all or only
successful build artifacts. Default behaviour is to still create
and cache all expected buildtrees.

element.py: _cache_artifact() Check if context for cache_buildtrees
has been set to always or failure with a corresponding build
result, if not skip attempting to export the build-root. Element
types without a build-root are cached with an empty buildtree
regardless. Update _stage_sources_at() to warn the user that the
buildtree import is empty.

tests/integration: Add test to artifact.py for the optional caching
of buildtree content from bst build. Rename build-tree.py to
shellbuildtrees.py to reflect included test cases, add test for
empty buildtree warning and failure option.

NEWS: Add entry for new option.

54ec032a

by Jürg Billeter at 2019-02-13T14:50:15Z

Merge branch 'tpollard/896' into 'master'

Optional creation of buildtrees

Closes #896

See merge request BuildStream/buildstream!1135

ec4bbf35

by Benjamin Schubert at 2019-02-13T14:59:47Z

Cleanup internal Loader cache after loading elements

b41a82d3

by Benjamin Schubert at 2019-02-13T14:59:47Z

Don't register exceptions when not running the testsuite

This fix a problem with the garbage collector not being able to
clean the MetaElements that are loaded.

On small projects this is not a problem, but in bigger projects, this
can save a few hundred of MBs at runtime

The reason behind this is, whenever we have a "stack" element, which
has no stack.yaml configuration, since it doesn't need it, we would
get an exception thrown when initiating the first one, as loading the
yaml file would fail.

This would capture the frame in which this command was executed, which
references meta_elements. Therefore, as long as another exception is not
thrown, the garbage collector would not be able to clean all the
MetaElements.

12 changed files:

NEWS
buildstream/_context.py
buildstream/_exceptions.py
buildstream/_frontend/app.py
buildstream/_frontend/cli.py
buildstream/_loader/loader.py
buildstream/_project.py
buildstream/data/userconfig.yaml
buildstream/element.py
tests/frontend/completions.py
tests/integration/artifact.py
tests/integration/build-tree.py → tests/integration/shellbuildtrees.py

Changes:

NEWS

@@ -126,6 +126,14 @@ buildstream 1.3.1
      Providing a remote will limit build's pull/push remote actions to the given
      remote specifically, ignoring those defined via user or project configuration.
 +  o Artifacts can now be cached explicitly with an empty `build tree` when built.
 +    Element types without a build-root were already cached with an empty build tree
 +    directory, this can now be extended to all or successful artifacts to save on cache
 +    overheads. The cli main option '--cache-buildtrees' or the user configuration cache
 +    group option 'cache-buildtrees' can be set as 'always', 'failure' or 'never', with
 +    the default being always. Note, as the cache-key for the artifact is independant of
 +    the cached build tree input it will remain unaltered, however the availbility of the
 +    build tree content may differ.
  =================
  buildstream 1.1.5

buildstream/_context.py

@@ -121,6 +121,9 @@ class Context():
          # Whether or not to attempt to pull build trees globally
          self.pull_buildtrees = None
 +        # Whether or not to cache build trees on artifact creation
 +        self.cache_buildtrees = None
++
          # Boolean, whether we double-check with the user that they meant to
          # close the workspace when they're using it to access the project.
          self.prompt_workspace_close_project_inaccessible = None
@@ -201,7 +204,7 @@ class Context():
          # our artifactdir - the artifactdir may not have been created
          # yet.
          cache = _yaml.node_get(defaults, Mapping, 'cache')
 -        _yaml.node_validate(cache, ['quota', 'pull-buildtrees'])
 +        _yaml.node_validate(cache, ['quota', 'pull-buildtrees', 'cache-buildtrees'])
          self.config_cache_quota = _yaml.node_get(cache, str, 'quota')
@@ -213,6 +216,10 @@ class Context():
          # Load pull build trees configuration
          self.pull_buildtrees = _yaml.node_get(cache, bool, 'pull-buildtrees')
 +        # Load cache build trees configuration
 +        self.cache_buildtrees = _node_get_option_str(
 +            cache, 'cache-buildtrees', ['always', 'failure', 'never'])
++
          # Load logging config
          logging = _yaml.node_get(defaults, Mapping, 'logging')
          _yaml.node_validate(logging, [

buildstream/_exceptions.py

@@ -19,6 +19,7 @@
  #        Tiago Gomes <tiago gomes codethink co uk>
  from enum import Enum
 +import os
  # Disable pylint warnings for whole file here:
  # pylint: disable=global-statement
@@ -50,6 +51,9 @@ def get_last_exception():
  # Used by regression tests
+ #
  def get_last_task_error():
 +    if 'BST_TEST_SUITE' not in os.environ:
 +        raise BstError("Getting the last task error is only supported when running tests")
++
      global _last_task_error_domain
      global _last_task_error_reason
@@ -67,11 +71,12 @@ def get_last_task_error():
  # tests about how things failed in a machine readable way
+ #
  def set_last_task_error(domain, reason):
 -    global _last_task_error_domain
 -    global _last_task_error_reason
 +    if 'BST_TEST_SUITE' in os.environ:
 +        global _last_task_error_domain
 +        global _last_task_error_reason
 -    _last_task_error_domain = domain
 -    _last_task_error_reason = reason
 +        _last_task_error_domain = domain
 +        _last_task_error_reason = reason
  class ErrorDomain(Enum):
@@ -126,7 +131,8 @@ class BstError(Exception):
          self.reason = reason
          # Hold on to the last raised exception for testing purposes
 -        _last_exception = self
 +        if 'BST_TEST_SUITE' in os.environ:
 +            _last_exception = self
  # PluginError

buildstream/_frontend/app.py

@@ -183,7 +183,8 @@ class App():
              'builders': 'sched_builders',
              'pushers': 'sched_pushers',
              'network_retries': 'sched_network_retries',
 -            'pull_buildtrees': 'pull_buildtrees'
 +            'pull_buildtrees': 'pull_buildtrees',
 +            'cache_buildtrees': 'cache_buildtrees'
+         }
          for cli_option, context_attr in override_map.items():
              option_value = self._main_options.get(cli_option)

buildstream/_frontend/cli.py

@@ -251,6 +251,9 @@ def print_version(ctx, param, value):
                help="The mirror to fetch from first, before attempting other mirrors")
  @click.option('--pull-buildtrees', is_flag=True, default=None,
                help="Include an element's build tree when pulling remote element artifacts")
 +@click.option('--cache-buildtrees', default=None,
 +              type=click.Choice(['always', 'failure', 'never']),
 +              help="Cache artifact build tree content on creation")
  @click.pass_context
  def cli(context, **kwargs):
      """Build and manipulate BuildStream projects
@@ -572,7 +575,8 @@ def shell(app, element, sysroot, mount, isolate, build_, cli_buildtree, command)
                      if choice != "never":
                          use_buildtree = choice
 -        if use_buildtree and not element._cached_success():
 +        # Raise warning if the element is cached in a failed state
 +        if use_buildtree and element._cached_failure():
              click.echo("WARNING: using a buildtree from a failed build.", err=True)
          try:

buildstream/_loader/loader.py

@@ -152,8 +152,27 @@ class Loader():
+             #
              ret.append(loader._collect_element(element))
 +        self._clean_caches()
++
          return ret
 +    # clean_caches()
 +    #
 +    # Clean internal loader caches, recursively
 +    #
 +    # When loading the elements, the loaders use caches in order to not load the
 +    # same element twice. These are kept after loading and prevent garbage
 +    # collection. Cleaning them explicitely is required.
 +    #
 +    def _clean_caches(self):
 +        for loader in self._loaders.values():
 +            # value may be None with nested junctions without overrides
 +            if loader is not None:
 +                loader._clean_caches()
++
 +        self._meta_elements = {}
 +        self._elements = {}
++
      ###########################################
      #            Private Methods              #
      ###########################################

buildstream/_project.py

@@ -358,6 +358,8 @@ class Project():
                  for meta in meta_elements
+             ]
 +        Element._clear_meta_elements_cache()
++
          # Now warn about any redundant source references which may have
          # been discovered in the resolve() phase.
          redundant_refs = Element._get_redundant_source_refs()

buildstream/data/userconfig.yaml

@@ -41,6 +41,15 @@ cache:
    # Whether to pull build trees when downloading element artifacts
    pull-buildtrees: False
 +  # Whether to cache build trees on artifact creation:
 +  #
 +  #  always - Always cache artifact build tree content
 +  #  failure - Only cache build trees of failed builds
 +  #  never - Don't cache artifact build tree content
 +  #
 +  cache-buildtrees: always
++
++
+ #
  #    Scheduler
+ #

buildstream/element.py

@@ -966,6 +966,21 @@ class Element(Plugin):
          return element
 +    # _clear_meta_elements_cache()
 +    #
 +    # Clear the internal meta elements cache.
 +    #
 +    # When loading elements from meta, we cache already instantiated elements
 +    # in order to not have to load the same elements twice.
 +    # This clears the cache.
 +    #
 +    # It should be called whenever we are done loading all elements in order
 +    # to save memory.
 +    #
 +    @classmethod
 +    def _clear_meta_elements_cache(cls):
 +        cls.__instantiated_elements = {}
++
      # _get_redundant_source_refs()
+     #
      # Fetches a list of (Source, ref) tuples of all the Sources
@@ -1457,6 +1472,9 @@ class Element(Plugin):
              elif usebuildtree:
                  artifact_base, _ = self.__extract()
                  import_dir = os.path.join(artifact_base, 'buildtree')
 +                if not os.listdir(import_dir):
 +                    detail = "Element type either does not expect a buildtree or it was explictily cached without one."
 +                    self.warn("WARNING: {} Artifact contains an empty buildtree".format(self.name), detail=detail)
              else:
                  # No workspace or cached buildtree, stage source directly
                  for source in self.sources():
@@ -1663,6 +1681,8 @@ class Element(Plugin):
                  # No collect directory existed
                  collectvdir = None
 +        context = self._get_context()
++
          # Create artifact directory structure
          assembledir = os.path.join(rootdir, 'artifact')
          filesdir = os.path.join(assembledir, 'files')
@@ -1680,20 +1700,30 @@ class Element(Plugin):
          if collect is not None and collectvdir is not None:
              collectvdir.export_files(filesdir, can_link=True)
 -        try:
 -            sandbox_vroot = sandbox.get_virtual_directory()
 -            sandbox_build_dir = sandbox_vroot.descend(
 -                self.get_variable('build-root').lstrip(os.sep).split(os.sep))
 -            # Hard link files from build-root dir to buildtreedir directory
 -            sandbox_build_dir.export_files(buildtreedir)
 -        except VirtualDirectoryError:
 -            # Directory could not be found. Pre-virtual
 -            # directory behaviour was to continue silently
 -            # if the directory could not be found.
 -            pass
 +        cache_buildtrees = context.cache_buildtrees
 +        build_success = self.__build_result[0]
++
 +        # cache_buildtrees defaults to 'always', as such the
 +        # default behaviour is to attempt to cache them. If only
 +        # caching failed artifact buildtrees, then query the build
 +        # result. Element types without a build-root dir will be cached
 +        # with an empty buildtreedir regardless of this configuration.
++
 +        if cache_buildtrees == 'always' or (cache_buildtrees == 'failure' and not build_success):
 +            try:
 +                sandbox_vroot = sandbox.get_virtual_directory()
 +                sandbox_build_dir = sandbox_vroot.descend(
 +                    self.get_variable('build-root').lstrip(os.sep).split(os.sep))
 +                # Hard link files from build-root dir to buildtreedir directory
 +                sandbox_build_dir.export_files(buildtreedir)
 +            except VirtualDirectoryError:
 +                # Directory could not be found. Pre-virtual
 +                # directory behaviour was to continue silently
 +                # if the directory could not be found.
 +                pass
          # Copy build log
 -        log_filename = self._get_context().get_log_filename()
 +        log_filename = context.get_log_filename()
          self._build_log_path = os.path.join(logsdir, 'build.log')
          if log_filename:
              shutil.copyfile(log_filename, self._build_log_path)
@@ -1834,7 +1864,7 @@ class Element(Plugin):
              return True
          # Do not push elements that aren't cached, or that are cached with a dangling buildtree
 -        # artifact unless element type is expected to have an an empty buildtree directory
 +        # ref unless element type is expected to have an an empty buildtree directory
          if not self._cached_buildtree():
              return True
@@ -2036,6 +2066,8 @@ class Element(Plugin):
      # Returns:
      #     (bool): True if artifact cached with buildtree, False if
      #             element not cached or missing expected buildtree.
 +    #             Note this only confirms if a buildtree is present,
 +    #             not its contents.
+     #
      def _cached_buildtree(self):
          context = self._get_context()

tests/frontend/completions.py

@@ -23,6 +23,7 @@ MAIN_OPTIONS = [
      "--builders ",
      "-c ",
      "-C ",
 +    "--cache-buildtrees ",
      "--colors ",
      "--config ",
      "--debug ",
@@ -156,6 +157,7 @@ def test_options(cli, cmd, word_idx, expected):
  @pytest.mark.parametrize("cmd,word_idx,expected", [
      ('bst --on-error ', 2, ['continue ', 'quit ', 'terminate ']),
 +    ('bst --cache-buildtrees ', 2, ['always ', 'failure ', 'never ']),
      ('bst show --deps ', 3, ['all ', 'build ', 'none ', 'plan ', 'run ']),
      ('bst show --deps=', 2, ['all ', 'build ', 'none ', 'plan ', 'run ']),
      ('bst show --deps b', 3, ['build ']),

tests/integration/artifact.py

@@ -20,9 +20,12 @@
  import os
  import pytest
 +import shutil
  from buildstream.plugintestutils import cli_integration as cli
+-
 +from tests.testutils import create_artifact_share
 +from tests.testutils.site import HAVE_SANDBOX
 +from buildstream._exceptions import ErrorDomain
  pytestmark = pytest.mark.integration
@@ -66,3 +69,106 @@ def test_artifact_log(cli, tmpdir, datafiles):
      assert result.exit_code == 0
      # The artifact is cached under both a strong key and a weak key
      assert (log + log) == result.output
++
++
 +# A test to capture the integration of the cachebuildtrees
 +# behaviour, which by default is to include the buildtree
 +# content of an element on caching.
 +@pytest.mark.integration
 +@pytest.mark.datafiles(DATA_DIR)
 +@pytest.mark.skipif(not HAVE_SANDBOX, reason='Only available with a functioning sandbox')
 +def test_cache_buildtrees(cli, tmpdir, datafiles):
 +    project = os.path.join(datafiles.dirname, datafiles.basename)
 +    element_name = 'autotools/amhello.bst'
++
 +    # Create artifact shares for pull & push testing
 +    with create_artifact_share(os.path.join(str(tmpdir), 'share1')) as share1,\
 +        create_artifact_share(os.path.join(str(tmpdir), 'share2')) as share2,\
 +        create_artifact_share(os.path.join(str(tmpdir), 'share3')) as share3:
 +        cli.configure({
 +            'artifacts': {'url': share1.repo, 'push': True},
 +            'artifactdir': os.path.join(str(tmpdir), 'artifacts')
 +        })
++
 +        # Build autotools element with cache-buildtrees set via the
 +        # cli. The artifact should be successfully pushed to the share1 remote
 +        # and cached locally with an 'empty' buildtree digest, as it's not a
 +        # dangling ref
 +        result = cli.run(project=project, args=['--cache-buildtrees', 'never', 'build', element_name])
 +        assert result.exit_code == 0
 +        assert cli.get_element_state(project, element_name) == 'cached'
 +        assert share1.has_artifact('test', element_name, cli.get_element_key(project, element_name))
++
 +        # The extracted buildtree dir should be empty, as we set the config
 +        # to not cache buildtrees
 +        cache_key = cli.get_element_key(project, element_name)
 +        elementdigest = share1.has_artifact('test', element_name, cache_key)
 +        buildtreedir = os.path.join(str(tmpdir), 'artifacts', 'extract', 'test', 'autotools-amhello',
 +                                    elementdigest.hash, 'buildtree')
 +        assert os.path.isdir(buildtreedir)
 +        assert not os.listdir(buildtreedir)
++
 +        # Delete the local cached artifacts, and assert the when pulled with --pull-buildtrees
 +        # that is was cached in share1 as expected with an empty buildtree dir
 +        shutil.rmtree(os.path.join(str(tmpdir), 'artifacts'))
 +        assert cli.get_element_state(project, element_name) != 'cached'
 +        result = cli.run(project=project, args=['--pull-buildtrees', 'artifact', 'pull', element_name])
 +        assert element_name in result.get_pulled_elements()
 +        assert os.path.isdir(buildtreedir)
 +        assert not os.listdir(buildtreedir)
 +        shutil.rmtree(os.path.join(str(tmpdir), 'artifacts'))
++
 +        # Assert that the default behaviour of pull to not include buildtrees on the artifact
 +        # in share1 which was purposely cached with an empty one behaves as expected. As such the
 +        # pulled artifact will have a dangling ref for the buildtree dir, regardless of content,
 +        # leading to no buildtreedir being extracted
 +        result = cli.run(project=project, args=['artifact', 'pull', element_name])
 +        assert element_name in result.get_pulled_elements()
 +        assert not os.path.isdir(buildtreedir)
 +        shutil.rmtree(os.path.join(str(tmpdir), 'artifacts'))
++
 +        # Repeat building the artifacts, this time with the default behaviour of caching buildtrees,
 +        # as such the buildtree dir should not be empty
 +        cli.configure({
 +            'artifacts': {'url': share2.repo, 'push': True},
 +            'artifactdir': os.path.join(str(tmpdir), 'artifacts')
 +        })
 +        result = cli.run(project=project, args=['build', element_name])
 +        assert result.exit_code == 0
 +        assert cli.get_element_state(project, element_name) == 'cached'
 +        assert share2.has_artifact('test', element_name, cli.get_element_key(project, element_name))
++
 +        # Cache key will be the same however the digest hash will have changed as expected, so reconstruct paths
 +        elementdigest = share2.has_artifact('test', element_name, cache_key)
 +        buildtreedir = os.path.join(str(tmpdir), 'artifacts', 'extract', 'test', 'autotools-amhello',
 +                                    elementdigest.hash, 'buildtree')
 +        assert os.path.isdir(buildtreedir)
 +        assert os.listdir(buildtreedir) is not None
++
 +        # Delete the local cached artifacts, and assert that when pulled with --pull-buildtrees
 +        # that it was cached in share2 as expected with a populated buildtree dir
 +        shutil.rmtree(os.path.join(str(tmpdir), 'artifacts'))
 +        assert cli.get_element_state(project, element_name) != 'cached'
 +        result = cli.run(project=project, args=['--pull-buildtrees', 'artifact', 'pull', element_name])
 +        assert element_name in result.get_pulled_elements()
 +        assert os.path.isdir(buildtreedir)
 +        assert os.listdir(buildtreedir) is not None
 +        shutil.rmtree(os.path.join(str(tmpdir), 'artifacts'))
++
 +        # Clarify that the user config option for cache-buildtrees works as the cli
 +        # main option does. Point to share3 which does not have the artifacts cached to force
 +        # a build
 +        cli.configure({
 +            'artifacts': {'url': share3.repo, 'push': True},
 +            'artifactdir': os.path.join(str(tmpdir), 'artifacts'),
 +            'cache': {'cache-buildtrees': 'never'}
 +        })
 +        result = cli.run(project=project, args=['build', element_name])
 +        assert result.exit_code == 0
 +        assert cli.get_element_state(project, element_name) == 'cached'
 +        cache_key = cli.get_element_key(project, element_name)
 +        elementdigest = share3.has_artifact('test', element_name, cache_key)
 +        buildtreedir = os.path.join(str(tmpdir), 'artifacts', 'extract', 'test', 'autotools-amhello',
 +                                    elementdigest.hash, 'buildtree')
 +        assert os.path.isdir(buildtreedir)
 +        assert not os.listdir(buildtreedir)

tests/integration/build-tree.py → tests/integration/shellbuildtrees.py

@@ -52,6 +52,29 @@ def test_buildtree_staged_forced_true(cli_integration, tmpdir, datafiles):
      assert 'Hi' in res.output
 +@pytest.mark.datafiles(DATA_DIR)
 +@pytest.mark.skipif(not HAVE_SANDBOX, reason='Only available with a functioning sandbox')
 +def test_buildtree_staged_warn_empty_cached(cli_integration, tmpdir, datafiles):
 +    # Test that if we stage a cached and empty buildtree, we warn the user.
 +    project = os.path.join(datafiles.dirname, datafiles.basename)
 +    element_name = 'build-shell/buildtree.bst'
++
 +    # Switch to a temp artifact cache dir to ensure the artifact is rebuilt,
 +    # caching an empty buildtree
 +    cli_integration.configure({
 +        'artifactdir': os.path.join(os.path.join(str(tmpdir), 'artifacts'))
 +    })
++
 +    res = cli_integration.run(project=project, args=['--cache-buildtrees', 'never', 'build', element_name])
 +    res.assert_success()
++
 +    res = cli_integration.run(project=project, args=[
 +        'shell', '--build', '--use-buildtree', 'always', element_name, '--', 'cat', 'test'
 +    ])
 +    res.assert_shell_error()
 +    assert "Artifact contains an empty buildtree" in res.stderr
++
++
  @pytest.mark.datafiles(DATA_DIR)
  @pytest.mark.skipif(not HAVE_SANDBOX, reason='Only available with a functioning sandbox')
  def test_buildtree_staged_if_available(cli_integration, tmpdir, datafiles):
@@ -106,6 +129,54 @@ def test_buildtree_from_failure(cli_integration, tmpdir, datafiles):
      assert 'Hi' in res.output
 +@pytest.mark.datafiles(DATA_DIR)
 +@pytest.mark.skipif(not HAVE_SANDBOX, reason='Only available with a functioning sandbox')
 +def test_buildtree_from_failure_option_never(cli_integration, tmpdir, datafiles):
++
 +    project = os.path.join(datafiles.dirname, datafiles.basename)
 +    element_name = 'build-shell/buildtree-fail.bst'
++
 +    # Switch to a temp artifact cache dir to ensure the artifact is rebuilt,
 +    # caching an empty buildtree
 +    cli_integration.configure({
 +        'artifactdir': os.path.join(os.path.join(str(tmpdir), 'artifacts'))
 +    })
++
 +    res = cli_integration.run(project=project, args=['--cache-buildtrees', 'never', 'build', element_name])
 +    res.assert_main_error(ErrorDomain.STREAM, None)
++
 +    res = cli_integration.run(project=project, args=[
 +        'shell', '--build', element_name, '--use-buildtree', 'always', '--', 'cat', 'test'
 +    ])
 +    res.assert_shell_error()
 +    assert "Artifact contains an empty buildtree" in res.stderr
++
++
 +@pytest.mark.datafiles(DATA_DIR)
 +@pytest.mark.skipif(not HAVE_SANDBOX, reason='Only available with a functioning sandbox')
 +def test_buildtree_from_failure_option_failure(cli_integration, tmpdir, datafiles):
++
 +    project = os.path.join(datafiles.dirname, datafiles.basename)
 +    element_name = 'build-shell/buildtree-fail.bst'
++
 +    # build with  --cache-buildtrees set to 'failure', behaviour should match
 +    # default behaviour (which is always) as the buildtree will explicitly have been
 +    # cached with content.
 +    cli_integration.configure({
 +        'artifactdir': os.path.join(os.path.join(str(tmpdir), 'artifacts'))
 +    })
++
 +    res = cli_integration.run(project=project, args=['--cache-buildtrees', 'failure', 'build', element_name])
 +    res.assert_main_error(ErrorDomain.STREAM, None)
++
 +    res = cli_integration.run(project=project, args=[
 +        'shell', '--build', element_name, '--use-buildtree', 'always', '--', 'cat', 'test'
 +    ])
 +    res.assert_success()
 +    assert "WARNING: using a buildtree from a failed build" in res.stderr
 +    assert 'Hi' in res.output
++
++
  # Check that build shells work when pulled from a remote cache
  # This is to roughly simulate remote execution
  @pytest.mark.datafiles(DATA_DIR)

[Notes] [Git][BuildStream/buildstream][bschubert/cleanup-local-state] 6 commits: Add cli main & user conf option for 'cache-buildtrees' context

Benjamin Schubert pushed to branch bschubert/cleanup-local-state at BuildStream / buildstream

Commits:

12 changed files:

Changes: