taskcluster-taskgraph 12.2.0__tar.gz → 13.0.0__tar.gz

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Change Log
 
+## [13.0.0] - 2025-01-23
+
+### Added
+
+- automatically interpolate {task_workdir} in environment (#630)
+- add caches for common package managers (#623)
+- support setting repo wide default values for cache selection (#623)
+- support list of caches in `use-caches` key (#623)
+
+### Fixed
+
+- `get_ancestors` now returns tasks keyed by taskid, to avoid missing tasks when multiple tasks exist with the same label in a graph (#633)
+
+### Removed
+
+- unused resource-monitor code (#636)
+- `cache-dotcache` key (#623)
+
 ## [12.2.0] - 2025-01-15
 
 ### Added

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskcluster-taskgraph
-Version: 12.2.0
+Version: 13.0.0
 Summary: Build taskcluster taskgraphs
 Project-URL: Repository, https://github.com/taskcluster/taskgraph
 Project-URL: Issues, https://github.com/taskcluster/taskgraph/issues

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/docs/howto/docker.rst

@@ -201,6 +201,65 @@ process the ``Dockerfile`` and handle the special syntax. Whereas the
 only generated once and then re-used by all subsequent pushes until the image
 is modified.
 
+Layering images on top of each other
+....................................
+
+The ``parent`` value on a docker-image task can refer to another image's ``name``.
+The parent image can then be referenced from the dependent image's Dockerfile
+as ``$DOCKER_IMAGE_PARENT``.  Whenever the base image's definition (or
+something it includes) changes, that automatically also triggers a
+rebuild of the dependent image.
+
+For example, ``kind.yml`` could include:
+
+.. code-block:: yaml
+
+  tasks:
+    base:
+      symbol: I(base)
+    extras:
+      symbol: I(extras)
+      parent: base
+
+And the ``extras`` image's Dockerfile:
+
+.. code-block::
+
+  FROM $DOCKER_IMAGE_PARENT
+
+  RUN apt-get update && apt-get install -y extra software && apt-get clean
+
+
+.. note::
+   The ``taskgraph build-image`` command doesn't handle this syntax, so it won't work for those images.
+   In taskcluster this is handled by the ``image_builder`` tool, see
+   `the image_builder docker image <https://hub.docker.com/r/mozillareleases/image_builder>`_ and
+   `its source code <https://searchfox.org/mozilla-central/source/taskcluster/docker/image_builder>`_.
+
+
+Reusing image definitions
+.........................
+
+The same ``Dockerfile`` can be used for multiple images, by setting ``definition``, for example:
+
+.. code-block:: yaml
+
+  tasks:
+      debian12:
+          symbol: I(deb12)
+          definition: debian
+          args:
+              BASE_IMAGE: debian:12
+      debian11:
+          symbol: I(deb11)
+          definition: debian
+          args:
+              BASE_IMAGE: debian:11
+
+Both the ``debian11`` and ``debian12`` images will be built from the definition in
+``taskcluster/docker/debian``, but they'll be passed different ``BASE_IMAGE``
+variables (as in ``docker build --build-arg``).
+
 Context Directory Hashing
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/docs/reference/migrations.rst

@@ -3,6 +3,41 @@ Migration Guide
 
 This page can help when migrating Taskgraph across major versions.
 
+12.x -> 13.x
+------------
+
+* Remove all ``run.cache-dotcache`` keys. If it was set to ``true``, replace it
+  with:
+
+  .. code-block:: yaml
+
+     run:
+       use-caches: [checkout, <caches>]
+
+  Where caches can be any of ``cargo``, ``pip``, ``uv`` or ``npm``. If the task
+  was setting up ``.cache`` for another tool, a mount will need to be created
+  for it manually. If ``use-caches`` was previously set to ``false``, omit
+  ``checkout`` in the example above. If ``use-caches`` was previously set to
+  ``true``, replace ``true`` with the value above (including ``checkout``).
+* Invert any usage of the dict keys and values returned by `get_ancestors`:
+
+  For example, if you were using:
+
+  .. code-block:: python
+
+    for label, taskid in get_ancestors(...):
+      ...
+
+  Change it to:
+
+  .. code-block:: python
+
+    for taskid, label in get_ancestors(...):
+      ...
+
+  Note that due to this change `get_ancestors` may return multiple tasks with
+  the same label now, which your code may need to deal with.
+
 11.x -> 12.x
 ------------
 
@@ -110,7 +145,7 @@ This page can help when migrating Taskgraph across major versions.
 5.x -> 6.x
 ----------
 
-* Replace all uses of ``command-context` with the more generalized ``task-context``
+* Replace all uses of ``command-context`` with the more generalized ``task-context``
 
 4.x -> 5.x
 ----------

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/packages/pytest-taskgraph/src/pytest_taskgraph/fixtures/gen.py

@@ -204,7 +204,11 @@ def make_transform_config(parameters, graph_config):
         if extra_params:
             parameters.update(extra_params)
         if extra_graph_config:
-            graph_config._config.update(extra_graph_config)
+            # We need this intermediate variable because `GraphConfig` is
+            # frozen and we can't set attributes on it.
+            new_graph_config = merge(graph_config._config, extra_graph_config)
+            graph_config._config.update(new_graph_config)
+
         return TransformConfig(
             "test",
             str(here),
@@ -220,12 +224,12 @@ def make_transform_config(parameters, graph_config):
 
 @pytest.fixture
 def run_transform(make_transform_config):
-    def inner(func, tasks, config=None):
+    def inner(func, tasks, config=None, **kwargs):
         if not isinstance(tasks, list):
             tasks = [tasks]
 
         if not config:
-            config = make_transform_config()
+            config = make_transform_config(**kwargs)
         return list(func(config, tasks))
 
     return inner

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/src/taskgraph/__init__.py

@@ -2,7 +2,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-__version__ = "12.2.0"
+__version__ = "13.0.0"
 
 # Maximum number of dependencies a single task can have
 # https://docs.taskcluster.net/docs/reference/platform/queue/api#createTask

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/src/taskgraph/config.py

@@ -12,6 +12,7 @@ from typing import Dict
 from voluptuous import All, Any, Extra, Length, Optional, Required
 
 from .util import path
+from .util.caches import CACHES
 from .util.python_path import find_object
 from .util.schema import Schema, optionally_keyed_by, validate_schema
 from .util.yaml import load_yaml
@@ -74,6 +75,16 @@ graph_config_schema = Schema(
                 "index-path-regexes",
                 description="Regular expressions matching index paths to be summarized.",
             ): [str],
+            Optional(
+                "run",
+                description="Configuration related to the 'run' transforms.",
+            ): {
+                Optional(
+                    "use-caches",
+                    description="List of caches to enable, or a boolean to "
+                    "enable/disable all of them.",
+                ): Any(bool, list(CACHES.keys())),
+            },
             Required("repositories"): All(
                 {
                     str: {
@@ -106,8 +117,8 @@ class GraphConfig:
     def __contains__(self, name):
         return name in self._config
 
-    def get(self, name):
-        return self._config.get(name)
+    def get(self, name, default=None):
+        return self._config.get(name, default)
 
     def register(self):
         """

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/src/taskgraph/run-task/run-task

@@ -1026,64 +1026,6 @@ def install_pip_requirements(repositories):
     run_required_command(b"pip-install", cmd)
 
 
-def maybe_run_resource_monitoring():
-    """Run the resource monitor if available.
-
-    Discussion in https://github.com/taskcluster/taskcluster-rfcs/pull/160
-    and https://bugzil.la/1648051
-
-    """
-    if "MOZ_FETCHES" not in os.environ:
-        return
-    if "RESOURCE_MONITOR_OUTPUT" not in os.environ:
-        return
-
-    prefix = b"resource_monitor"
-
-    executable = "{}/resource-monitor/resource-monitor{}".format(
-        os.environ.get("MOZ_FETCHES_DIR"), ".exe" if IS_WINDOWS else ""
-    )
-
-    if not os.path.exists(executable) or not os.access(executable, os.X_OK):
-        print_line(prefix, b"%s not executable\n" % executable.encode("utf-8"))
-        return
-    args = [
-        executable,
-        "-process",
-        str(os.getpid()),
-        "-output",
-        os.environ["RESOURCE_MONITOR_OUTPUT"],
-    ]
-    print_line(prefix, b"Resource monitor starting: %s\n" % str(args).encode("utf-8"))
-    # Avoid environment variables the payload doesn't need.
-    del os.environ["RESOURCE_MONITOR_OUTPUT"]
-
-    # Without CREATE_NEW_PROCESS_GROUP Windows signals will attempt to kill run-task, too.
-    process = subprocess.Popen(
-        args,
-        # Disable buffering because we want to receive output
-        # as it is generated so timestamps in logs are
-        # accurate.
-        bufsize=0,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP if IS_WINDOWS else 0,
-        cwd=os.getcwd(),
-    )
-
-    def capture_output():
-        fh = io.TextIOWrapper(process.stdout, encoding="latin1")
-        while True:
-            data = fh.readline().encode("latin1")
-            if data == b"":
-                break
-            print_line(prefix, data)
-
-    monitor_process = Thread(target=capture_output)
-    monitor_process.start()
-    return process
-
-
 def _display_python_version():
     print_line(
         b"setup", b"Python version: %s\n" % platform.python_version().encode("utf-8")
@@ -1091,10 +1033,10 @@ def _display_python_version():
 
 
 def main(args):
-    os.environ["TASK_WORKDIR"] = os.getcwd()
+    task_workdir = os.environ["TASK_WORKDIR"] = os.getcwd()
     print_line(
         b"setup",
-        b"run-task started in %s\n" % os.environ["TASK_WORKDIR"].encode("utf-8"),
+        b"run-task started in %s\n" % task_workdir.encode("utf-8"),
     )
     print_line(
         b"setup",
@@ -1313,20 +1255,26 @@ def main(args):
     for repo in repositories:
         vcs_checkout_from_args(repo)
 
-    resource_process = None
-
-    try:
-        for k in ["MOZ_FETCHES_DIR", "UPLOAD_DIR"] + [
-            "{}_PATH".format(repository["project"].upper())
-            for repository in repositories
-        ]:
-            if k in os.environ:
-                os.environ[k] = os.path.abspath(os.environ[k])
+    # Interpolate environment variables with defined substitution patterns. For
+    # example, the variable `CACHE_DIR={task_workdir}/.cache` will be
+    # interpolated with the task's working directory.
+    env_subs = {
+        "task_workdir": task_workdir,
+    }
+    for k, v in os.environ.items():
+        for subname, subval in env_subs.items():
+            # We check for an exact match rather than using a format string to
+            # avoid accidentally trying to interpolate environment variables
+            # that happen to contain brackets for some other reason.
+            pattern = f"{{{subname}}}"
+            if pattern in v:
+                os.environ[k] = v.replace(pattern, subval)
                 print_line(
                     b"setup",
                     b"%s is %s\n" % (k.encode("utf-8"), os.environ[k].encode("utf-8")),
                 )
 
+    try:
         if "MOZ_FETCHES" in os.environ:
             fetch_artifacts()
 
@@ -1334,21 +1282,8 @@ def main(args):
         # fetches to grab dependencies.
         install_pip_requirements(repositories)
 
-        resource_process = maybe_run_resource_monitoring()
-
         return run_command(b"task", task_args, cwd=args.task_cwd)
     finally:
-        if resource_process:
-            print_line(b"resource_monitor", b"terminating\n")
-            if IS_WINDOWS:
-                # .terminate() on Windows is not a graceful shutdown, due to
-                # differences in signals. CTRL_BREAK_EVENT will work provided
-                # the subprocess is in a different process group, so this script
-                # isn't also killed.
-                os.kill(resource_process.pid, signal.CTRL_BREAK_EVENT)
-            else:
-                resource_process.terminate()
-            resource_process.wait()
         fetches_dir = os.environ.get("MOZ_FETCHES_DIR")
         if fetches_dir and os.path.isdir(fetches_dir):
             print_line(b"fetches", b"removing %s\n" % fetches_dir.encode("utf-8"))

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/src/taskgraph/transforms/run/__init__.py

@@ -160,43 +160,6 @@ def set_label(config, tasks):
         yield task
 
 
-@transforms.add
-def add_resource_monitor(config, tasks):
-    for task in tasks:
-        if task.get("attributes", {}).get("resource-monitor"):
-            worker_implementation, worker_os = worker_type_implementation(
-                config.graph_config, task["worker-type"]
-            )
-            # Normalise worker os so that linux-bitbar and similar use linux tools.
-            if worker_os:
-                worker_os = worker_os.split("-")[0]
-            if "win7" in task["worker-type"]:
-                arch = "32"
-            else:
-                arch = "64"
-            task.setdefault("fetches", {})
-            task["fetches"].setdefault("toolchain", [])
-            task["fetches"]["toolchain"].append(f"{worker_os}{arch}-resource-monitor")
-
-            if worker_implementation == "docker-worker":
-                artifact_source = "/builds/worker/monitoring/resource-monitor.json"
-            else:
-                artifact_source = "monitoring/resource-monitor.json"
-            task["worker"].setdefault("artifacts", [])
-            task["worker"]["artifacts"].append(
-                {
-                    "name": "public/monitoring/resource-monitor.json",
-                    "type": "file",
-                    "path": artifact_source,
-                }
-            )
-            # Set env for output file
-            task["worker"].setdefault("env", {})
-            task["worker"]["env"]["RESOURCE_MONITOR_OUTPUT"] = artifact_source
-
-        yield task
-
-
 def get_attribute(dict, key, attributes, attribute_name):
     """Get `attribute_name` from the given `attributes` dict, and if there
     is a corresponding value, set `key` in `dict` to that value."""
@@ -367,7 +330,7 @@ def use_fetches(config, tasks):
             "task-reference": json.dumps(task_fetches, sort_keys=True)
         }
 
-        env.setdefault("MOZ_FETCHES_DIR", "fetches")
+        env.setdefault("MOZ_FETCHES_DIR", "{task_workdir}/fetches")
 
         yield task
 

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/src/taskgraph/transforms/run/common.py

@@ -7,9 +7,12 @@ worker implementation they operate on, and take the same three parameters, for
 consistency.
 """
 
-import hashlib
 import json
+from typing import Any, Dict, List, Union
 
+from taskgraph.transforms.base import TransformConfig
+from taskgraph.util import path
+from taskgraph.util.caches import CACHES, get_checkout_dir
 from taskgraph.util.taskcluster import get_artifact_prefix
 
 
@@ -31,10 +34,10 @@ def add_cache(task, taskdesc, name, mount_point, skip_untrusted=False):
         skip_untrusted (bool): Whether cache is used in untrusted environments
             (default: False). Only applies to docker-worker.
     """
-    if not task["run"].get("use-caches", True):
-        return
-
     worker = task["worker"]
+    if worker["implementation"] not in ("docker-worker", "generic-worker"):
+        # caches support not implemented
+        return
 
     if worker["implementation"] == "docker-worker":
         taskdesc["worker"].setdefault("caches", []).append(
@@ -54,10 +57,6 @@ def add_cache(task, taskdesc, name, mount_point, skip_untrusted=False):
             }
         )
 
-    else:
-        # Caches not implemented
-        pass
-
 
 def add_artifacts(config, task, taskdesc, path):
     taskdesc["worker"].setdefault("artifacts", []).append(
@@ -91,46 +90,19 @@ def support_vcs_checkout(config, task, taskdesc, repo_configs, sparse=False):
     reserved for ``run-task`` tasks.
     """
     worker = task["worker"]
-    is_mac = worker["os"] == "macosx"
+    assert worker["os"] in ("linux", "macosx", "windows")
     is_win = worker["os"] == "windows"
-    is_linux = worker["os"] == "linux"
     is_docker = worker["implementation"] == "docker-worker"
-    assert is_mac or is_win or is_linux
 
+    checkoutdir = get_checkout_dir(task)
     if is_win:
-        checkoutdir = "./build"
         hgstore = "y:/hg-shared"
     elif is_docker:
-        checkoutdir = "{workdir}/checkouts".format(**task["run"])
         hgstore = f"{checkoutdir}/hg-store"
     else:
-        checkoutdir = "./checkouts"
         hgstore = f"{checkoutdir}/hg-shared"
 
-    vcsdir = checkoutdir + "/" + get_vcsdir_name(worker["os"])
-    cache_name = "checkouts"
-
-    # Robust checkout does not clean up subrepositories, so ensure  that tasks
-    # that checkout different sets of paths have separate caches.
-    # See https://bugzilla.mozilla.org/show_bug.cgi?id=1631610
-    if len(repo_configs) > 1:
-        checkout_paths = {
-            "\t".join([repo_config.path, repo_config.prefix])
-            for repo_config in sorted(
-                repo_configs.values(), key=lambda repo_config: repo_config.path
-            )
-        }
-        checkout_paths_str = "\n".join(checkout_paths).encode("utf-8")
-        digest = hashlib.sha256(checkout_paths_str).hexdigest()
-        cache_name += f"-repos-{digest}"
-
-    # Sparse checkouts need their own cache because they can interfere
-    # with clients that aren't sparse aware.
-    if sparse:
-        cache_name += "-sparse"
-
-    add_cache(task, taskdesc, cache_name, checkoutdir)
-
+    vcsdir = f"{checkoutdir}/{get_vcsdir_name(worker['os'])}"
     env = taskdesc["worker"].setdefault("env", {})
     env.update(
         {
@@ -138,7 +110,8 @@ def support_vcs_checkout(config, task, taskdesc, repo_configs, sparse=False):
             "REPOSITORIES": json.dumps(
                 {repo.prefix: repo.name for repo in repo_configs.values()}
             ),
-            "VCS_PATH": vcsdir,
+            # If vcsdir is already absolute this will return it unmodified.
+            "VCS_PATH": path.join("{task_workdir}", vcsdir),
         }
     )
     for repo_config in repo_configs.values():
@@ -162,3 +135,69 @@ def support_vcs_checkout(config, task, taskdesc, repo_configs, sparse=False):
     # only some worker platforms have taskcluster-proxy enabled
     if task["worker"]["implementation"] in ("docker-worker",):
         taskdesc["worker"]["taskcluster-proxy"] = True
+
+    return vcsdir
+
+
+def should_use_cache(
+    name: str,
+    use_caches: Union[bool, List[str]],
+    has_checkout: bool,
+) -> bool:
+    # Never enable the checkout cache if there's no clone. This allows
+    # 'checkout' to be specified as a default cache without impacting
+    # irrelevant tasks.
+    if name == "checkout" and not has_checkout:
+        return False
+
+    if isinstance(use_caches, bool):
+        return use_caches
+
+    return name in use_caches
+
+
+def support_caches(
+    config: TransformConfig, task: Dict[str, Any], taskdesc: Dict[str, Any]
+):
+    """Add caches for common tools."""
+    run = task["run"]
+    worker = task["worker"]
+    workdir = run.get("workdir")
+    base_cache_dir = ".task-cache"
+    if worker["implementation"] == "docker-worker":
+        workdir = workdir or "/builds/worker"
+        base_cache_dir = path.join(workdir, base_cache_dir)
+
+    use_caches = run.get("use-caches")
+    if use_caches is None:
+        # Use project default values for filtering caches, default to
+        # checkout cache if no selection is specified.
+        use_caches = (
+            config.graph_config.get("taskgraph", {})
+            .get("run", {})
+            .get("use-caches", ["checkout"])
+        )
+
+    for name, cache_cfg in CACHES.items():
+        if not should_use_cache(name, use_caches, run["checkout"]):
+            continue
+
+        if "cache_dir" in cache_cfg:
+            assert callable(cache_cfg["cache_dir"])
+            cache_dir = cache_cfg["cache_dir"](task)
+        else:
+            cache_dir = f"{base_cache_dir}/{name}"
+
+        if "cache_name" in cache_cfg:
+            assert callable(cache_cfg["cache_name"])
+            cache_name = cache_cfg["cache_name"](config, task)
+        else:
+            cache_name = name
+
+        if cache_cfg.get("env"):
+            env = taskdesc["worker"].setdefault("env", {})
+            # If cache_dir is already absolute, the `.join` call returns it as
+            # is. In that case, {task_workdir} will get interpolated by
+            # run-task.
+            env[cache_cfg["env"]] = path.join("{task_workdir}", cache_dir)
+        add_cache(task, taskdesc, cache_name, cache_dir)

{taskcluster_taskgraph-12.2.0 → taskcluster_taskgraph-13.0.0}/src/taskgraph/transforms/run/run_task.py

@@ -11,9 +11,13 @@ import os
 from voluptuous import Any, Optional, Required
 
 from taskgraph.transforms.run import run_task_using
-from taskgraph.transforms.run.common import support_vcs_checkout
+from taskgraph.transforms.run.common import (
+    support_caches,
+    support_vcs_checkout,
+)
 from taskgraph.transforms.task import taskref_or_string
 from taskgraph.util import path, taskcluster
+from taskgraph.util.caches import CACHES
 from taskgraph.util.schema import Schema
 
 EXEC_COMMANDS = {
@@ -24,12 +28,11 @@ EXEC_COMMANDS = {
 run_task_schema = Schema(
     {
         Required("using"): "run-task",
-        # if true, add a cache at ~worker/.cache, which is where things like pip
-        # tend to hide their caches.  This cache is never added for level-1 tasks.
-        # TODO Once bug 1526028 is fixed, this and 'use-caches' should be merged.
-        Required("cache-dotcache"): bool,
-        # Whether or not to use caches.
-        Optional("use-caches"): bool,
+        # Which caches to use. May take a boolean in which case either all
+        # (True) or no (False) caches will be used. Alternatively, it can
+        # accept a list of caches to enable. Defaults to only the checkout cache
+        # enabled.
+        Optional("use-caches", "caches"): Any(bool, list(CACHES.keys())),
         # if true (the default), perform a checkout on the worker
         Required("checkout"): Any(bool, {str: dict}),
         Optional(
@@ -70,7 +73,7 @@ def common_setup(config, task, taskdesc, command):
                 for (repo, config) in run["checkout"].items()
             }
 
-        support_vcs_checkout(
+        vcs_path = support_vcs_checkout(
             config,
             task,
             taskdesc,
@@ -78,7 +81,6 @@ def common_setup(config, task, taskdesc, command):
             sparse=bool(run["sparse-profile"]),
         )
 
-        vcs_path = taskdesc["worker"]["env"]["VCS_PATH"]
         for repo_config in repo_configs.values():
             checkout_path = path.join(vcs_path, repo_config.path)
             command.append(f"--{repo_config.prefix}-checkout={checkout_path}")
@@ -104,11 +106,11 @@ def common_setup(config, task, taskdesc, command):
     if "cwd" in run:
         command.extend(("--task-cwd", run["cwd"]))
 
+    support_caches(config, task, taskdesc)
     taskdesc["worker"].setdefault("env", {})["MOZ_SCM_LEVEL"] = config.params["level"]
 
 
 worker_defaults = {
-    "cache-dotcache": False,
     "checkout": True,
     "sparse-profile": None,
     "run-as-root": False,
@@ -135,16 +137,6 @@ def docker_worker_run_task(config, task, taskdesc):
     command = run.pop("run-task-command", ["/usr/local/bin/run-task"])
     common_setup(config, task, taskdesc, command)
 
-    if run.get("cache-dotcache"):
-        worker["caches"].append(
-            {
-                "type": "persistent",
-                "name": "{project}-dotcache".format(**config.params),
-                "mount-point": "{workdir}/.cache".format(**run),
-                "skip-untrusted": True,
-            }
-        )
-
     run_command = run["command"]
 
     # dict is for the case of `{'task-reference': str}`.
@@ -177,13 +169,6 @@ def generic_worker_run_task(config, task, taskdesc):
     common_setup(config, task, taskdesc, command)
 
     worker.setdefault("mounts", [])
-    if run.get("cache-dotcache"):
-        worker["mounts"].append(
-            {
-                "cache-name": "{project}-dotcache".format(**config.params),
-                "directory": "{workdir}/.cache".format(**run),
-            }
-        )
     worker["mounts"].append(
         {
             "content": {