pulpcore 3.49.53__tar.gz → 3.49.55__tar.gz

{pulpcore-3.49.53 → pulpcore-3.49.55}/CHANGES.md

@@ -8,6 +8,50 @@
 
 [//]: # (towncrier release notes start)
 
+## 3.49.55 (2026-03-10) {: #3.49.55 }
+
+### REST API {: #3.49.55-rest-api }
+
+#### Bugfixes {: #3.49.55-rest-api-bugfix }
+
+- Moved artifact checksum validation from module-level settings code to a Django system check.
+  [#7380](https://github.com/pulp/pulpcore/issues/7380)
+- Fixed the url of the generated openapi schemas when using `pulpcore-manager openapi`.
+
+### Plugin API {: #3.49.55-plugin-api }
+
+No significant changes.
+
+### Pulp File {: #3.49.55-pulp-file }
+
+No significant changes.
+
+### Pulp Cert Guard {: #3.49.55-pulp-cert-guard }
+
+No significant changes.
+
+---
+
+## 3.49.54 (2026-03-06) {: #3.49.54 }
+
+### REST API {: #3.49.54-rest-api }
+
+No significant changes.
+
+### Plugin API {: #3.49.54-plugin-api }
+
+No significant changes.
+
+### Pulp File {: #3.49.54-pulp-file }
+
+No significant changes.
+
+### Pulp Cert Guard {: #3.49.54-pulp-cert-guard }
+
+No significant changes.
+
+---
+
 ## 3.49.53 (2026-03-03) {: #3.49.53 }
 
 ### REST API {: #3.49.53-rest-api }

{pulpcore-3.49.53 → pulpcore-3.49.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulpcore
-Version: 3.49.53
+Version: 3.49.55
 Summary: Pulp Django Application and Related Modules
 Home-page: https://pulpproject.org
 Author: Pulp Team
@@ -36,7 +36,7 @@ Requires-Dist: djangorestframework<=3.15.2,>=3.14.0
 Requires-Dist: djangorestframework-queryfields<=1.1.0,>=1.0
 Requires-Dist: drf-access-policy<1.5.1,>=1.1.2
 Requires-Dist: drf-nested-routers<=0.93.5,>=0.93.4
-Requires-Dist: drf-spectacular==0.26.5
+Requires-Dist: drf-spectacular<0.30,>=0.26.5
 Requires-Dist: dynaconf<3.3.0,>=3.1.12
 Requires-Dist: gunicorn<23.1.0,>=20.1
 Requires-Dist: importlib-metadata<=6.0.1,>=6.0.1

{pulpcore-3.49.53 → pulpcore-3.49.55}/pulp_certguard/app/__init__.py

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

{pulpcore-3.49.53 → pulpcore-3.49.55}/pulp_file/app/__init__.py

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

{pulpcore-3.49.53 → pulpcore-3.49.55}/pulpcore/app/apps.py

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

pulpcore-3.49.55/pulpcore/app/checks.py

@@ -0,0 +1,119 @@
+from pathlib import Path
+
+from django.conf import settings
+from django.core.checks import (
+    Debug as CheckDebug,
+    Error as CheckError,
+    Warning as CheckWarning,
+    Tags,
+    register,
+)
+from django.db.models import Q
+
+from pulpcore import constants
+
+
+@register(deploy=True)
+def content_origin_check(app_configs, **kwargs):
+    messages = []
+    if getattr(settings, "CONTENT_ORIGIN", "UNREACHABLE") == "UNREACHABLE":
+        messages.append(
+            CheckError(
+                "CONTENT_ORIGIN is a required setting but it was not configured. This may be "
+                "caused by invalid read permissions of the settings file. Note that "
+                "CONTENT_ORIGIN is set by the installation automatically.",
+                id="pulpcore.E001",
+            )
+        )
+    return messages
+
+
+@register(deploy=True)
+def storage_paths(app_configs, **kwargs):
+    warnings = []
+
+    if settings.STORAGES["default"]["BACKEND"] == "pulpcore.app.models.storage.FileSystem":
+        try:
+            media_root_dev = Path(settings.MEDIA_ROOT).stat().st_dev
+        except OSError:
+            media_root_dev = None
+            warnings.append(
+                CheckWarning(
+                    "Your MEDIA_ROOT setting points to a path that does not exist.",
+                    id="pulpcore.W001",
+                )
+            )
+
+        try:
+            working_dir_dev = Path(settings.WORKING_DIRECTORY).stat().st_dev
+        except OSError:
+            working_dir_dev = None
+            warnings.append(
+                CheckWarning(
+                    "Your WORKING_DIRECTORY setting points to a path that does not exist.",
+                    id="pulpcore.W002",
+                )
+            )
+
+        if media_root_dev and media_root_dev != working_dir_dev:
+            warnings.append(
+                CheckWarning(
+                    "MEDIA_ROOT and WORKING_DIRECTORY are on different filesystems. "
+                    "It is highly recommended that these live on the same filesystem",
+                    id="pulpcore.W003",
+                )
+            )
+
+    return warnings
+
+
+@register(Tags.database)
+def check_artifact_checksums(app_configs, **kwargs):
+    from pulpcore.app.models import Artifact, RemoteArtifact
+
+    messages = []
+    allowed = set(settings.ALLOWED_CONTENT_CHECKSUMS)
+    forbidden = set(constants.ALL_KNOWN_CONTENT_CHECKSUMS).difference(allowed)
+
+    try:
+        for checksum in allowed:
+            if Artifact.objects.filter(**{checksum: None}).exists():
+                messages.append(
+                    CheckError(
+                        f"There have been identified artifacts missing checksum '{checksum}'. "
+                        "Run 'pulpcore-manager handle-artifact-checksums' first to populate "
+                        "missing artifact checksums.",
+                        id="pulpcore.E002",
+                    )
+                )
+        for checksum in forbidden:
+            if Artifact.objects.exclude(**{checksum: None}).exists():
+                messages.append(
+                    CheckWarning(
+                        f"There have been identified artifacts with forbidden checksum "
+                        f"'{checksum}'. Run 'pulpcore-manager handle-artifact-checksums' "
+                        "to unset forbidden checksums.",
+                        id="pulpcore.W004",
+                    )
+                )
+
+        has_any_checksum = ~Q(**{c: None for c in constants.ALL_KNOWN_CONTENT_CHECKSUMS})
+        missing_allowed = Q(**{c: None for c in allowed})
+        if RemoteArtifact.objects.filter(has_any_checksum & missing_allowed).exists():
+            messages.append(
+                CheckWarning(
+                    "Detected remote content without allowed checksums. "
+                    "Run 'pulpcore-manager handle-artifact-checksums --report' to "
+                    "view this content.",
+                    id="pulpcore.W005",
+                )
+            )
+    except Exception:
+        messages.append(
+            CheckDebug(
+                "Skipping artifact checksum checks (table may not exist yet).",
+                id="pulpcore.D001",
+            )
+        )
+
+    return messages

{pulpcore-3.49.53 → pulpcore-3.49.55}/pulpcore/app/settings.py

@@ -19,7 +19,6 @@ from cryptography.fernet import Fernet
 from django.conf import global_settings
 from django.core.files.storage import storages  # noqa: F401
 from django.core.exceptions import ImproperlyConfigured
-from django.db import connection
 
 from pulpcore import constants
 
@@ -307,6 +306,10 @@ SPECTACULAR_SETTINGS = {
     "COMPONENT_NO_READ_ONLY_REQUIRED": True,
     "GENERIC_ADDITIONAL_PROPERTIES": None,
     "DISABLE_ERRORS_AND_WARNINGS": not DEBUG,
+    "POSTPROCESSING_HOOKS": [
+        "drf_spectacular.hooks.postprocess_schema_enums",
+        "pulpcore.openapi.hooks.add_info_hook",
+    ],
     "TITLE": "Pulp 3 API",
     "DESCRIPTION": "Fetch, Upload, Organize, and Distribute Software Packages",
     "VERSION": "v3",
@@ -316,8 +319,9 @@ SPECTACULAR_SETTINGS = {
         "url": "https://pulpproject.org",
     },
     "LICENSE": {
-        "name": "GPLv2+",
         "url": "https://raw.githubusercontent.com/pulp/pulpcore/master/LICENSE",
+        "name": "GNU General Public License v2.0 or later",
+        "identifier": "GPL-2.0-or-later",
     },
 }
 
@@ -471,69 +475,6 @@ FORBIDDEN_CHECKSUMS = set(constants.ALL_KNOWN_CONTENT_CHECKSUMS).difference(
     ALLOWED_CONTENT_CHECKSUMS
 )
 
-_SKIPPED_COMMANDS_FOR_CONTENT_CHECKS = [
-    "handle-artifact-checksums",
-    "migrate",
-    "collectstatic",
-    "openapi",
-]
-
-if not (len(sys.argv) >= 2 and sys.argv[1] in _SKIPPED_COMMANDS_FOR_CONTENT_CHECKS):
-    try:
-        with connection.cursor() as cursor:
-            for checksum in ALLOWED_CONTENT_CHECKSUMS:
-                # can't import Artifact here so use a direct db connection
-                cursor.execute(f"SELECT count(pulp_id) FROM core_artifact WHERE {checksum} IS NULL")
-                row = cursor.fetchone()
-                if row[0] > 0:
-                    raise ImproperlyConfigured(
-                        (
-                            "There have been identified artifacts missing checksum '{}'. "
-                            "Run 'pulpcore-manager handle-artifact-checksums' first to populate "
-                            "missing artifact checksums."
-                        ).format(checksum)
-                    )
-            for checksum in FORBIDDEN_CHECKSUMS:
-                # can't import Artifact here so use a direct db connection
-                cursor.execute(
-                    f"SELECT count(pulp_id) FROM core_artifact WHERE {checksum} IS NOT NULL"
-                )
-                row = cursor.fetchone()
-                if row[0] > 0:
-                    raise ImproperlyConfigured(
-                        (
-                            "There have been identified artifacts with forbidden checksum '{}'. "
-                            "Run 'pulpcore-manager handle-artifact-checksums' first to unset "
-                            "forbidden checksums."
-                        ).format(checksum)
-                    )
-
-            # warn if there are remote artifacts with checksums but no allowed checksums
-            cond = " AND ".join([f"{c} IS NULL" for c in constants.ALL_KNOWN_CONTENT_CHECKSUMS])
-            no_checksum_query = f"SELECT pulp_id FROM core_remoteartifact WHERE {cond}"
-            cond = " AND ".join([f"{c} IS NULL" for c in ALLOWED_CONTENT_CHECKSUMS])
-            cursor.execute(
-                f"SELECT count(pulp_id) FROM core_remoteartifact WHERE {cond} AND "
-                f"pulp_id NOT IN ({no_checksum_query})"
-            )
-            row = cursor.fetchone()
-            if row[0] > 0:
-                _logger.warning(
-                    (
-                        "Warning: detected remote content without allowed checksums. "
-                        "Run 'pulpcore-manager handle-artifact-checksums --report' to "
-                        "view this content."
-                    )
-                )
-
-    except ImproperlyConfigured as e:
-        raise e
-    except Exception:
-        # our check could fail if the table hasn't been created yet or we can't get a db connection
-        pass
-    finally:
-        connection.close()
-
 # Ensures the cached property storage.backends uses the right value after dynaconf init
 storages._backends = settings.STORAGES.copy()
 storages.backends

{pulpcore-3.49.53 → pulpcore-3.49.55}/pulpcore/openapi/__init__.py

@@ -5,6 +5,7 @@ from urllib.parse import urljoin
 
 from django.conf import settings
 from django.core.exceptions import FieldDoesNotExist
+from django.http import HttpRequest
 from django.utils.html import strip_tags
 from drf_spectacular.drainage import reset_generator_stats
 from drf_spectacular.generators import SchemaGenerator
@@ -21,9 +22,11 @@ from drf_spectacular.plumbing import (
 )
 from drf_spectacular.settings import spectacular_settings
 from drf_spectacular.types import OpenApiTypes
-from drf_spectacular.utils import OpenApiParameter, extend_schema_field
+from drf_spectacular.utils import OpenApiParameter, extend_schema, extend_schema_field
+from drf_spectacular.extensions import OpenApiViewExtension, OpenApiAuthenticationExtension
 from rest_framework import mixins, serializers
 from rest_framework.exceptions import ParseError
+from rest_framework.request import Request
 from rest_framework.schemas.utils import get_pk_description
 
 from pulpcore.app.apps import pulp_plugin_configs
@@ -36,11 +39,14 @@ else:
     API_ROOT_NO_FRONT_SLASH = settings.V3_API_ROOT_NO_FRONT_SLASH
 API_ROOT_NO_FRONT_SLASH = API_ROOT_NO_FRONT_SLASH.replace("<", "{").replace(">", "}")
 
-
 # Python does not distinguish integer sizes. The safest assumption is that they are large.
 extend_schema_field(OpenApiTypes.INT64)(serializers.IntegerField)
 
 
+class InheritSerializer(serializers.Serializer):
+    """This is a dummy tracer to allow mixins to refer to the natural serializer of a viewset."""
+
+
 class PulpAutoSchema(AutoSchema):
     """Pulp Auto Schema."""
 
@@ -51,6 +57,7 @@ class PulpAutoSchema(AutoSchema):
         "patch": "partial_update",
         "delete": "delete",
     }
+    V3_API = API_ROOT_NO_FRONT_SLASH.replace("{pulp_domain}/", "")
 
     def _tokenize_path(self):
         """
@@ -78,7 +85,7 @@ class PulpAutoSchema(AutoSchema):
             if not tokenized_path and getattr(self.view, "get_view_name", None):
                 tokenized_path.extend(self.view.get_view_name().split())
 
-        path = "/".join(tokenized_path).replace(settings.V3_API_ROOT_NO_FRONT_SLASH, "")
+        path = "/".join(tokenized_path).replace(self.V3_API, "")
         tokenized_path = path.split("/")
 
         return tokenized_path
@@ -193,6 +200,19 @@ class PulpAutoSchema(AutoSchema):
             name = name + "Response"
         return name
 
+    def get_override_parameters(self):
+        parameters = super().get_override_parameters()
+        parameters.append(
+            OpenApiParameter(
+                name="X-Task-Diagnostics",
+                location=OpenApiParameter.HEADER,
+                required=False,
+                type={"type": "array", "items": {"type": "string"}},
+                description="List of profilers to use on tasks.",
+            )
+        )
+        return parameters
+
     def map_parsers(self):
         """
         Get request parsers.
@@ -213,82 +233,11 @@ class PulpAutoSchema(AutoSchema):
             request_body["required"] = True
         return request_body
 
-    def _resolve_path_parameters(self, variables):
-        """
-        Resolve path parameters.
-
-        Extended to omit undesired warns.
-        """
-        model = getattr(getattr(self.view, "queryset", None), "model", None)
-        parameters = []
-
-        for variable in variables:
-            schema = build_basic_type(OpenApiTypes.STR)
-            description = ""
-
-            resolved_parameter = resolve_django_path_parameter(
-                self.path_regex,
-                variable,
-                self.map_renderers("format"),
-            )
-            if not resolved_parameter:
-                resolved_parameter = resolve_regex_path_parameter(self.path_regex, variable)
-
-            if resolved_parameter:
-                schema = resolved_parameter["schema"]
-            elif model:
-                try:
-                    model_field = model._meta.get_field(variable)
-                    schema = self._map_model_field(model_field, direction=None)
-                    # strip irrelevant meta data
-                    irrelevant_field_meta = ["readOnly", "writeOnly", "nullable", "default"]
-                    schema = {k: v for k, v in schema.items() if k not in irrelevant_field_meta}
-                    if "description" not in schema and model_field.primary_key:
-                        description = get_pk_description(model, model_field)
-                except FieldDoesNotExist:
-                    pass
-
-            # Used by the bindings to identify which param is the domain path
-            extensions = {}
-            if settings.DOMAIN_ENABLED and variable == "pulp_domain":
-                extensions["x-isDomain"] = True
-
-            parameters.append(
-                build_parameter_type(
-                    name=variable,
-                    location=OpenApiParameter.PATH,
-                    description=description,
-                    schema=schema,
-                    extensions=extensions,
-                )
-            )
-
-        return parameters
-
-    def resolve_serializer(self, serializer, direction):
-        """Serializer to component."""
-        component_schema = self._map_serializer(serializer, direction)
-        if not component_schema.get("properties", {}):
-            component = ResolvedComponent(
-                name=self._get_serializer_name(serializer, direction),
-                type=ResolvedComponent.SCHEMA,
-                object=serializer,
-            )
-            if component in self.registry:
-                return self.registry[component]
-
-            component.schema = component_schema
-            self.registry.register(component)
-
-        else:
-            component = super().resolve_serializer(serializer, direction)
-
-        return component
-
     def _get_response_bodies(self):
         """
         Handle response status code.
         """
+        # DRF handles this most of the time. But it seems set_label still needs it.
         response = super()._get_response_bodies()
         if (
             self.method == "POST"
@@ -299,6 +248,15 @@ class PulpAutoSchema(AutoSchema):
 
         return response
 
+    def _get_response_for_code(
+        self, serializer, status_code, media_types=None, direction="response"
+    ):
+        """Hack to replace the InheritSerializer with the real deal."""
+        if serializer == InheritSerializer:
+            serializer = self._get_serializer()
+
+        return super()._get_response_for_code(serializer, status_code, media_types, direction)
+
 
 class PulpSchemaGenerator(SchemaGenerator):
     """Pulp Schema Generator."""
@@ -311,7 +269,7 @@ class PulpSchemaGenerator(SchemaGenerator):
             prefix (str): Optional prefix to add to the slug
             pulp_model_alias (str): Optional model name to use instead of model.__name__
         Returns:
-            str: *pulp_href where * is the model name in all lower case letters
+            str: '{model_name_snake_case}_href'
         """
         app_label = model._meta.app_label
         model_name = pulp_model_alias or model.__name__
@@ -377,7 +335,7 @@ class PulpSchemaGenerator(SchemaGenerator):
             resource_path = "%s}/" % path.rsplit(sep="}", maxsplit=1)[0]
             # This check prevents /pulp/{pulp_domain}/ from being converted for non-detail endpoints
             # Possibly affects plugin-specific urls, depends on their url structure
-            if resource_path.lstrip("/") not in API_ROOT_NO_FRONT_SLASH:
+            if not resource_path.endswith("/{pulp_domain}/"):
                 path = path.replace(resource_path, "{%s}" % param_name)
         return path
 
@@ -470,51 +428,47 @@ class PulpSchemaGenerator(SchemaGenerator):
 
     def get_schema(self, request=None, public=False):
         """Generate a OpenAPI schema."""
-        reset_generator_stats()
+        if request is None:
+            request = Request(HttpRequest())
+            request.META["SERVER_NAME"] = "localhost"
+            request.META["SERVER_PORT"] = "24817"
 
         apps = list(pulp_plugin_configs())
+        if request and "plugin" in request.query_params:
+            raise ParseError("'plugin' has been removed. Use 'component' instead.")
         if request and "component" in request.query_params:
             # /pulp/api/v3/docs/api.json?component=core,file
-            if "plugin" in request.query_params:
-                raise ParseError("'component' and 'plugin' cannot be combined.")
             app_labels = request.query_params["component"].split(",")
+            if "core" not in app_labels:
+                core_app = [app for app in apps if app.label == "core"]
+            else:
+                core_app = []
             apps = [app for app in apps if app.label in app_labels]
             if len(apps) != len(app_labels):
                 raise ParseError("Invalid component specified.")
             request.plugins = [app.name.split(".")[0] for app in apps]
+            # Adding core back because we want to report it's version too.
+            apps.extend(core_app)
+        request.apps = apps
 
-        if request and "plugin" in request.query_params:
-            # /pulp/api/v3/docs/api.json?plugin=pulp_file
-            deprecation_logger.warn(
-                _(
-                    "The query parameter `plugin` has been deprecated and "
-                    "will be removed with pulpcore>=3.55. "
-                    "Please use `component` with a list of app labels instead."
-                )
-            )
-            request.plugins = request.query_params["plugin"].split(",")
+        request.bindings = "bindings" in request.query_params
 
-        result = build_root_object(
-            paths=self.parse(request, public),
-            components=self.registry.build(spectacular_settings.APPEND_COMPONENTS),
-            version=self.api_version or getattr(request, "version", None),
-        )
-        for hook in spectacular_settings.POSTPROCESSING_HOOKS:
-            result = hook(result=result, generator=self, request=request, public=public)
+        result = super().get_schema(request, public)
 
-        # Basically I'm doing it to get pulp logo at redoc page
-        result["info"]["x-logo"] = {
-            "url": "https://pulp.plan.io/attachments/download/517478/pulp_logo_word_rectangle.svg"
-        }
-
-        # Adding plugin version config
-        result["info"]["x-pulp-app-versions"] = {app.label: app.version for app in apps}
+        if request.bindings:
+            # Undo the spectacular sanitization of operation ids
+            for path, path_spec in result["paths"].items():
+                for operation, operation_spec in path_spec.items():
+                    operation_spec["operationId"] = operation_spec.pop("x-copy-operationId")
+        return result
 
-        # Add domain-settings value
-        result["info"]["x-pulp-domain-enabled"] = settings.DOMAIN_ENABLED
 
-        # Adding current host as server (it will provide a default value for the bindings)
-        server_url = "http://localhost:24817" if not request else request.build_absolute_uri("/")
-        result["servers"] = [{"url": server_url}]
+class BasicAuthenticationScheme(OpenApiAuthenticationExtension):
+    target_class = "pulpcore.app.authentication.BasicAuthentication"
+    name = "basicAuth"
 
-        return normalize_result_object(result)
+    def get_security_definition(self, auto_schema):
+        return {
+            "type": "http",
+            "scheme": "basic",
+        }

pulpcore-3.49.55/pulpcore/openapi/hooks.py

@@ -0,0 +1,36 @@
+from django.conf import settings
+
+
+def add_info_hook(result, generator, request, **kwargs):
+    # Basically I'm doing it to get pulp logo at redoc page
+    result["info"]["x-logo"] = {"url": "https://pulpproject.org/assets/pulp_logo_icon.svg"}
+
+    if result["openapi"].split(".", maxsplit=2)[:-1] == ["3", "0"]:
+        result["info"]["license"].pop("identifier", None)
+    else:
+        result["info"]["license"].pop("url", None)
+
+    # Adding plugin version config
+    result["info"]["x-pulp-app-versions"] = {app.label: app.version for app in request.apps}
+
+    # Add domain-settings value
+    result["info"]["x-pulp-domain-enabled"] = settings.DOMAIN_ENABLED
+
+    # Add x-isDomain flag to domain path parameters
+    # Save a copy of the bad operationId in case we generate bindings
+    for path, path_spec in result["paths"].items():
+        for operation, operation_spec in path_spec.items():
+            if request.bindings:
+                # Keep the operation id before sanitization
+                operation_spec["x-copy-operationId"] = operation_spec["operationId"]
+            if settings.DOMAIN_ENABLED:
+                parameters = operation_spec.get("parameters")
+                if parameters:
+                    for parameter in parameters:
+                        if parameter["name"] == "pulp_domain" and parameter["in"] == "path":
+                            parameter["x-isDomain"] = True
+
+    # Adding current host as server (it will provide a default value for the bindings)
+    result["servers"] = [{"url": request.build_absolute_uri("/")}]
+
+    return result