Add migrate endpoint for push repositories.

Provide an async API to convert legacy ContainerPushRepository instances into ContainerRepository while preserving content and distribution links.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: gerrod3

CHANGES/+migrate-push-repository.feature

@@ -0,0 +1 @@
+Added a `migrate` endpoint to push repositories that converts a `ContainerPushRepository` into a `ContainerRepository`.

pulp_container/app/serializers.py

@@ -290,6 +290,21 @@ class Meta:
         model = models.ContainerPushRepository
 
 
+class MigratePushRepositorySerializer(ValidateFieldsMixin, serializers.Serializer):
+    """
+    Serializer for migrating a push repository to a container repository.
+    """
+
+    copy_versions = serializers.BooleanField(
+        required=False,
+        default=False,
+        help_text=_(
+            "If True, copy the full repository version history. "
+            "If False, only the latest repository version content is copied."
+        ),
+    )
+
+
 class ContainerRemoteSerializer(RemoteSerializer):
     """
     A Serializer for ContainerRemote.

pulp_container/app/tasks/__init__.py

@@ -1,5 +1,6 @@
 from .download_image_data import aadd_and_remove, download_image_data  # noqa
 from .builder import build_image_from_containerfile, build_image  # noqa
+from .migrate_push_repository import migrate_push_repository  # noqa
 from .recursive_add import recursive_add_content  # noqa
 from .recursive_remove import recursive_remove_content  # noqa
 from .sign import sign  # noqa

pulp_container/app/tasks/migrate_push_repository.py

@@ -0,0 +1,72 @@
+from django.db import transaction
+
+from pulpcore.plugin.models import CreatedResource
+
+from pulp_container.app.models import (
+    ContainerDistribution,
+    ContainerPushRepository,
+    ContainerRepository,
+)
+from pulp_container.app.serializers import ContainerRepositorySerializer
+
+
+def migrate_push_repository(push_repository_pk, copy_versions=False):
+    """
+    Convert a ContainerPushRepository into a ContainerRepository.
+
+    Creates a new container repository with the same name and metadata, copies
+    content from the push repository, reassociates any distributions, and deletes
+    the original push repository.
+
+    Args:
+        push_repository_pk (str): The primary key for the push repository to migrate.
+        copy_versions (bool): If True, copy the full repository version history. If False,
+            only copy content from the latest repository version.
+    """
+    push_repository = ContainerPushRepository.objects.get(pk=push_repository_pk)
+
+    original_name = push_repository.name
+    temp_name = f"{original_name}__migrating__{push_repository.pk}"
+
+    with transaction.atomic():
+        push_repository.name = temp_name
+        push_repository.save(update_fields=["name"])
+
+        container_repository = ContainerRepository(
+            name=original_name,
+            pulp_domain=push_repository.pulp_domain,
+            pulp_labels=push_repository.pulp_labels,
+            description=push_repository.description,
+            retain_repo_versions=push_repository.retain_repo_versions,
+            retain_checkpoints=push_repository.retain_checkpoints,
+            user_hidden=push_repository.user_hidden,
+            manifest_signing_service=push_repository.manifest_signing_service,
+        )
+        container_repository.save()
+
+        container_repository.pending_blobs.set(push_repository.pending_blobs.all())
+        container_repository.pending_manifests.set(push_repository.pending_manifests.all())
+
+        if copy_versions:
+            for push_version in push_repository.versions.complete().order_by("number"):
+                if push_version.number == 0 and not push_version.content.exists():
+                    continue
+                with container_repository.new_version() as new_version:
+                    new_version.set_content(push_version.content.all())
+        else:
+            latest_version = push_repository.latest_version()
+            if latest_version:
+                with container_repository.new_version() as new_version:
+                    new_version.set_content(latest_version.content.all())
+
+        ContainerDistribution.objects.filter(repository=push_repository).update(
+            repository=container_repository
+        )
+
+        push_repository.delete()
+
+    CreatedResource(content_object=container_repository).save()
+
+    return ContainerRepositorySerializer(
+        instance=container_repository, context={"request": None}
+    ).data

pulp_container/app/viewsets.py

@@ -1135,7 +1135,7 @@ class ContainerPushRepositoryViewSet(
                 ],
             },
             {
-                "action": ["update", "partial_update", "set_label", "unset_label"],
+                "action": ["update", "partial_update", "set_label", "unset_label", "migrate"],
                 "principal": "authenticated",
                 "effect": "allow",
                 "condition_expression": [
@@ -1154,6 +1154,40 @@ class ContainerPushRepositoryViewSet(
     }
     LOCKED_ROLES = {}
 
+    @extend_schema(
+        description=(
+            "Trigger an asynchronous task to convert this push repository into a "
+            "container repository."
+        ),
+        summary="Migrate push repository to container repository",
+        request=serializers.MigratePushRepositorySerializer,
+        responses={202: AsyncOperationResponseSerializer},
+    )
+    @action(detail=True, methods=["post"], serializer_class=serializers.MigratePushRepositorySerializer)
+    def migrate(self, request, pk):
+        """
+        Create a task which converts a push repository into a container repository.
+        """
+        repository = self.get_object()
+
+        serializer = serializers.MigratePushRepositorySerializer(
+            data=request.data, context={"request": request}
+        )
+        serializer.is_valid(raise_exception=True)
+
+        distributions = models.ContainerDistribution.objects.filter(repository=repository)
+        exclusive_resources = [repository, *distributions]
+
+        result = dispatch(
+            tasks.migrate_push_repository,
+            exclusive_resources=exclusive_resources,
+            kwargs={
+                "push_repository_pk": str(repository.pk),
+                "copy_versions": serializer.validated_data["copy_versions"],
+            },
+        )
+        return OperationPostponedResponse(result, request)
+
     @extend_schema(
         description=(
             "Trigger an asynchronous task to remove a manifest and all its associated "

pulp_container/tests/functional/api/test_migrate_push_repository.py

@@ -0,0 +1,55 @@
+"""Tests for migrating push repositories to container repositories."""
+
+import uuid
+
+from pulp_container.tests.functional.constants import REGISTRY_V2_REPO_PULP
+
+
+def test_migrate_push_repository(
+    add_to_cleanup,
+    container_push_repository_factory,
+    registry_client,
+    local_registry,
+    container_bindings,
+    full_path,
+    monitor_task,
+):
+    """A push repository can be migrated to a container repository."""
+    namespace_name = str(uuid.uuid4())
+    repo_name = f"{namespace_name}/migrate"
+    local_url = full_path(f"{repo_name}:1.0")
+
+    container_push_repository_factory(name=repo_name)
+    image_path = f"{REGISTRY_V2_REPO_PULP}:manifest_a"
+    registry_client.pull(image_path)
+    local_registry.tag_and_push(image_path, local_url)
+
+    distribution = container_bindings.DistributionsContainerApi.list(name=repo_name).results[0]
+    namespace = container_bindings.PulpContainerNamespacesApi.read(distribution.namespace)
+    add_to_cleanup(container_bindings.PulpContainerNamespacesApi, namespace.pulp_href)
+
+    push_repository = container_bindings.RepositoriesContainerPushApi.list(name=repo_name).results[0]
+    tags_before = container_bindings.ContentTagsApi.list(
+        repository_version=push_repository.latest_version_href
+    )
+    assert tags_before.count == 1
+
+    migrate_response = container_bindings.RepositoriesContainerPushApi.migrate(
+        push_repository.pulp_href, {"copy_versions": False}
+    )
+    task = monitor_task(migrate_response.task)
+    container_repository = container_bindings.RepositoriesContainerApi.read(task.result["pulp_href"])
+    assert container_repository.name == repo_name
+    assert container_repository.pulp_href in task.created_resources
+    assert container_repository.prn == task.result["prn"]
+    tags_after = container_bindings.ContentTagsApi.list(
+        repository_version=container_repository.latest_version_href
+    )
+    assert tags_after.count == 1
+    assert tags_after.results[0].name == tags_before.results[0].name
+    assert tags_after.results[0].prn == tags_before.results[0].prn
+
+    assert container_bindings.RepositoriesContainerPushApi.list(name=repo_name).count == 0
+
+    distribution = container_bindings.DistributionsContainerApi.list(name=repo_name).results[0]
+    assert distribution.repository == container_repository.pulp_href