pulpcore 3.89.0__py3-none-any.whl → 3.90.0__py3-none-any.whl

pulp_certguard/app/__init__.py

@@ -6,6 +6,6 @@ class PulpCertGuardPluginAppConfig(PulpPluginAppConfig):
 
     name = "pulp_certguard.app"
     label = "certguard"
-    version = "3.89.0"
+    version = "3.90.0"
     python_package_name = "pulpcore"
     domain_compatible = True

pulp_file/app/__init__.py

@@ -8,6 +8,6 @@ class PulpFilePluginAppConfig(PulpPluginAppConfig):
 
     name = "pulp_file.app"
     label = "file"
-    version = "3.89.0"
+    version = "3.90.0"
     python_package_name = "pulpcore"
     domain_compatible = True

pulp_file/tests/functional/api/test_filesystem_export.py

@@ -0,0 +1,220 @@
+import json
+import pytest
+import uuid
+
+from pulpcore.client.pulpcore.exceptions import ApiException, BadRequestException
+from pulpcore.app import settings
+from pulpcore.constants import TASK_STATES
+
+
+pytestmark = [
+    pytest.mark.skipif(
+        "/tmp" not in settings.ALLOWED_EXPORT_PATHS,
+        reason="Cannot run export-tests unless /tmp is in ALLOWED_EXPORT_PATHS "
+        f"({settings.ALLOWED_EXPORT_PATHS}).",
+    ),
+]
+
+
+@pytest.fixture
+def fs_exporter_factory(
+    tmpdir,
+    pulpcore_bindings,
+    gen_object_with_cleanup,
+    add_to_filesystem_cleanup,
+):
+    def _fs_exporter_factory(method="write", pulp_domain=None):
+        name = str(uuid.uuid4())
+        path = "{}/{}/".format(tmpdir, name)
+        body = {
+            "name": name,
+            "path": path,
+            "method": method,
+        }
+        kwargs = {}
+        if pulp_domain:
+            kwargs["pulp_domain"] = pulp_domain
+        exporter = gen_object_with_cleanup(pulpcore_bindings.ExportersFilesystemApi, body, **kwargs)
+        add_to_filesystem_cleanup(path)
+        assert exporter.name == name
+        assert exporter.path == path
+        assert exporter.method == method
+        return exporter
+
+    return _fs_exporter_factory
+
+
+@pytest.fixture
+def fs_export_factory(pulpcore_bindings, monitor_task):
+    def _fs_export_factory(exporter, body):
+        task = monitor_task(
+            pulpcore_bindings.ExportersFilesystemExportsApi.create(
+                exporter.pulp_href, body or {}
+            ).task
+        )
+        assert len(task.created_resources) == 1
+        export = pulpcore_bindings.ExportersFilesystemExportsApi.read(task.created_resources[0])
+        for report in task.progress_reports:
+            assert report.state == TASK_STATES.COMPLETED
+        return export
+
+    return _fs_export_factory
+
+
+@pytest.fixture
+def pub_and_repo(
+    file_repository_factory,
+    file_bindings,
+    gen_object_with_cleanup,
+    random_artifact_factory,
+    monitor_task,
+):
+    def _pub_and_repo(pulp_domain=None):
+        random_artifact = random_artifact_factory(pulp_domain=pulp_domain)
+        repository = file_repository_factory(pulp_domain=pulp_domain)
+        kwargs = {}
+        if pulp_domain:
+            kwargs["pulp_domain"] = pulp_domain
+        for i in range(2):
+            monitor_task(
+                file_bindings.ContentFilesApi.create(
+                    artifact=random_artifact.pulp_href,
+                    relative_path=f"{i}.dat",
+                    repository=repository.pulp_href,
+                    **kwargs,
+                ).task
+            )
+        publish_data = file_bindings.FileFilePublication(repository=repository.pulp_href)
+        publication = gen_object_with_cleanup(
+            file_bindings.PublicationsFileApi, publish_data, **kwargs
+        )
+        return publication, repository
+
+    return _pub_and_repo
+
+
+@pytest.mark.parallel
+def test_crud_fsexporter(fs_exporter_factory, pulpcore_bindings, monitor_task):
+    # READ
+    exporter = fs_exporter_factory()
+    exporter_read = pulpcore_bindings.ExportersFilesystemApi.read(exporter.pulp_href)
+    assert exporter_read.name == exporter.name
+    assert exporter_read.path == exporter.path
+
+    # UPDATE
+    body = {"path": "/tmp/{}".format(str(uuid.uuid4()))}
+    result = pulpcore_bindings.ExportersFilesystemApi.partial_update(exporter.pulp_href, body)
+    monitor_task(result.task)
+    exporter_read = pulpcore_bindings.ExportersFilesystemApi.read(exporter.pulp_href)
+    assert exporter_read.path != exporter.path
+    assert exporter_read.path == body["path"]
+
+    # LIST
+    exporters = pulpcore_bindings.ExportersFilesystemApi.list(name=exporter.name).results
+    assert exporter.name in [e.name for e in exporters]
+
+    # DELETE
+    result = pulpcore_bindings.ExportersFilesystemApi.delete(exporter.pulp_href)
+    monitor_task(result.task)
+    with pytest.raises(ApiException):
+        pulpcore_bindings.ExportersFilesystemApi.read(exporter.pulp_href)
+
+
+@pytest.mark.parallel
+def test_fsexport(pulpcore_bindings, fs_exporter_factory, fs_export_factory, pub_and_repo):
+    exporter = fs_exporter_factory()
+    (publication, _) = pub_and_repo()
+    # Test export
+    body = {"publication": publication.pulp_href}
+    export = fs_export_factory(exporter, body=body)
+
+    # Test list and delete
+    exports = pulpcore_bindings.ExportersPulpExportsApi.list(exporter.pulp_href).results
+    assert len(exports) == 1
+    pulpcore_bindings.ExportersPulpExportsApi.delete(export.pulp_href)
+    exports = pulpcore_bindings.ExportersPulpExportsApi.list(exporter.pulp_href).results
+    assert len(exports) == 0
+
+
+@pytest.mark.parallel
+def test_fsexport_by_version(
+    fs_exporter_factory,
+    fs_export_factory,
+    pub_and_repo,
+):
+    (publication, repository) = pub_and_repo()
+    latest = repository.latest_version_href
+    zeroth = latest.replace("/2/", "/0/")
+
+    # export by version
+    exporter = fs_exporter_factory()
+    body = {"repository_version": latest}
+    fs_export_factory(exporter, body=body)
+
+    # export by version with start_version
+    exporter = fs_exporter_factory()
+    body = {"repository_version": latest, "start_repository_version": zeroth}
+    fs_export_factory(exporter, body=body)
+
+    # export by publication with start_version
+    exporter = fs_exporter_factory()
+    body = {"publication": publication.pulp_href, "start_repository_version": zeroth}
+    fs_export_factory(exporter, body=body)
+
+    # negative: specify publication and version
+    with pytest.raises(BadRequestException) as e:
+        exporter = fs_exporter_factory()
+        body = {"publication": publication.pulp_href, "repository_version": zeroth}
+        fs_export_factory(exporter, body=body)
+    assert e.value.status == 400
+    assert json.loads(e.value.body) == {
+        "non_field_errors": [
+            "publication or repository_version must either be supplied but not both."
+        ]
+    }
+
+
+@pytest.mark.skipif(not settings.DOMAIN_ENABLED, reason="Domains not enabled.")
+@pytest.mark.parallel
+def test_fsexport_cross_domain(
+    fs_exporter_factory,
+    fs_export_factory,
+    gen_object_with_cleanup,
+    pulpcore_bindings,
+    pub_and_repo,
+):
+
+    entities = [{}, {}]
+    for e in entities:
+        body = {
+            "name": str(uuid.uuid4()),
+            "storage_class": "pulpcore.app.models.storage.FileSystem",
+            "storage_settings": {"MEDIA_ROOT": "/var/lib/pulp/media/"},
+        }
+        e["domain"] = gen_object_with_cleanup(pulpcore_bindings.DomainsApi, body)
+        (e["publication"], e["repository"]) = pub_and_repo(pulp_domain=e["domain"].name)
+        e["exporter"] = fs_exporter_factory(pulp_domain=e["domain"].name)
+        body = {"publication": e["publication"].pulp_href}
+        e["export"] = fs_export_factory(e["exporter"], body=body)
+
+    latest = entities[0]["repository"].latest_version_href
+    zeroth = latest.replace("/2/", "/0/")
+
+    with pytest.raises(BadRequestException) as e:
+        body = {"publication": entities[0]["publication"].pulp_href}
+        fs_export_factory(entities[1]["exporter"], body=body)
+
+    with pytest.raises(BadRequestException) as e:
+        body = {"repository_version": latest}
+        fs_export_factory(entities[1]["exporter"], body=body)
+
+    with pytest.raises(BadRequestException) as e:
+        body = {"repository_version": latest, "start_repository_version": zeroth}
+        fs_export_factory(entities[1]["exporter"], body=body)
+
+    with pytest.raises(BadRequestException) as e:
+        body = {
+            "publication": entities[0]["publication"].pulp_href,
+            "start_repository_version": zeroth,
+        }
+        fs_export_factory(entities[1]["exporter"], body=body)

pulp_file/tests/functional/api/test_pulp_export.py

@@ -1,13 +1,14 @@
+import json
 import pytest
 import uuid
 
 from pulpcore.client.pulpcore.exceptions import ApiException
+from pulpcore.client.pulpcore.exceptions import BadRequestException
 from pulpcore.app import settings
 from pulpcore.constants import TASK_STATES
 
 
 pytestmark = [
-    pytest.mark.skipif(settings.DOMAIN_ENABLED, reason="Domains do not support export."),
     pytest.mark.skipif(
         "/tmp" not in settings.ALLOWED_EXPORT_PATHS,
         reason="Cannot run export-tests unless /tmp is in ALLOWED_EXPORT_PATHS "
@@ -23,7 +24,10 @@ def pulp_exporter_factory(
     gen_object_with_cleanup,
     add_to_filesystem_cleanup,
 ):
-    def _pulp_exporter_factory(repositories=None):
+    def _pulp_exporter_factory(
+        repositories=None,
+        pulp_domain=None,
+    ):
         if repositories is None:
             repositories = []
         name = str(uuid.uuid4())
@@ -33,7 +37,11 @@ def pulp_exporter_factory(
             "path": path,
             "repositories": [r.pulp_href for r in repositories],
         }
-        exporter = gen_object_with_cleanup(pulpcore_bindings.ExportersPulpApi, body)
+        kwargs = {}
+        if pulp_domain:
+            kwargs["pulp_domain"] = pulp_domain.name
+
+        exporter = gen_object_with_cleanup(pulpcore_bindings.ExportersPulpApi, body, **kwargs)
         add_to_filesystem_cleanup(path)
         assert exporter.name == name
         assert exporter.path == path
@@ -291,3 +299,95 @@ def test_export_incremental(
     with pytest.raises(ApiException):
         body = {"start_versions": [file_repo.latest_version_href], "full": False}
         pulp_export_factory(exporter, body)
+
+
+# Test that cross-domain attempts fail
+# Exporter: repository, last-export : create, update
+# Export: versions, start_versions
+@pytest.mark.skipif(not settings.DOMAIN_ENABLED, reason="Domains not enabled.")
+@pytest.mark.parallel
+def test_cross_domain_exporter(
+    basic_manifest_path,
+    file_bindings,
+    file_remote_factory,
+    gen_object_with_cleanup,
+    pulpcore_bindings,
+    pulp_export_factory,
+    pulp_exporter_factory,
+    monitor_task,
+):
+    # Create two domains
+    #   In each, create and sync a repository, create and export an exporter
+    # Attempt to create an exporter using the *other domain's* repo
+    # Attempt to update the exporter using the *other domain's* repo and last_export
+    # Use the exporter and attempt to export the *other domain's* repo-versions
+
+    entities = [{}, {}]
+    for e in entities:
+        body = {
+            "name": str(uuid.uuid4()),
+            "storage_class": "pulpcore.app.models.storage.FileSystem",
+            "storage_settings": {"MEDIA_ROOT": "/var/lib/pulp/media/"},
+        }
+        e["domain"] = gen_object_with_cleanup(pulpcore_bindings.DomainsApi, body)
+        remote = file_remote_factory(
+            manifest_path=basic_manifest_path, policy="immediate", pulp_domain=e["domain"].name
+        )
+
+        repo_body = {"name": str(uuid.uuid4()), "remote": remote.pulp_href}
+        e["repository"] = gen_object_with_cleanup(
+            file_bindings.RepositoriesFileApi, repo_body, pulp_domain=e["domain"].name
+        )
+        task = file_bindings.RepositoriesFileApi.sync(e["repository"].pulp_href, {}).task
+        monitor_task(task)
+        e["repository"] = file_bindings.RepositoriesFileApi.read(e["repository"].pulp_href)
+        e["exporter"] = pulp_exporter_factory(
+            repositories=[e["repository"]], pulp_domain=e["domain"]
+        )
+        e["export"] = pulp_export_factory(e["exporter"])
+
+    target_domain = entities[1]["domain"]
+    # cross-create
+    with pytest.raises(BadRequestException) as e:
+        pulp_exporter_factory(repositories=[entities[0]["repository"]], pulp_domain=target_domain)
+    assert e.value.status == 400
+    assert json.loads(e.value.body) == {
+        "non_field_errors": [f"Objects must all be a part of the {target_domain.name} domain."]
+    }
+    # cross-update
+    body = {"repositories": [entities[0]["repository"].pulp_href]}
+    with pytest.raises(BadRequestException) as e:
+        pulpcore_bindings.ExportersPulpApi.partial_update(entities[1]["exporter"].pulp_href, body)
+    assert e.value.status == 400
+    assert json.loads(e.value.body) == {
+        "non_field_errors": [f"Objects must all be a part of the {target_domain.name} domain."]
+    }
+
+    body = {"last_export": entities[0]["export"].pulp_href}
+    with pytest.raises(BadRequestException) as e:
+        pulpcore_bindings.ExportersPulpApi.partial_update(entities[1]["exporter"].pulp_href, body)
+    assert e.value.status == 400
+    assert json.loads(e.value.body) == {
+        "non_field_errors": [f"Objects must all be a part of the {target_domain.name} domain."]
+    }
+
+    # cross-export
+    with pytest.raises(BadRequestException) as e:
+        latest_v = entities[0]["repository"].latest_version_href
+        zero_v = latest_v.replace("/1/", "/0/")
+        body = {
+            "start_versions": [latest_v],
+            "versions": [zero_v],
+            "full": False,
+        }
+        pulp_export_factory(entities[1]["exporter"], body)
+    assert e.value.status == 400
+    msgs = json.loads(e.value.body)
+    assert "versions" in msgs
+    assert "start_versions" in msgs
+    assert msgs["versions"] == [
+        "Requested RepositoryVersions must belong to the Repositories named by the Exporter!"
+    ]
+    assert msgs["start_versions"] == [
+        "Requested RepositoryVersions must belong to the Repositories named by the Exporter!"
+    ]

pulpcore/app/apps.py

@@ -239,7 +239,7 @@ class PulpAppConfig(PulpPluginAppConfig):
     label = "core"
 
     # The version of this app
-    version = "3.89.0"
+    version = "3.90.0"
 
     # The python package name providing this app
     python_package_name = "pulpcore"

pulpcore/app/importexport.py

@@ -130,14 +130,30 @@ def export_artifacts(export, artifact_pks):
                             temp_file.write(artifact.file.read())
                             temp_file.flush()
                             artifact.file.close()
-                            export.tarfile.add(temp_file.name, artifact.file.name)
+                            # If we're domain-enabled, replace our domain-pk with "DOMAIN" in
+                            # the tarfile
+                            if settings.DOMAIN_ENABLED:
+                                tarfile_loc = artifact.file.name.replace(
+                                    str(artifact.pulp_domain_id), "DOMAIN"
+                                )
+                            else:
+                                tarfile_loc = artifact.file.name
+                            export.tarfile.add(temp_file.name, tarfile_loc)
         else:
             for offset in range(0, len(artifact_pks), EXPORT_BATCH_SIZE):
                 batch = artifact_pks[offset : offset + EXPORT_BATCH_SIZE]
                 batch_qs = Artifact.objects.filter(pk__in=batch).only("file")
 
                 for artifact in pb.iter(batch_qs.iterator()):
-                    export.tarfile.add(artifact.file.path, artifact.file.name)
+                    # If we're domain-enabled, replace our domain-pk with "DOMAIN" in
+                    # the tarfile
+                    if settings.DOMAIN_ENABLED:
+                        tarfile_loc = artifact.file.name.replace(
+                            str(artifact.pulp_domain_id), "DOMAIN"
+                        )
+                    else:
+                        tarfile_loc = artifact.file.name
+                    export.tarfile.add(artifact.file.path, tarfile_loc)
 
     resource = ArtifactResource()
     resource.queryset = Artifact.objects.filter(pk__in=artifact_pks)

pulpcore/app/management/commands/shell.py

@@ -0,0 +1,8 @@
+from django.core.management.commands import shell
+
+
+class Command(shell.Command):
+    def get_auto_imports(self):
+        # disable automatic imports. See
+        # https://docs.djangoproject.com/en/5.2/howto/custom-shell/
+        return None

pulpcore/app/migrations/0144_delete_old_appstatus.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.23 on 2025-09-09 08:24
+
+from django.db import migrations
+from pulpcore.migrations import RequireVersion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0143_require_app_lock_zdu'),
+    ]
+
+    operations = [
+        RequireVersion("core", "3.87"),
+        migrations.DeleteModel(
+            name='ApiAppStatus',
+        ),
+        migrations.DeleteModel(
+            name='ContentAppStatus',
+        ),
+        migrations.RemoveField(
+            model_name='task',
+            name='worker',
+        ),
+        migrations.DeleteModel(
+            name='Worker',
+        ),
+    ]

pulpcore/app/migrations/0145_domainize_import_export.py

@@ -0,0 +1,53 @@
+# Generated by Django 4.2.23 on 2025-08-21 21:21
+
+from django.db import migrations, models
+import django.db.models.deletion
+import pulpcore.app.util
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0144_delete_old_appstatus"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="export",
+            name="pulp_domain",
+            field=models.ForeignKey(default=pulpcore.app.util.get_domain_pk, on_delete=django.db.models.deletion.PROTECT, to="core.domain"),
+        ),
+        migrations.AddField(
+            model_name="exporter",
+            name="pulp_domain",
+            field=models.ForeignKey(default=pulpcore.app.util.get_domain_pk, on_delete=django.db.models.deletion.PROTECT, to="core.domain"),
+        ),
+        migrations.AlterUniqueTogether(
+            name="exporter",
+            unique_together={("name", "pulp_domain")},
+        ),
+        migrations.AddField(
+            model_name="import",
+            name="pulp_domain",
+            field=models.ForeignKey(default=pulpcore.app.util.get_domain_pk, on_delete=django.db.models.deletion.PROTECT, to="core.domain"),
+        ),
+        migrations.AddField(
+            model_name="importer",
+            name="pulp_domain",
+            field=models.ForeignKey(default=pulpcore.app.util.get_domain_pk, on_delete=django.db.models.deletion.PROTECT, to="core.domain"),
+        ),
+        migrations.AlterUniqueTogether(
+            name="importer",
+            unique_together={("name", "pulp_domain")},
+        ),
+        migrations.AlterField(
+            model_name="exporter",
+            name="name",
+            field=models.TextField(),
+        ),
+        migrations.AlterField(
+            model_name="importer",
+            name="name",
+            field=models.TextField(),
+        ),
+    ]

pulpcore/app/modelresource.py

@@ -1,3 +1,6 @@
+import re
+
+from django.conf import settings
 from import_export import fields
 from import_export.widgets import ForeignKeyWidget
 from logging import getLogger
@@ -8,12 +11,16 @@ from pulpcore.app.models.content import (
     ContentArtifact,
 )
 from pulpcore.app.models.repository import Repository
+from pulpcore.app.util import get_domain_pk, get_domain
 from pulpcore.constants import ALL_KNOWN_CONTENT_CHECKSUMS
 from pulpcore.plugin.importexport import QueryModelResource
 
-
 log = getLogger(__name__)
 
+domain_artifact_file_regex = re.compile(
+    r"^artifact/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
+)
+
 
 #
 # Artifact and Repository are different from other import-export entities, in that they are not
@@ -31,6 +38,25 @@ class ArtifactResource(QueryModelResource):
             kwargs: args passed along from the import() call.
 
         """
+        # IF we're domain-enabled *AND NOT IMPORTING INTO DEFAULT*:
+        #   REPLACE "their" domain-id with ours, if there is one.
+        #   If not, INSERT "our" domain-id into the path in the right place.
+        # Otherwise:
+        #   REMOVE their domain-id if there is one.
+        # Do this before letting QMR run, since it will replace "their" domain-id with "ours"
+        upstream_domain_enabled = re.match(domain_artifact_file_regex, row["file"])
+        into_default = "default" == get_domain().name
+        domain = str(get_domain_pk())
+
+        if settings.DOMAIN_ENABLED and not into_default:  # Replace "their" domain-id with "ours"
+            if upstream_domain_enabled:
+                row["file"] = row["file"].replace(row["pulp_domain"], domain)
+            else:  # Add in our domain-id to the path
+                row["file"] = row["file"].replace("artifact", f"artifact/{domain}")
+        else:  # Strip domain-id out of the artifact-file *if there is one there*
+            if upstream_domain_enabled:
+                row["file"] = row["file"].replace(f'artifact/{row["pulp_domain"]}/', "artifact/")
+
         super().before_import_row(row, **kwargs)
 
         # the export converts None to blank strings but sha384 and sha512 have unique constraints
@@ -39,14 +65,15 @@ class ArtifactResource(QueryModelResource):
             if row[checksum] == "":
                 row[checksum] = None
 
+    def set_up_queryset(self):
+        """
+        :return: Artifacts for a specific domain
+        """
+        return Artifact.objects.filter(pulp_domain_id=get_domain_pk())
+
     class Meta:
         model = Artifact
-        exclude = (
-            "pulp_id",
-            "pulp_created",
-            "pulp_last_updated",
-            "timestamp_of_interest",
-        )
+        exclude = QueryModelResource.Meta.exclude + ("timestamp_of_interest",)
         import_id_fields = (
             "pulp_domain",
             "sha256",
@@ -54,16 +81,20 @@ class ArtifactResource(QueryModelResource):
 
 
 class RepositoryResource(QueryModelResource):
+
+    def set_up_queryset(self):
+        """
+        :return: Repositories for a specific domain
+        """
+        return Repository.objects.filter(pulp_domain_id=get_domain_pk())
+
     class Meta:
         model = Repository
         import_id_fields = (
             "pulp_domain",
             "name",
         )
-        exclude = (
-            "pulp_id",
-            "pulp_created",
-            "pulp_last_updated",
+        exclude = QueryModelResource.Meta.exclude + (
             "content",
             "next_version",
             "repository_ptr",
@@ -72,9 +103,18 @@ class RepositoryResource(QueryModelResource):
         )
 
 
+class ArtifactDomainForeignKeyWidget(ForeignKeyWidget):
+    def get_queryset(self, value, row, *args, **kwargs):
+        qs = self.model.objects.filter(sha256=row["artifact"], pulp_domain_id=get_domain_pk())
+        return qs
+
+    def render(self, value, obj=None, **kwargs):
+        return value.sha256
+
+
 class ContentArtifactResource(QueryModelResource):
     """
-    Handles import/export of the ContentArtifact model.
+    Handles import/export of the ContentArtifact model
 
     ContentArtifact is different from other import-export entities because it has no 'natural key'
     other than a pulp_id, which aren't shared across instances. We do some magic to link up
@@ -85,7 +125,9 @@ class ContentArtifactResource(QueryModelResource):
     """
 
     artifact = fields.Field(
-        column_name="artifact", attribute="artifact", widget=ForeignKeyWidget(Artifact, "sha256")
+        column_name="artifact",
+        attribute="artifact",
+        widget=ArtifactDomainForeignKeyWidget(Artifact, "sha256"),
     )
     linked_content = {}
 
@@ -121,18 +163,21 @@ class ContentArtifactResource(QueryModelResource):
             for content_ids in self.content_mapping.values():
                 content_pks |= set(content_ids)
 
-        return (
+        qs = (
             ContentArtifact.objects.filter(content__in=content_pks)
             .order_by("content", "relative_path")
             .select_related("artifact")
         )
+        return qs
 
     def dehydrate_content(self, content_artifact):
         return str(content_artifact.content_id)
 
     def fetch_linked_content(self):
         linked_content = {}
-        c_qs = Content.objects.filter(upstream_id__isnull=False).values("upstream_id", "pulp_id")
+        c_qs = Content.objects.filter(
+            upstream_id__isnull=False, pulp_domain_id=get_domain_pk()
+        ).values("upstream_id", "pulp_id")
         for c in c_qs.iterator():
             linked_content[str(c["upstream_id"])] = str(c["pulp_id"])
 
@@ -144,9 +189,4 @@ class ContentArtifactResource(QueryModelResource):
             "content",
             "relative_path",
         )
-        exclude = (
-            "pulp_created",
-            "pulp_last_updated",
-            "_artifacts",
-            "pulp_id",
-        )
+        exclude = QueryModelResource.Meta.exclude + ("_artifacts",)