Revert "Merge pull request #223 from shanejbrown/XENG-9264"

shanejbrown · shanejbrown · commit 4a48e14861bb · 2026-02-12T13:34:10.000-07:00
This reverts commit baee0d0, reversing changes made to cc251e5.
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
@@ -33,15 +33,6 @@ jobs:
       run: uv sync --locked
     - name: Pre-commit checks
       run: uv run pre-commit run --all-files
-
-    - name: Set up QEMU
-      uses: docker/setup-qemu-action@v1
-      with:
-        platforms: linux/amd64,linux/arm64
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v1
-
     - name: Test with pytest
       # Create the ssh key file once for all testing
       run: |
diff --git a/README.rst b/README.rst
@@ -990,19 +990,6 @@ The default generated tag may be omitted by setting the 'add_build_tag' flag to
 false. In this case, the 'tags' property must be specified or else an error
 will occur.
 
-When multiple build steps push to the same Docker repository, each step receives
-a unique default tag that includes the step name (format: ``{default_tag}-{step_name}``).
-This prevents tag collisions between steps. For example, if two steps named
-``build-java17`` and ``build-java11`` both push to ``myimages/app``, they will
-receive default tags like ``main-1791.Ia09cc5.M0-1661374484-build-java17`` and
-``main-1791.Ia09cc5.M0-1661374484-build-java11`` respectively.
-
-Docker images pushed to registries are recorded in the ``artifacts.json`` file.
-When multiple steps push to the same repository, each step creates a separate
-artifact entry keyed by ``{step_name}/{repository}`` (e.g., ``build-java17/myimages/app``).
-This prevents artifact entries from overwriting each other and allows downstream
-systems to distinguish between images from different build steps.
-
 To push the image to a registry, you must add the --push argument to buildrunner.
 
 The following is an example of simple configuration where only the repository
diff --git a/buildrunner/config/loader.py b/buildrunner/config/loader.py
@@ -87,53 +87,6 @@ def _add_default_tag_to_tags(config: Union[str, dict], default_tag: str) -> dict
     return config
 
 
-def _get_step_tag(default_tag: str, step_name: str, max_length: int = 128) -> str:
-    """
-    Get a step-specific tag from a default tag and step name.
-
-    This function creates unique tags per build step by appending the step name to
-    the default tag. This is necessary when multiple build steps push to the same
-    Docker repository, as it prevents tag collisions (multiple build steps using the same default tag).
-
-    Args:
-        default_tag: The base default tag (typically a build ID or timestamp)
-        step_name: The name of the build step (e.g., "build-java17")
-        max_length: Maximum allowed tag length (default: 128, Docker image tag name character limit)
-
-    Returns:
-        A step-specific tag in the format "{default_tag}-{step_name}".
-        If the resulting tag exceeds max_length, the default_tag is truncated
-        to fit while preserving the step_name suffix.
-    """
-    # Create step-specific tag by appending step name to default tag
-    step_tag = f"{default_tag}-{step_name}"
-
-    # If tag is within length limit, return as-is
-    if len(step_tag) <= max_length:
-        return step_tag
-
-    # Tag exceeds Docker's maximum length limit (typically 128 characters)
-    # Truncate the default_tag portion while preserving the step_name suffix
-    # This ensures the step name is always included for uniqueness
-    LOGGER.info(
-        f"Step tag {step_tag} is too long, truncating default tag by length of step name"
-    )
-
-    step_suffix = f"-{step_name}"
-
-    # If the step suffix is too long, truncate it
-    if len(step_suffix) > max_length:
-        step_suffix = step_suffix[:max_length]
-
-    # Calculate how much space we have for the default_tag portion
-    available_space = max_length - len(step_suffix)
-    step_tag = f"{default_tag[:available_space]}{step_suffix}"
-
-    LOGGER.info(f"Truncated step tag: {step_tag}")
-
-    return step_tag
-
-
 def _set_default_tag(config: dict, default_tag: str) -> dict:
     """
     Set default tag if not set for each image
@@ -149,20 +102,18 @@ def _set_default_tag(config: dict, default_tag: str) -> dict:
     if not isinstance(steps, dict):
         return config
     for step_name, step in steps.items():
-        step_tag = _get_step_tag(default_tag, step_name)
-
         for substep_name, substep in step.items():
             if substep_name in ["push", "commit"]:
                 # Add default tag to tags list if not in the list
                 if isinstance(substep, list):
                     curr_image_infos = []
                     for push_config in substep:
                         curr_image_infos.append(
-                            _add_default_tag_to_tags(push_config, step_tag)
+                            _add_default_tag_to_tags(push_config, default_tag)
                         )
                     config["steps"][step_name][substep_name] = curr_image_infos
                 else:
-                    curr_image_info = _add_default_tag_to_tags(substep, step_tag)
+                    curr_image_info = _add_default_tag_to_tags(substep, default_tag)
                     config["steps"][step_name][substep_name] = curr_image_info
     return config
 
diff --git a/buildrunner/steprunner/tasks/push.py b/buildrunner/steprunner/tasks/push.py
@@ -348,11 +348,8 @@ def run(self, context):  # pylint: disable=too-many-branches
 
                 # Add tagged image as artifact if this is a push and not just a commit
                 if not self._commit_only:
-                    # Include step name in artifact key to prevent overwrites when multiple
-                    # steps push to the same repository with different tags
-                    artifact_key = f"{self.step_runner.name}/{repo.repository}"
                     self.step_runner.build_runner.add_artifact(
-                        artifact_key,
+                        repo.repository,
                         {
                             "type": "docker-image",
                             "docker:image": built_image_ids_str,
diff --git a/buildrunner/steprunner/tasks/run.py b/buildrunner/steprunner/tasks/run.py
@@ -1152,34 +1152,19 @@ def _run_post_build(self, context):
         self.step_runner.log.info("Running post-build processing")
         post_build = self.step.post_build
         temp_tag = f"buildrunner-post-build-tag-{str(uuid.uuid4())}"
-        committed_image = self.runner.commit(self.step_runner.log)
-        python_on_whales.docker.image.tag(committed_image, temp_tag)
+        python_on_whales.docker.image.tag(
+            self.runner.commit(self.step_runner.log),
+            temp_tag,
+        )
         self.images_to_remove.append(temp_tag)
 
-        # Force use of legacy builder for post-build since we're using a locally committed image
-        # Buildx with certain builders (like docker-container) cannot access local images
-        buildrunner_config = BuildRunnerConfig.get_instance()
-        original_use_legacy_builder = buildrunner_config.run_config.use_legacy_builder
-        if not original_use_legacy_builder:
-            self.step_runner.log.info(
-                "Forcing use of legacy builder for post-build step (committed image is local)"
-            )
-            buildrunner_config.run_config.use_legacy_builder = True
-
         post_build.pull = False
-        try:
-            build_image_task = BuildBuildStepRunnerTask(
-                self.step_runner, post_build, image_to_prepend_to_dockerfile=temp_tag
-            )
-            _build_context = {}
-            build_image_task.run(_build_context)
-            context["run-image"] = _build_context.get("image", None)
-        finally:
-            # Restore the original builder setting
-            if not original_use_legacy_builder:
-                buildrunner_config.run_config.use_legacy_builder = (
-                    original_use_legacy_builder
-                )
+        build_image_task = BuildBuildStepRunnerTask(
+            self.step_runner, post_build, image_to_prepend_to_dockerfile=temp_tag
+        )
+        _build_context = {}
+        build_image_task.run(_build_context)
+        context["run-image"] = _build_context.get("image", None)
 
     def cleanup(self, context):  # pylint: disable=unused-argument
         if self.runner:
diff --git a/pyproject.toml b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "buildrunner"
-version = "3.20"
+version = "3.19"
 description = "Docker-based build tool"
 readme = "README.rst"
 requires-python = ">=3.9"
diff --git a/tests/test-files/test-multiplatform-image-tags.yaml b/tests/test-files/test-multiplatform-image-tags.yaml
diff --git a/tests/test-files/test-push.yaml b/tests/test-files/test-push.yaml
@@ -63,7 +63,7 @@ steps:
     build:
       # pull defaults to false
       dockerfile: |
-        FROM adobe/buildrunner-test3:{{ BUILDRUNNER_BUILD_DOCKER_TAG }}-test-commit-list
+        FROM adobe/buildrunner-test3:{{ BUILDRUNNER_BUILD_DOCKER_TAG }}
     run:
       cmds:
         # File should exist since the locally committed version is used
diff --git a/tests/test_buildrunner_files.py b/tests/test_buildrunner_files.py
@@ -20,7 +20,6 @@
     "test-general-buildx.yaml",
     "test-general.yaml",
     "test-push-artifact-buildx.yaml",
-    "test-multiplatform-image-tags.yaml",
 ]
 
 
diff --git a/tests/test_config_validation/test_retagging.py b/tests/test_config_validation/test_retagging.py
@@ -336,7 +336,7 @@ def test_valid_config_with_buildrunner_build_tag(
     buildrunner_config = BuildRunnerConfig.get_instance()
     push_info = buildrunner_config.run_config.steps["build-container"].push
     assert isinstance(push_info, list)
-    assert f"{id_string}-{build_number}-build-container" in push_info[0].tags
+    assert f"{id_string}-{build_number}" in push_info[0].tags
 
 
 @pytest.mark.parametrize(
@@ -362,9 +362,28 @@ def test_valid_config_with_buildrunner_build_tag(
             push:
                 repository: user1/buildrunner-test-multi-platform2
                 tags: [ 'latest' ]
-    """
+    """,
+        """
+    steps:
+        build-container-multi-platform:
+            build:
+                dockerfile: |
+                    FROM {{ DOCKER_REGISTRY }}/busybox
+                platforms:
+                    - linux/amd64
+                    - linux/arm64/v8
+            push:
+                - repository: user1/buildrunner-test-multi-platform
+                  tags: [ 'latest', '0.0.1' ]
+
+        use-built-image1:
+            run:
+                image: user1/buildrunner-test-multi-platform:{{ BUILDRUNNER_BUILD_DOCKER_TAG }}
+                cmd: echo "Hello World"
+            push: user1/buildrunner-test-multi-platform2
+    """,
     ],
-    ids=["buildrunner_build_tag_explict"],
+    ids=["buildrunner_build_tag_explict", "buildrunner_build_tag_implied"],
 )
 @mock.patch("buildrunner.config.DEFAULT_GLOBAL_CONFIG_FILES", [])
 @mock.patch("buildrunner.detect_vcs")
diff --git a/tests/test_push_artifact.py b/tests/test_push_artifact.py
@@ -188,105 +188,3 @@ def test_artifacts_with_buildx_builder(test_name, artifacts_in_file):
         0,
         artifacts_in_file,
     )
-
-
-def test_multiplatform_image_tags_separate_artifacts():
-    """
-    Test that multiple build steps pushing to the same repository with different tags
-    create separate artifact entries in artifacts.json, keyed by step name.
-    """
-    with tempfile.TemporaryDirectory(prefix="buildrunner.results-") as temp_dir:
-        command_line = [
-            "buildrunner-tester",
-            "-d",
-            top_dir_path,
-            "-b",
-            temp_dir,
-            "--keep-step-artifacts",
-            "-f",
-            os.path.join(
-                f"{TEST_DIR}/test-files", "test-multiplatform-image-tags.yaml"
-            ),
-        ]
-
-        assert 0 == test_runner.run_tests(
-            command_line,
-            master_config_file=f"{test_dir_path}/config-files/etc-buildrunner.yaml",
-            global_config_files=[
-                f"{test_dir_path}/config-files/etc-buildrunner.yaml",
-                f"{test_dir_path}/config-files/dot-buildrunner.yaml",
-            ],
-        )
-
-        artifacts_file = f"{temp_dir}/artifacts.json"
-        assert os.path.exists(artifacts_file)
-        with open(artifacts_file, "r") as artifacts_file:
-            artifacts = json.load(artifacts_file)
-
-            # Remove build.log if present
-            if "build.log" in artifacts:
-                del artifacts["build.log"]
-
-            # Verify both artifact entries exist with step-prefixed keys
-            java17_key = "build-java17/adobe/buildrunner-test-multitag"
-            java11_key = "build-java11/adobe/buildrunner-test-multitag"
-
-            assert java17_key in artifacts, (
-                f"Expected artifact key '{java17_key}' not found in artifacts.json"
-            )
-            assert java11_key in artifacts, (
-                f"Expected artifact key '{java11_key}' not found in artifacts.json"
-            )
-
-            # Verify java17 artifact structure and tags
-            java17_artifact = artifacts[java17_key]
-            assert java17_artifact["type"] == "docker-image"
-            assert (
-                java17_artifact["docker:repository"]
-                == "adobe/buildrunner-test-multitag"
-            )
-            assert "java17" in java17_artifact["docker:tags"], (
-                f"Expected 'java17' tag not found in {java17_artifact['docker:tags']}"
-            )
-            # Verify step-specific default tag is included (should contain step name)
-            java17_tags = java17_artifact["docker:tags"]
-            assert any("build-java17" in tag for tag in java17_tags), (
-                f"Expected step-specific tag containing 'build-java17' not found in {java17_tags}"
-            )
-            assert "docker:image" in java17_artifact
-            assert "docker:platforms" in java17_artifact
-            assert len(java17_artifact["docker:platforms"]) == 2, (
-                "Expected multiplatform build with 2 platforms"
-            )
-
-            # Verify java11 artifact structure and tags
-            java11_artifact = artifacts[java11_key]
-            assert java11_artifact["type"] == "docker-image"
-            assert (
-                java11_artifact["docker:repository"]
-                == "adobe/buildrunner-test-multitag"
-            )
-            assert "java11" in java11_artifact["docker:tags"], (
-                f"Expected 'java11' tag not found in {java11_artifact['docker:tags']}"
-            )
-            # Verify step-specific default tag is included (should contain step name)
-            java11_tags = java11_artifact["docker:tags"]
-            assert any("build-java11" in tag for tag in java11_tags), (
-                f"Expected step-specific tag containing 'build-java11' not found in {java11_tags}"
-            )
-            assert "docker:image" in java11_artifact
-            assert "docker:platforms" in java11_artifact
-            assert len(java11_artifact["docker:platforms"]) == 2, (
-                "Expected multiplatform build with 2 platforms"
-            )
-
-            # Verify they are different entries (not overwriting each other)
-            assert java17_artifact != java11_artifact, (
-                "Artifacts should be different entries, not overwriting each other"
-            )
-
-            # Verify no other unexpected artifacts (except build.log which we already removed)
-            remaining_artifacts = set(artifacts.keys()) - {java17_key, java11_key}
-            assert len(remaining_artifacts) == 0, (
-                f"Unexpected artifacts found: {remaining_artifacts}"
-            )
diff --git a/uv.lock b/uv.lock

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@`
`20`	`20`	`"test-general-buildx.yaml",`
`21`	`21`	`"test-general.yaml",`
`22`	`22`	`"test-push-artifact-buildx.yaml",`
`23`		`- "test-multiplatform-image-tags.yaml",`
`24`	`23`	`]`
`25`	`24`
`26`	`25`