buildstream/_artifactcache/cascache.py

@@ -845,6 +845,9 @@ class _CASRemote():
 
 
 def _grouper(iterable, n):
-    # pylint: disable=stop-iteration-return
     while True:
-        yield itertools.chain([next(iterable)], itertools.islice(iterable, n - 1))
+        try:
+            current = next(iterable)
+        except StopIteration:
+            return
+        yield itertools.chain([current], itertools.islice(iterable, n - 1))

buildstream/_frontend/app.py

@@ -275,6 +275,10 @@ class App():
 
             # Exit with the error
             self._error_exit(e)
+        except RecursionError:
+            click.echo("RecursionError: Depency depth is too large. Maximum recursion depth exceeded.",
+                       err=True)
+            sys.exit(-1)
 
         else:
             # No exceptions occurred, print session time and summary

buildstream/_frontend/cli.py

@@ -827,4 +827,5 @@ def source_bundle(app, element, force, directory,
         app.stream.source_bundle(element, directory,
                                  track_first=track_,
                                  force=force,
-                                 compression=compression)
+                                 compression=compression,
+                                 except_targets=except_)

buildstream/_frontend/complete.py

@@ -68,9 +68,10 @@ def complete_path(path_type, incomplete, base_directory='.'):
         # If there was nothing on the left of the last separator,
         # we are completing files in the filesystem root
         base_path = os.path.join(base_directory, base_path)
-
-    elif os.path.isdir(incomplete):
-        base_path = incomplete
+    else:
+        incomplete_base_path = os.path.join(base_directory, incomplete)
+        if os.path.isdir(incomplete_base_path):
+            base_path = incomplete_base_path
 
     try:
         if base_path:

buildstream/_stream.py

@@ -437,7 +437,7 @@ class Stream():
 
         except BstError as e:
             raise StreamError("Error while staging dependencies into a sandbox"
-                              ": '{}'".format(e), reason=e.reason) from e
+                              ": '{}'".format(e), detail=e.detail, reason=e.reason) from e
 
     # workspace_open
     #
@@ -478,7 +478,7 @@ class Stream():
 
         # Check for workspace config
         workspace = workspaces.get_workspace(target._get_full_name())
-        if workspace:
+        if workspace and not force:
             raise StreamError("Workspace '{}' is already defined at: {}"
                               .format(target.name, workspace.path))
 
@@ -497,6 +497,10 @@ class Stream():
                               "fetch the latest version of the " +
                               "source.")
 
+        if workspace:
+            workspaces.delete_workspace(target._get_full_name())
+            workspaces.save_config()
+            shutil.rmtree(directory)
         try:
             os.makedirs(directory, exist_ok=True)
         except OSError as e:
@@ -654,7 +658,8 @@ class Stream():
     def source_bundle(self, target, directory, *,
                       track_first=False,
                       force=False,
-                      compression="gz"):
+                      compression="gz",
+                      except_targets=()):
 
         if track_first:
             track_targets = (target,)
@@ -663,6 +668,7 @@ class Stream():
 
         elements, track_elements = self._load((target,), track_targets,
                                               selection=PipelineSelection.ALL,
+                                              except_targets=except_targets,
                                               track_selection=PipelineSelection.ALL,
                                               fetch_subprojects=True)
 

buildstream/element.py

@@ -194,6 +194,9 @@ class Element(Plugin):
 
     def __init__(self, context, project, artifacts, meta, plugin_conf):
 
+        self.__cache_key_dict = None            # Dict for cache key calculation
+        self.__cache_key = None                 # Our cached cache key
+
         super().__init__(meta.name, context, project, meta.provenance, "element")
 
         self.__is_junction = meta.kind == "junction"
@@ -212,8 +215,6 @@ class Element(Plugin):
         self.__runtime_dependencies = []        # Direct runtime dependency Elements
         self.__build_dependencies = []          # Direct build dependency Elements
         self.__sources = []                     # List of Sources
-        self.__cache_key_dict = None            # Dict for cache key calculation
-        self.__cache_key = None                 # Our cached cache key
         self.__weak_cache_key = None            # Our cached weak cache key
         self.__strict_cache_key = None          # Our cached cache key for strict builds
         self.__artifacts = artifacts            # Artifact cache
@@ -612,6 +613,12 @@ class Element(Plugin):
               dep.stage_artifact(sandbox)
         """
 
+        if not self._cached():
+            detail = "No artifacts have been cached yet for that element\n" + \
+                     "Try building the element first with `bst build`\n"
+            raise ElementError("No artifacts to stage",
+                               detail=detail, reason="uncached-checkout-attempt")
+
         if update_mtimes is None:
             update_mtimes = []
 

tests/completions/completions.py

@@ -212,6 +212,10 @@ def test_option_directory(datafiles, cli, cmd, word_idx, expected, subdir):
     # Also try multi arguments together
     ('no-element-path', 'bst --directory ../ checkout t ', 4, ['target.bst '], 'files'),
     ('no-element-path', 'bst --directory ../ checkout target.bst ', 5, ['bin-files/', 'dev-files/'], 'files'),
+
+    # When element-path have sub-folders
+    ('sub-folders', 'bst show base', 2, ['base/wanted.bst '], None),
+    ('sub-folders', 'bst show base/', 2, ['base/wanted.bst '], None),
 ])
 def test_argument_element(datafiles, cli, project, cmd, word_idx, expected, subdir):
     cwd = os.path.join(str(datafiles), project)

tests/completions/sub-folders/base/unwanted.bst

+kind: autotools
+description: |
+
+    Not auto-completed element

tests/completions/sub-folders/elements/base.bst

+kind: stack
+description: Base stack
+
+depends:
+- base/wanted.bst

tests/completions/sub-folders/elements/base/wanted.bst

+kind: autotools
+description: |
+
+    Auto-completed element

tests/completions/sub-folders/elements/hello.bst

+kind: autotools
+description: |
+
+    Hello world

tests/completions/sub-folders/project.conf

+# Project config for frontend build test
+name: test
+
+element-path: elements

tests/frontend/buildcheckout.py

@@ -96,6 +96,16 @@ def test_build_checkout_deps(datafiles, cli, deps):
         assert not os.path.exists(filename)
 
 
+@pytest.mark.datafiles(DATA_DIR)
+def test_build_checkout_unbuilt(datafiles, cli):
+    project = os.path.join(datafiles.dirname, datafiles.basename)
+    checkout = os.path.join(cli.directory, 'checkout')
+
+    # Check that checking out an unbuilt element fails nicely
+    result = cli.run(project=project, args=['checkout', 'target.bst', checkout])
+    result.assert_main_error(ErrorDomain.STREAM, "uncached-checkout-attempt")
+
+
 @pytest.mark.datafiles(DATA_DIR)
 def test_build_checkout_tarball(datafiles, cli):
     project = os.path.join(datafiles.dirname, datafiles.basename)

tests/frontend/show.py

 import os
-import pytest
+import sys
+import shutil
 import itertools
+import pytest
 from tests.testutils import cli, generate_junction
 
 from buildstream import _yaml
@@ -232,3 +234,58 @@ def test_fetched_junction(cli, tmpdir, datafiles, element_name):
 
     results = result.output.strip().splitlines()
     assert 'junction.bst:import-etc.bst-buildable' in results
+
+
+###############################################################
+#                   Testing recursion depth                   #
+###############################################################
+@pytest.mark.parametrize("dependency_depth", [100, 500, 1200])
+def test_exceed_max_recursion_depth(cli, tmpdir, dependency_depth):
+    project_name = "recursion-test"
+    path = str(tmpdir)
+    project_path = os.path.join(path, project_name)
+
+    def setup_test():
+        """
+        Creates a bst project with dependencydepth + 1 elements, each of which
+        depends of the previous element to be created. Each element created
+        is of type import and has an empty source file.
+        """
+        os.mkdir(project_path)
+
+        result = cli.run(project=project_path, silent=True,
+                         args=['init', '--project-name', project_name])
+        result.assert_success()
+
+        sourcefiles_path = os.path.join(project_path, "files")
+        os.mkdir(sourcefiles_path)
+
+        element_path = os.path.join(project_path, "elements")
+        for i in range(0, dependency_depth + 1):
+            element = {
+                'kind': 'import',
+                'sources': [{'kind': 'local',
+                             'path': 'files/source{}'.format(str(i))}],
+                'depends': ['element{}.bst'.format(str(i - 1))]
+            }
+            if i == 0:
+                del element['depends']
+            _yaml.dump(element, os.path.join(element_path, "element{}.bst".format(str(i))))
+
+            source = os.path.join(sourcefiles_path, "source{}".format(str(i)))
+            open(source, 'x').close()
+            assert os.path.exists(source)
+
+    setup_test()
+    result = cli.run(project=project_path, silent=True,
+                     args=['show', "element{}.bst".format(str(dependency_depth))])
+
+    recursion_limit = sys.getrecursionlimit()
+    if dependency_depth <= recursion_limit:
+        result.assert_success()
+    else:
+        #  Assert exception is thown and handled
+        assert not result.unhandled_exception
+        assert result.exit_code == -1
+
+    shutil.rmtree(project_path)

tests/frontend/workspace.py

@@ -123,6 +123,58 @@ def test_open_force(cli, tmpdir, datafiles, kind):
     result.assert_success()
 
 
+@pytest.mark.datafiles(DATA_DIR)
+@pytest.mark.parametrize("kind", repo_kinds)
+def test_open_force_open(cli, tmpdir, datafiles, kind):
+    element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, kind, False)
+
+    # Assert the workspace dir exists
+    assert os.path.exists(workspace)
+
+    # Now open the workspace again with --force, this should happily succeed
+    result = cli.run(project=project, args=[
+        'workspace', 'open', '--force', element_name, workspace
+    ])
+    result.assert_success()
+
+
+@pytest.mark.datafiles(DATA_DIR)
+@pytest.mark.parametrize("kind", repo_kinds)
+def test_open_force_different_workspace(cli, tmpdir, datafiles, kind):
+    element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, kind, False, "-alpha")
+
+    # Assert the workspace dir exists
+    assert os.path.exists(workspace)
+
+    hello_path = os.path.join(workspace, 'usr', 'bin', 'hello')
+    hello1_path = os.path.join(workspace, 'usr', 'bin', 'hello1')
+
+    tmpdir = os.path.join(str(tmpdir), "-beta")
+    shutil.move(hello_path, hello1_path)
+    element_name2, project2, workspace2 = open_workspace(cli, tmpdir, datafiles, kind, False, "-beta")
+
+    # Assert the workspace dir exists
+    assert os.path.exists(workspace2)
+
+    # Assert that workspace 1 contains the modified file
+    assert os.path.exists(hello1_path)
+
+    # Assert that workspace 2 contains the unmodified file
+    assert os.path.exists(os.path.join(workspace2, 'usr', 'bin', 'hello'))
+
+    # Now open the workspace again with --force, this should happily succeed
+    result = cli.run(project=project, args=[
+        'workspace', 'open', '--force', element_name2, workspace
+    ])
+
+    # Assert that the file in workspace 1 has been replaced
+    # With the file from workspace 2
+    assert os.path.exists(hello_path)
+    assert not os.path.exists(hello1_path)
+
+    result.assert_success()
+
+
 @pytest.mark.datafiles(DATA_DIR)
 @pytest.mark.parametrize("kind", repo_kinds)
 def test_close(cli, tmpdir, datafiles, kind):