[Notes] [Git][BuildStream/buildstream][chandan/dot-graph] 5 commits: Add

Chandan Singh pushed to branch chandan/dot-graph 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

fe119c4b

by Chandan Singh at 2019-02-13T16:12:59Z

contrib/bst-graph: Add script to print graph in DOT format

This script leverages the recently added format strings
(`%{build-deps}`, `%{runtime-deps}`) to `bst show` to print a graph in
DOT format. This requires users to have the `graphviz` python package
installed.

Additionally, users can also render the graph using the `--format`
option if they have the `graphviz` command line tool installed.

10 changed files:

NEWS
buildstream/_context.py
buildstream/_frontend/app.py
buildstream/_frontend/cli.py
buildstream/data/userconfig.yaml
buildstream/element.py
+ contrib/bst-graph
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/_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/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

@@ -1457,6 +1457,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 +1666,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 +1685,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 +1849,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 +2051,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()

contrib/bst-graph

 +#!/usr/bin/env python3
 +'''Print dependency graph of given element(s) in DOT format.
++
 +This script must be run from the same directory where you would normally
 +run `bst` commands.
++
 +When `--format` option is specified, the output will also be rendered in the
 +given format. A file with name `bst-graph.{format}` will be created in the same
 +directory. To use this option, you must have the `graphviz` command line tool
 +installed.
 +'''
++
 +import argparse
 +import subprocess
++
 +from graphviz import Digraph
++
++
 +def parse_args():
 +    '''Handle parsing of command line arguments.
++
 +    Returns:
 +       A argparse.Namespace object
 +    '''
 +    parser = argparse.ArgumentParser(description=__doc__)
 +    parser.add_argument(
 +        'ELEMENT', nargs='*',
 +        help='Name of the element'
 +    )
 +    parser.add_argument(
 +        '--format',
 +        help='Redner the graph in given format (`pdf`, `png`, `svg` etc)'
 +    )
 +    parser.add_argument(
 +        '--view', action='store_true',
 +        help='Open the rendered graph with the default application'
 +    )
 +    return parser.parse_args()
++
++
 +def parse_graph(lines):
 +    '''Return nodes and edges of the parsed grpah.
++
 +    Args:
 +       lines: List of lines in format 'NAME|BUILD-DEPS|RUNTIME-DEPS'
++
 +    Returns:
 +       Tuple of format (nodes,build_deps,runtime_deps)
 +       Each member of build_deps and runtime_deps is also a tuple.
 +    '''
 +    nodes = set()
 +    build_deps = set()
 +    runtime_deps = set()
 +    for line in lines:
 +        # It is safe to split on '|' as it is not a valid character for
 +        # element names.
 +        name, build_dep, runtime_dep = line.split('|')
 +        build_dep = build_dep.lstrip('[').rstrip(']').split(',')
 +        runtime_dep = runtime_dep.lstrip('[').rstrip(']').split(',')
 +        nodes.add(name)
 +        [build_deps.add((name, dep)) for dep in build_dep if dep]
 +        [runtime_deps.add((name, dep)) for dep in runtime_dep if dep]
++
 +    return nodes, build_deps, runtime_deps
++
++
 +def generate_graph(nodes, build_deps, runtime_deps):
 +    '''Generate graph from given nodes and edges.
++
 +    Args:
 +       nodes: set of nodes
 +       build_deps: set of tuples of build depdencies
 +       runtime_deps: set of tuples of runtime depdencies
++
 +    Returns:
 +       A graphviz.Digraph object
 +    '''
 +    graph = Digraph()
 +    for node in nodes:
 +        graph.node(node)
 +    for source, target in build_deps:
 +        graph.edge(source, target, label='build-dep')
 +    for source, target in runtime_deps:
 +        graph.edge(source, target, label='runtime-dep')
 +    return graph
++
++
 +def main():
 +    args = parse_args()
 +    cmd = ['bst', 'show', '--format', '%{name}|%{build-deps}|%{runtime-deps}']
 +    if 'element' in args:
 +        cmd += args.element
 +    graph_lines = subprocess.check_output(cmd, universal_newlines=True)
 +    # NOTE: We generate nodes and edges before giving them to graphviz as
 +    # the library does not de-deuplicate them.
 +    nodes, build_deps, runtime_deps = parse_graph(graph_lines.splitlines())
 +    graph = generate_graph(nodes, build_deps, runtime_deps)
 +    print(graph.source)
 +    if args.format:
 +        graph.render(cleanup=True,
 +                     filename='bst-graph',
 +                     format=args.format,
 +                     view=args.view)
++
++
 +if __name__ == '__main__':
 +    main()

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][chandan/dot-graph] 5 commits: Add cli main & user conf option for 'cache-buildtrees' context

Chandan Singh pushed to branch chandan/dot-graph at BuildStream / buildstream

Commits:

10 changed files:

Changes: