jolt 0.9.342__py3-none-any.whl → 0.9.429__py3-none-any.whl

jolt/cli.py

@@ -18,13 +18,12 @@ from jolt import log
 from jolt import __version__
 from jolt.log import logfile
 from jolt import config
-from jolt.loader import JoltLoader
+from jolt.loader import JoltLoader, import_workspace
 from jolt import tools
 from jolt import utils
 from jolt.influence import HashInfluenceRegistry
 from jolt.options import JoltOptions
 from jolt import hooks
-from jolt.manifest import JoltManifest
 from jolt.error import JoltError
 from jolt.error import raise_error
 from jolt.error import raise_error_if
@@ -92,6 +91,7 @@ class PluginGroup(click.Group):
               help="Add salt as task influence.")
 @click.option("-g", "--debug", is_flag=True, default=False, hidden=True,
               help="Start debug shell before executing task.")
+@click.option("-m", "--mute", is_flag=True, help="Display task log only if it fails.")
 @click.option("-n", "--network", is_flag=True, default=False, hidden=True,
               help="Build on network.")
 @click.option("-l", "--local", is_flag=True, default=False, hidden=True,
@@ -103,7 +103,7 @@ class PluginGroup(click.Group):
 @click.option("-h", "--help", is_flag=True, help="Show this message and exit.")
 @click.pass_context
 def cli(ctx, verbose, config_file, debugger, profile,
-        force, salt, debug, network, local, keep_going, jobs, help, machine_interface, chdir):
+        force, salt, debug, mute, network, local, keep_going, jobs, help, machine_interface, chdir):
     """
     A task execution tool.
 
@@ -156,23 +156,9 @@ def cli(ctx, verbose, config_file, debugger, profile,
         print(ctx.get_help())
         sys.exit(0)
 
-    manifest = JoltManifest()
-    utils.call_and_catch(manifest.parse)
-    manifest.process_import()
-    ctx.obj["manifest"] = manifest
-
-    if manifest.version:
-        from jolt.version_utils import requirement, version
-        req = requirement(manifest.version)
-        ver = version(__version__)
-        raise_error_if(not req.satisfied(ver),
-                       "This project requires Jolt version {} (running {})",
-                       req, __version__)
-
+    registry = TaskRegistry.get()
     loader = JoltLoader.get()
-    tasks = loader.load()
-    for cls in tasks:
-        TaskRegistry.get().add_task_class(cls)
+    loader.load(registry)
 
     if ctx.invoked_subcommand in ["build", "clean"] and loader.joltdir:
         ctx.obj["workspace_lock"] = utils.LockFile(
@@ -185,8 +171,8 @@ def cli(ctx, verbose, config_file, debugger, profile,
     if ctx.invoked_subcommand is None:
         task = config.get("jolt", "default", "default")
         taskname, _ = utils.parse_task_name(task)
-        if TaskRegistry.get().get_task_class(taskname) is not None:
-            ctx.invoke(build, task=[task], force=force, salt=salt, debug=debug,
+        if registry.get_task_class(taskname) is not None:
+            ctx.invoke(build, task=[task], force=force, salt=salt, debug=debug, mute=mute,
                        network=network, local=local, keep_going=keep_going, jobs=jobs)
         else:
             print(cli.get_help(ctx))
@@ -194,11 +180,8 @@ def cli(ctx, verbose, config_file, debugger, profile,
 
 
 def _autocomplete_tasks(ctx, args, incomplete):
-    manifest = JoltManifest()
-    utils.call_and_catch(manifest.parse)
-    manifest.process_import()
-
-    tasks = JoltLoader.get().load()
+    loader = JoltLoader.get()
+    tasks = loader.load()
     tasks = [task.name for task in tasks if task.name.startswith(incomplete or '')]
     return sorted(tasks)
 
@@ -234,12 +217,13 @@ def _autocomplete_tasks(ctx, args, incomplete):
               help="Don't prune cached artifacts from the build graph. This option can be used to populate the local cache with remotely cached dependency artifacts.")
 @click.option("--worker", is_flag=True, default=False,
               help="Run with the worker build strategy", hidden=True)
+@click.option("--environ", type=click.Path(), help="Import build environment from protobuf", hidden=True)
 @click.pass_context
 @hooks.cli_build
 def build(ctx, task, network, keep_going, default, local,
           no_download, no_download_persistent, no_upload, download, upload, worker, force,
           salt, copy, debug, result, jobs, no_prune, verbose,
-          mute):
+          mute, environ):
     """
     Build task artifact.
 
@@ -271,6 +255,7 @@ def build(ctx, task, network, keep_going, default, local,
     are removed before execution starts.
 
     """
+
     raise_error_if(network and local,
                    "The -n and -l flags are mutually exclusive")
 
@@ -322,6 +307,33 @@ def build(ctx, task, network, keep_going, default, local,
     if keep_going:
         config.set_keep_going(True)
 
+    # Import build environment from protobuf if provided
+    buildenv = None
+    if environ:
+        with open(environ, "rb") as f:
+            from jolt import common_pb2 as common_pb
+            buildenv = common_pb.BuildEnvironment()
+            try:
+                buildenv.ParseFromString(f.read())
+            except Exception as e:
+                raise_error("Failed to parse build environment protobuf: {}", e)
+
+        # Import log level
+        log.set_level_pb(buildenv.loglevel)
+
+        # Import workspace
+        import_workspace(buildenv)
+
+        # Import configuration snippet
+        config.import_config(buildenv.config)
+
+        # Import configuration parameters (-c params.key)
+        config.import_params({param.key: param.value for param in buildenv.parameters})
+
+        # Import default parameters (-d taskname:param=value)
+        default = utils.as_list(default)
+        default += buildenv.task_default_parameters
+
     options = JoltOptions(
         network=network,
         local=local,
@@ -356,26 +368,20 @@ def build(ctx, task, network, keep_going, default, local,
     for params in default:
         registry.set_default_parameters(params)
 
-    manifest = ctx.obj["manifest"]
-
-    for mb in manifest.builds:
-        for mt in mb.tasks:
-            task.append(mt.name)
-        for mt in mb.defaults:
-            registry.set_default_parameters(mt.name)
-
-    if force:
-        for goal in task:
-            registry.get_task(goal, manifest=manifest).taint = uuid.uuid4()
-
     log.info("Started: {}", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
 
-    gb = graph.GraphBuilder(registry, acache, manifest, options, progress=True)
+    gb = graph.GraphBuilder(registry, acache, options, progress=True, buildenv=buildenv)
     dag = gb.build(task)
 
+    # If asked to force rebuild, taint all goal tasks
+    if force:
+        for goal in dag.goals:
+            goal.get_extended_task().taint()
+
     # Collect information about artifact presence before starting prune or build
     acache.precheck(dag.persistent_artifacts, remote=not local)
 
+    # Prune the graph to remove tasks that are already available locally or remotely
     if not no_prune:
         gp = graph.GraphPruner(acache, strategy)
         dag = gp.prune(dag)
@@ -384,7 +390,7 @@ def build(ctx, task, network, keep_going, default, local,
     goal_task_duration = 0
 
     session = executors.create_session(dag) if options.network else {}
-    queue = scheduler.TaskQueue(strategy, acache, session)
+    queue = scheduler.TaskQueue()
 
     try:
         if not dag.has_tasks():
@@ -398,16 +404,20 @@ def build(ctx, task, network, keep_going, default, local,
             debug=debug)
 
         with progress:
+            in_progress = set()
+
             while dag.has_tasks() or not queue.empty():
                 # Find all tasks ready to be executed
-                leafs = dag.select(lambda graph, task: task.is_ready())
+                leafs = dag.select(lambda graph, task: task.is_ready() and task not in in_progress)
 
                 # Order the tasks by their weights to improve build times
                 leafs.sort(key=lambda x: x.weight)
 
                 while leafs:
                     task = leafs.pop()
-                    queue.submit(task)
+                    executor = strategy.create_executor(session, task)
+                    queue.submit(executor)
+                    in_progress.add(task)
 
                 task, error = queue.wait()
 
@@ -430,6 +440,7 @@ def build(ctx, task, network, keep_going, default, local,
 
                 if not keep_going and error is not None:
                     queue.abort()
+                    executors.shutdown()
                     task.raise_for_status()
                     raise error
 
@@ -448,6 +459,7 @@ def build(ctx, task, network, keep_going, default, local,
         log.warning("Interrupted by user")
         try:
             queue.abort()
+            executors.shutdown()
             sys.exit(1)
         except KeyboardInterrupt:
             print()
@@ -502,7 +514,7 @@ def clean(ctx, task, deps, expired):
     if task:
         task = [utils.stable_task_name(t) for t in task]
         registry = TaskRegistry.get()
-        dag = graph.GraphBuilder(registry, acache, ctx.obj["manifest"]).build(task)
+        dag = graph.GraphBuilder(registry, acache).build(task)
         if deps:
             tasks = dag.tasks
         else:
@@ -649,7 +661,7 @@ def display(ctx, task, reverse=None, show_cache=False, prune=False):
     registry = TaskRegistry.get()
     options = JoltOptions()
     acache = cache.ArtifactCache.get(options)
-    gb = graph.GraphBuilder(registry, acache, ctx.obj["manifest"])
+    gb = graph.GraphBuilder(registry, acache)
     dag = gb.build(task, influence=show_cache)
 
     if reverse:
@@ -746,15 +758,14 @@ def download(ctx, task, deps, copy, copy_all):
     if copy_all:
         deps = True
 
-    manifest = ctx.obj["manifest"]
     options = JoltOptions()
     acache = cache.ArtifactCache.get(options)
     hooks.TaskHookRegistry.get(options)
     executors = scheduler.ExecutorRegistry.get(options)
     registry = TaskRegistry.get()
     strategy = scheduler.DownloadStrategy(executors, acache)
-    queue = scheduler.TaskQueue(strategy, acache, {})
-    gb = graph.GraphBuilder(registry, acache, manifest, options, progress=True)
+    queue = scheduler.TaskQueue()
+    gb = graph.GraphBuilder(registry, acache, options, progress=True)
     dag = gb.build(task)
 
     if not deps:
@@ -767,12 +778,16 @@ def download(ctx, task, deps, copy, copy_all):
 
     try:
         with log.progress("Progress", dag.number_of_tasks(), " tasks", estimates=False, debug=False) as p:
+            in_progress = set()
+
             while dag.has_tasks() or not queue.empty():
-                leafs = dag.select(lambda graph, task: task.is_ready())
+                leafs = dag.select(lambda graph, task: task.is_ready() and task not in in_progress)
 
                 while leafs:
                     task = leafs.pop()
-                    queue.submit(task)
+                    executor = strategy.create_executor({}, task)
+                    queue.submit(executor)
+                    in_progress.add(task)
 
                 task, error = queue.wait()
                 p.update(1)
@@ -795,6 +810,7 @@ def download(ctx, task, deps, copy, copy_all):
         log.warning("Interrupted by user")
         try:
             queue.abort()
+            executors.shutdown()
             sys.exit(1)
         except KeyboardInterrupt:
             print()
@@ -809,54 +825,6 @@ def download(ctx, task, deps, copy, copy_all):
         queue.shutdown()
 
 
-@cli.command(hidden=True)
-@click.argument("task", type=str, nargs=-1, required=True)
-@click.option("-r", "--remove", is_flag=True, help="Remove tasks from existing manifest.")
-@click.option("-d", "--default", type=str, multiple=True, help="Override default parameter values.")
-@click.option("-o", "--output", type=str, default="default.joltxmanifest", help="Manifest filename.")
-@click.pass_context
-def freeze(ctx, task, default, output, remove):
-    """
-    Freeze the identity of a task.
-
-    <WIP>
-    """
-    manifest = ctx.obj["manifest"]
-
-    options = JoltOptions(default=default)
-    acache = cache.ArtifactCache.get(options)
-    scheduler.ExecutorRegistry.get(options)
-    registry = TaskRegistry.get()
-
-    for params in default:
-        registry.set_default_parameters(params)
-
-    gb = graph.GraphBuilder(registry, acache, manifest)
-    dag = gb.build(task)
-
-    available, missing = acache.availability(dag.persistent_artifacts)
-
-    for artifact in missing:
-        raise_task_error_if(
-            not remove, artifact.get_task(),
-            "Task artifact is not available in any cache, build it first")
-
-    for task in dag.tasks:
-        if task.is_resource() or not task.is_cacheable():
-            continue
-        manifest_task = manifest.find_task(task)
-        if remove and manifest_task:
-            manifest.remove_task(manifest_task)
-            continue
-        if not remove:
-            if not manifest_task:
-                manifest_task = manifest.create_task()
-            manifest_task.name = task.qualified_name
-            manifest_task.identity = task.identity
-
-    manifest.write(fs.path.join(JoltLoader.get().joltdir, output))
-
-
 @cli.command(name="list")
 @click.argument("task", type=str, nargs=-1, required=False, shell_complete=_autocomplete_tasks)
 @click.option("-a", "--all", is_flag=True, help="List all direct and indirect dependencies of TASK.")
@@ -892,7 +860,7 @@ def _list(ctx, task=None, all=False, reverse=None):
     reverse = [utils.stable_task_name(t) for t in utils.as_list(reverse or [])]
 
     try:
-        dag = graph.GraphBuilder(registry, acache, ctx.obj["manifest"]).build(task, influence=False)
+        dag = graph.GraphBuilder(registry, acache).build(task, influence=False)
     except JoltError as e:
         raise e
     except Exception:
@@ -992,9 +960,8 @@ def inspect(ctx, task, influence=False, artifact=False, salt=None):
 
     print()
     print("  Requirements")
-    manifest = ctx.obj["manifest"]
     try:
-        task = task_registry.get_task(task_name, manifest=manifest)
+        task = task_registry.get_task(task_name)
         for req in sorted(utils.as_list(utils.call_or_return(task, task.requires))):
             print("    {0}".format(task.tools.expand(req)))
         if not task.requires:
@@ -1016,7 +983,7 @@ def inspect(ctx, task, influence=False, artifact=False, salt=None):
     if artifact:
         options = JoltOptions(salt=salt)
         acache = cache.ArtifactCache.get()
-        builder = graph.GraphBuilder(task_registry, acache, manifest, options)
+        builder = graph.GraphBuilder(task_registry, acache, options)
         dag = builder.build([task.qualified_name])
         tasks = dag.select(lambda graph, node: node.task is task)
         assert len(tasks) == 1, "graph produced multiple tasks, one expected"
@@ -1080,7 +1047,7 @@ def _export(ctx, task):
     executors = scheduler.ExecutorRegistry.get()
     strategy = scheduler.LocalStrategy(executors, acache)
 
-    dag = graph.GraphBuilder(registry, acache, ctx.obj["manifest"])
+    dag = graph.GraphBuilder(registry, acache)
     dag = dag.build(task)
 
     gp = graph.GraphPruner(acache, strategy)
@@ -1110,7 +1077,7 @@ def _export(ctx, task):
     for task in context.tasks:
         for artifact in task.artifacts:
             raise_task_error_if(
-                artifact.is_temporary(), task,
+                not task.is_resource() and artifact.is_temporary(), task,
                 "Task artifact not found in local cache, build it first")
 
             visitor = Export()

jolt/config.py

@@ -7,7 +7,6 @@ from jolt import common_pb2 as common_pb
 from jolt import filesystem as fs
 from jolt import utils
 from jolt.error import raise_error_if
-from jolt.manifest import ManifestExtension, ManifestExtensionRegistry
 
 
 _workdir = os.getcwd()
@@ -318,39 +317,28 @@ def split(string):
     return section, key
 
 
-class ConfigExtension(ManifestExtension):
-    def export_manifest(self, manifest, _):
-        manifest.config = get("network", "config", "", expand=False)
-
-        for key, value in options("params"):
-            p = manifest.create_parameter()
-            p.key = "config." + key
-            p.value = value
-
-    def import_manifest(self, manifest):
-        if manifest.config:
-            _manifest.read_string(manifest.config)
-            from jolt.loader import JoltLoader
-            JoltLoader.get().load_plugins()
-
-        for param in manifest.parameters:
-            if param.key.startswith("config."):
-                set("params", param.key.split(".", 1)[1], param.value)
-
-    def import_protobuf(self, pb):
-        self.import_manifest(pb)
+def import_config(snippet: str):
+    """ Apply extra configuration for the worker, provided by the client. """
+    _manifest.read_string(snippet)
+    from jolt.loader import JoltLoader
+    JoltLoader.get().load_plugins()
 
 
 def export_config():
+    """ Get extra configuration for the worker. """
     return get("network", "config", "", expand=False)
 
 
+def import_params(params: dict):
+    """ Apply user-defined parameters (-c params.key=value). """
+    for key, value in params.items():
+        if key.startswith("config."):
+            set("params", key.split(".", 1)[1], value)
+
+
 def export_params():
+    """ Get user-defined parameters (-c params.key=value). """
     parameters = []
     for key, value in options("params"):
         parameters.append(common_pb.Property(key="config." + key, value=value))
     return parameters
-
-
-# High priority so that plugins are loaded before resources are acquired.
-ManifestExtensionRegistry.add(ConfigExtension(), -10)

jolt/filesystem.py

@@ -88,10 +88,10 @@ def move(src, dst):
 
 def onerror_warning(func, path, exc_info):
     from jolt import log
-    if type(exc_info[1]) is OSError:
+    if hasattr(exc_info[1], "strerror"):
         msg = exc_info[1].strerror
     else:
-        msg = "Reason unknown"
+        msg = "Reason unknown: " + str(exc_info[1])
     if os.path.exists(path):
         log.warning("Could not remove file or directory: {} ({})", path, msg)
 

jolt/graph.py

@@ -216,7 +216,7 @@ class TaskProxy(object):
         for c in self.children:
             if c.is_resource() or c.is_alias():
                 continue
-            if not c.is_available_locally():
+            if not c.is_available_locally(persistent_only=True):
                 return False
         return True
 
@@ -335,16 +335,32 @@ class TaskProxy(object):
         self._download = False
 
     def download(self, force=False, session_only=False, persistent_only=False):
+        """
+        Downloads all artifacts of this task.
+
+        If the task is not downloadable, the method returns True. Failure to
+        download persistent artifacts is considered a failure, and the method
+        returns False. Session artifacts are not required to be downloaded.
+
+        :param force: Force download even if the artifacts are already available.
+        :param session_only: Download only session artifacts.
+        :param persistent_only: Download only persistent artifacts.
+
+        """
         if not force and not self.is_downloadable():
             return True
+        success = True
         artifacts = self._artifacts
-        if session_only:
-            artifacts = list(filter(lambda a: a.is_session(), artifacts))
-        if persistent_only:
-            artifacts = list(filter(lambda a: not a.is_session(), artifacts))
-        if not artifacts:
-            return True
-        return all([self.cache.download(artifact, force=force) for artifact in artifacts])
+        artifacts_session = list(filter(lambda a: a.is_session(), artifacts))
+        artifacts_persistent = list(filter(lambda a: not a.is_session(), artifacts))
+        download_all = not session_only and not persistent_only
+        if session_only or download_all:
+            for artifact in artifacts_session:
+                if not self.cache.download(artifact, force=force):
+                    self.warning("Failed to download session artifact: {}", artifact.identity)
+        if persistent_only or download_all:
+            success = all([self.cache.download(artifact, force=force) for artifact in artifacts_persistent])
+        return success
 
     def upload(self, force=False, locked=False, session_only=False, persistent_only=False, artifacts=None):
         artifacts = artifacts or self._artifacts
@@ -408,9 +424,8 @@ class TaskProxy(object):
         self._owner = owner
         self.task.exported_name = f"{self.short_qualified_name}@@{owner.short_qualified_name}"
 
-    def finalize(self, dag, manifest):
+    def finalize(self, dag):
         log.debug("Finalizing: " + self.short_qualified_name)
-        self.manifest = manifest
 
         # Find all direct and transitive dependencies
         self.ancestors = set()
@@ -426,9 +441,10 @@ class TaskProxy(object):
                 self.children.extend(n.children)
             n.ancestors.add(self)
 
-        # Exclude transitive alias and resources dependencies
+        # Exclude transitive alias and resources dependencies.
+        # Workspace resources are included as they may be required by its dependencies.
         self.children = list(
-            filter(lambda n: not n.is_alias() and (not n.is_resource() or dag.are_neighbors(self, n)),
+            filter(lambda n: dag.are_neighbors(self, n) or (not n.is_alias() and not n.is_resource()),
                    utils.unique_list(self.children)))
 
         # Prepare workspace resources for this task so that influence can be calculated
@@ -451,11 +467,23 @@ class TaskProxy(object):
         self._artifacts.extend(self.task._artifacts(self.cache, self))
 
     def taint(self, salt=None):
-        self.task.taint = self.task.taint or salt or uuid.uuid4()
+        self.task.taint = salt or uuid.uuid4()
         if salt is None:
             # Only recalculate identity when build is forced, not when salted
             self.identity = None
             self.identity
+            # Recreate artifacts
+            self._artifacts = []
+            self.finalize_artifacts()
+
+        # If this is an alias, taint all children
+        if self.is_alias():
+            for child in self.children:
+                child.taint()
+
+        # Taint all extensions
+        for extension in self.extensions:
+            extension.taint()
 
     def queued(self, remote=True):
         self.task.verbose("Task queued " + self.log_name)
@@ -716,8 +744,7 @@ class TaskProxy(object):
         log_prefix = False
 
         # Collect list of resource dependencies
-        resource_deps = [child for child in self.children if child.is_resource() and not child.is_workspace_resource()]
-        resource_deps_ws = [child for child in self.children if child.is_workspace_resource()]
+        resource_deps = [child for child in self.children if child.is_resource()]
 
         if self.options.worker:
             # Exclude local resources when running as worker. They are already acquired by the client.
@@ -732,8 +759,11 @@ class TaskProxy(object):
         acquired = []
         try:
             # Acquire resource dependencies in reverse order.
-            for resource in reversed(resource_deps + resource_deps_ws):
-                with resource.lock_artifacts(discard=False) if not resource.is_workspace_resource() else nullcontext():
+            for resource in reversed(resource_deps):
+                # Always discard resource artifacts before acquiring the resource.
+                # They should not exist in the cache when the resource is acquired,
+                # but may exist if the resource was previously acquired by an interrupted build.
+                with resource.lock_artifacts(discard=True) if not resource.is_workspace_resource() else nullcontext():
                     resource.deps = self.cache.get_context(resource)
                     exitstack.enter_context(resource.deps)
 
@@ -763,7 +793,6 @@ class TaskProxy(object):
             self._run_task(env, force_upload, force_build)
 
     def _run_task(self, env, force_upload=False, force_build=False):
-        cache = env.cache
         queue = env.queue
 
         with self.tools:
@@ -777,7 +806,7 @@ class TaskProxy(object):
                     self.skipped()
                     return
 
-                available_remotely = cache.download_enabled() and self.is_available_remotely()
+                available_remotely = self.cache.download_enabled() and self.is_available_remotely()
                 if not available_locally and available_remotely:
                     available_locally = self.download()
 
@@ -796,7 +825,7 @@ class TaskProxy(object):
                         upload_session_artifacts = False
 
                         try:
-                            context = cache.get_context(self)
+                            context = self.cache.get_context(self)
                             exitstack.enter_context(context)
 
                             self.running_execution()
@@ -865,7 +894,7 @@ class TaskProxy(object):
                             if force_upload or force_build or not available_remotely:
                                 raise_task_error_if(
                                     not self.upload(force=force_upload, locked=False, persistent_only=True) \
-                                    and cache.upload_enabled(),
+                                    and self.cache.upload_enabled(),
                                     self, "Failed to upload task artifact")
 
                         finally:
@@ -873,14 +902,14 @@ class TaskProxy(object):
                             raise_task_error_if(
                                 upload_session_artifacts \
                                 and not self.upload(force=force_upload, locked=False, session_only=True, artifacts=upload_session_artifacts) \
-                                and cache.upload_enabled(),
+                                and self.cache.upload_enabled(),
                                 self, "Failed to upload session artifact")
 
             elif force_upload or not available_remotely:
                 self.started_upload()
                 raise_task_error_if(
                     not self.upload(force=force_upload, persistent_only=True) \
-                    and cache.upload_enabled(),
+                    and self.cache.upload_enabled(),
                     self, "Failed to upload task artifact")
                 self.finished_upload()
 
@@ -1075,12 +1104,11 @@ class Graph(object):
 
 
 class GraphBuilder(object):
-    def __init__(self, registry, cache, manifest=None, options=None, progress=False, buildenv=None):
+    def __init__(self, registry, cache, options=None, progress=False, buildenv=None):
         self.cache = cache
         self.graph = Graph()
         self.nodes = {}
         self.registry = registry
-        self.manifest = manifest
         self.buildenv = buildenv
         self.progress = progress
         self.options = options or JoltOptions()
@@ -1089,7 +1117,7 @@ class GraphBuilder(object):
         name = utils.stable_task_name(name)
         node = self.nodes.get(name)
         if not node:
-            task = self.registry.get_task(name, manifest=self.manifest, buildenv=self.buildenv)
+            task = self.registry.get_task(name, buildenv=self.buildenv)
             node = self.nodes.get(task.qualified_name, None)
             if node is not None:
                 return node
@@ -1121,7 +1149,7 @@ class GraphBuilder(object):
             parent = node
 
         for requirement in node.task.requires:
-            alias, artifact, task, name = utils.parse_aliased_task_name(requirement)
+            alias, _, task, name = utils.parse_aliased_task_name(requirement)
             child = self._get_node(progress, utils.format_task_name(task, name), parent=node)
 
             # Create direct edges from alias parents to alias children
@@ -1156,7 +1184,7 @@ class GraphBuilder(object):
             topological_nodes = self.graph.topological_nodes
             with self._progress("Collecting task influence", len(self.graph.tasks), "tasks") as p:
                 for node in reversed(topological_nodes):
-                    node.finalize(self.graph, self.manifest)
+                    node.finalize(self.graph)
                     p.update(1)
 
                 # Create artifacts in forward order so that parent identities are available