_stream.py: Allow loading to handle artifact refs

buildstream/_stream.py

@@ -29,7 +29,7 @@ import tempfile
 from contextlib import contextmanager, suppress
 from fnmatch import fnmatch
 
-from ._exceptions import StreamError, ImplError, BstError, set_last_task_error
+from ._exceptions import StreamError, ImplError, BstError, ArtifactElementError, set_last_task_error
 from ._message import Message, MessageType
 from ._scheduler import Scheduler, SchedStatus, TrackQueue, FetchQueue, BuildQueue, PullQueue, PushQueue
 from ._pipeline import Pipeline, PipelineSelection
@@ -109,19 +109,21 @@ class Stream():
     def load_selection(self, targets, *,
                        selection=PipelineSelection.NONE,
                        except_targets=(),
-                       use_artifact_config=False):
+                       use_artifact_config=False,
+                       load_refs=False):
 
         profile_start(Topics.LOAD_SELECTION, "_".join(t.replace(os.sep, '-') for t in targets))
 
-        elements, _ = self._load(targets, (),
-                                 selection=selection,
-                                 except_targets=except_targets,
-                                 fetch_subprojects=False,
-                                 use_artifact_config=use_artifact_config)
+        target_objects, _ = self._load(targets, (),
+                                       selection=selection,
+                                       except_targets=except_targets,
+                                       fetch_subprojects=False,
+                                       use_artifact_config=use_artifact_config,
+                                       load_refs=load_refs)
 
         profile_end(Topics.LOAD_SELECTION, "_".join(t.replace(os.sep, '-') for t in targets))
 
-        return elements
+        return target_objects
 
     # shell()
     #
@@ -913,25 +915,40 @@ class Stream():
               use_artifact_config=False,
               artifact_remote_url=None,
               fetch_subprojects=False,
-              dynamic_plan=False):
+              dynamic_plan=False,
+              load_refs=False):
+
+        # Obtain cached refs and project element path needed to classify artifacts
+        cas = self._artifacts.cas
+        cached_refs = cas.list_refs()
+        project_element_path = self._project.element_path
+
+        # Classify element and artifact strings
+        target_elements, target_artifacts = self._classify_artifacts(targets, cached_refs, project_element_path)
+
+        if target_artifacts and not load_refs:
+            detail = ''.join(target_artifacts)
+            raise ArtifactElementError("Cannot perform this operation with artifact refs:", detail=detail)
 
         # Load rewritable if we have any tracking selection to make
         rewritable = False
         if track_targets:
             rewritable = True
 
-        # Load all targets
+        # Load all target elements
         elements, except_elements, track_elements, track_except_elements = \
-            self._pipeline.load([targets, except_targets, track_targets, track_except_targets],
+            self._pipeline.load([target_elements, except_targets, track_targets, track_except_targets],
                                 rewritable=rewritable,
                                 fetch_subprojects=fetch_subprojects)
 
+        artifacts = self._load_refs(target_artifacts)
+
         # Optionally filter out junction elements
         if ignore_junction_targets:
             elements = [e for e in elements if e.get_kind() != 'junction']
 
         # Hold on to the targets
-        self.targets = elements
+        self.targets = elements + artifacts
 
         # Here we should raise an error if the track_elements targets
         # are not dependencies of the primary targets, this is not
@@ -988,9 +1005,9 @@ class Stream():
 
         # Now move on to loading primary selection.
         #
-        self._pipeline.resolve_elements(elements)
-        selected = self._pipeline.get_selection(elements, selection, silent=False)
-        selected = self._pipeline.except_elements(elements,
+        self._pipeline.resolve_elements(self.targets)
+        selected = self._pipeline.get_selection(self.targets, selection, silent=False)
+        selected = self._pipeline.except_elements(self.targets,
                                                   selected,
                                                   except_elements)
 
@@ -1014,6 +1031,20 @@ class Stream():
 
         return selected, track_selected
 
+    # _load_refs()
+    #
+    #  Create and resolve ArtifactElement objects
+    #
+    def _load_refs(self, refs):
+        artifact_elements = []
+        for ref in refs:
+            artifact_element = self._project.create_artifact_element(ref)
+            artifact_elements.append(artifact_element)
+
+        self._pipeline.resolve_elements(artifact_elements)
+
+        return artifact_elements
+
     # _message()
     #
     # Local message propagator