pulpcore 3.83.2__py3-none-any.whl → 3.85.0__py3-none-any.whl

pulp_certguard/tests/unit/test_rhsm_check_path.py

@@ -0,0 +1,213 @@
+from cryptography import x509
+import pytest
+
+from . import certdata
+
+from pulp_certguard.rhsm import check_path
+from pulp_certguard.rhsm.rhsm_check_path import (
+    bitstream,
+    Entitlement,
+    HuffmannNode,
+    cert_version,
+    split_count,
+    V1_PATH_OID_REGEX,
+)
+
+
+@pytest.fixture(scope="session")
+def ent_v1() -> x509.Certificate:
+    return x509.load_pem_x509_certificate(certdata.ENTITLEMENT_CERT_V1_0.encode())
+
+
+@pytest.fixture(scope="session")
+def ent_v3_0() -> x509.Certificate:
+    return x509.load_pem_x509_certificate(certdata.ENTITLEMENT_CERT_V3_0.encode())
+
+
+@pytest.fixture(scope="session")
+def ent_v3_2() -> x509.Certificate:
+    return x509.load_pem_x509_certificate(certdata.ENTITLEMENT_CERT_V3_2.encode())
+
+
+@pytest.fixture(scope="session", params=["3.0", "3.2"])
+def ent_v3_version(request: pytest.FixtureRequest) -> str:
+    return request.param
+
+
+@pytest.fixture(scope="session")
+def ent_v3(ent_v3_version: str) -> x509.Certificate:
+    ver = ent_v3_version.replace(".", "_")
+    attribute = f"ENTITLEMENT_CERT_V{ver}"
+    return x509.load_pem_x509_certificate(getattr(certdata, attribute).encode())
+
+
+class TestSplitCount:
+    """
+    If the first byte is < 128, that is the count itself.
+    Otherwise the 7 lsb describe the number of bytes to combine to the count.
+    """
+
+    @pytest.mark.parametrize(
+        "header, count",
+        [
+            pytest.param(b"\x00", 0, id="short zero"),
+            pytest.param(b"\x0a", 10, id="short ten"),
+            pytest.param(b"\x7f", 127, id="short max"),
+            pytest.param(b"\x80", 0, id="zero bytes zero"),
+            pytest.param(b"\x81\x00", 0, id="one byte zero"),
+            pytest.param(b"\x81\x01", 1, id="one byte one"),
+            pytest.param(b"\x81\xff", 255, id="one byte max"),
+            pytest.param(b"\x84\x00\x00\x00\x00", 0, id="four bytes zero"),
+            pytest.param(b"\x84\x00\x00\x00\x01", 1, id="four bytes one"),
+            pytest.param(b"\x84\x00\x00\x01\x00", 256, id="four bytes 256"),
+            pytest.param(b"\x84\x00\x00\x01\x04", 260, id="four bytes 260"),
+        ],
+    )
+    def test_returns_count_from(self, header: bytes, count: int) -> None:
+        assert split_count(header + b"\xde\xad\xbe\xaf") == (count, b"\xde\xad\xbe\xaf")
+
+
+class TestBitstream:
+    def test_0000_produces_16_false(self) -> None:
+        assert list(bitstream(b"\x00\x00")) == [False] * 16
+
+    def test_0001_produces_15_false_true(self) -> None:
+        assert list(bitstream(b"\x00\x01")) == [False] * 15 + [True]
+
+    def test_fff0_produces_12_true_4_false(self) -> None:
+        assert list(bitstream(b"\xff\xf0")) == [True] * 12 + [False] * 4
+
+
+def test_product_certificate_has_subject() -> None:
+    cert = x509.load_pem_x509_certificate(certdata.PRODUCT_CERT_V1_0.encode())
+    assert cert.subject.rfc4514_string() == "CN=100000000000002"
+
+
+class TestV1EntitlementCertificate:
+    def test_has_subject(self, ent_v1: x509.Certificate) -> None:
+        assert ent_v1.subject.rfc4514_string() == "CN=ff80808138574bd20138574d85a50b2f"
+
+    def test_has_4_paths(self, ent_v1: x509.Certificate) -> None:
+        assert (
+            len(
+                [ext for ext in ent_v1.extensions if V1_PATH_OID_REGEX.match(ext.oid.dotted_string)]
+            )
+            == 4
+        )
+
+    def test_has_version_1_0(self, ent_v1: x509.Certificate) -> None:
+        assert cert_version(ent_v1) == "1.0"
+
+
+class TestV3EntitlementCertificate:
+    def test_cert_version(self, ent_v3_version: str, ent_v3: x509.Certificate) -> None:
+        assert cert_version(ent_v3) == ent_v3_version
+
+
+class TestEntitlement:
+    @pytest.fixture(scope="class")
+    def entitlement(self, ent_v3: x509.Certificate) -> Entitlement:
+        return Entitlement(ent_v3)
+
+    @pytest.fixture(scope="class")
+    def word_tree(self, ent_v3: x509.Certificate) -> "HuffmannNode[str]":
+        lex_data, _, _ = Entitlement._split_payload(Entitlement._read_payload(ent_v3))
+        return Entitlement._build_word_tree(lex_data)
+
+    def test_has_node_count_10(self, ent_v3: x509.Certificate) -> None:
+        _, node_count, _ = Entitlement._split_payload(Entitlement._read_payload(ent_v3))
+        assert node_count == 10
+
+    def test_00_decodes_to_empty(self, word_tree: "HuffmannNode[str]") -> None:
+        assert word_tree.decode(iter([False, False])) == ""
+
+    def test_100_decodes_to_path(self, word_tree: "HuffmannNode[str]") -> None:
+        assert word_tree.decode(iter([True, False, False])) == "path"
+
+    def test_path_tree_root_contains_foo_and_path(self, entitlement: Entitlement) -> None:
+        assert {"foo", "path"} == entitlement._path_tree.keys()
+
+    def test_path_tree_contains_foo_path_never(self, entitlement: Entitlement) -> None:
+        assert entitlement._path_tree["foo"]["path"]["never"] == {}
+
+    def test_path_tree_contains_foo_path_var_always(self, entitlement: Entitlement) -> None:
+        assert entitlement._path_tree["foo"]["path"]["always"]["$releasever"] == {}
+
+
+class TestCheckPathV1:
+    @pytest.mark.parametrize(
+        "path",
+        (
+            "/foo/path/never",
+            "/foo/path/never/",
+            "//foo/path/never/",
+            "/foo/path/never/bar/a/b/c",
+            "/foo/path/never/bar//a/b/c",
+            "/foo//path/never/bar//a/b/c",
+        ),
+    )
+    def test_matches_foo_path_never(self, ent_v1: x509.Certificate, path: str) -> None:
+        assert check_path(ent_v1, path)
+
+    @pytest.mark.parametrize(
+        "path",
+        (
+            pytest.param("/path/never", id="misses the first part"),
+            pytest.param("foo", id="is only the middle part"),
+            "/foo",
+            "/foo/",
+            pytest.param("/foo/path/", id="misses the last part"),
+            pytest.param("baz/foo/path/never", id="prepended parts"),
+            pytest.param("/path/to//bar/awesomeos", id="substituted an empty string"),
+            pytest.param("/path/to/foo/bar/awesomeo", id="misses the last character"),
+            pytest.param("/path/to/foo/bar/awesomeos1", id="adds characters at the end"),
+        ),
+    )
+    def test_rejects_a_path_that(self, ent_v1: x509.Certificate, path: str) -> None:
+        assert not check_path(ent_v1, path)
+
+    @pytest.mark.parametrize(
+        "path",
+        (
+            "/path/to/foo/bar/awesomeos",
+            "/path/to/foo/bar/awesomeos/",
+            "/path/to/foo/bar/awesomeos/a/b/c",
+            "/path/to//bar/foo/awesomeos",
+        ),
+    )
+    def test_matches_path_with_substituted_variables(
+        self, ent_v1: x509.Certificate, path: str
+    ) -> None:
+        assert check_path(ent_v1, path)
+
+
+class TestCheckPathV3:
+    @pytest.mark.parametrize(
+        "path",
+        (
+            pytest.param("/foo/path/never", id="exact path without vars"),
+            pytest.param("/foo/path/never/a/b/c", id="exact path with extra segments"),
+            pytest.param(
+                "////foo///path//never///", id="exact path without vars and extra slashes"
+            ),
+            pytest.param("foo/path/always/c-3po", id="exact path with variable"),
+            pytest.param("/path/to/awesomeos/x86_64", id="another exact path without vars"),
+            pytest.param("/path/to/c-3po/r2-d2/awesomeos", id="another exact path with vars"),
+        ),
+    )
+    def test_matches(self, ent_v3: x509.Certificate, path: str) -> None:
+        assert check_path(ent_v3, path)
+
+    @pytest.mark.parametrize(
+        "path",
+        (
+            pytest.param("/a/path/to/wherever", id="lunatic path"),
+            pytest.param("", id="empty path"),
+            pytest.param("////", id="just slashes"),
+            pytest.param("foo", id="to short path"),
+            pytest.param("path/never", id="path with front segment missing"),
+            pytest.param("content/foo/path/never", id="path with extra front segment"),
+        ),
+    )
+    def test_rejects(self, ent_v3: x509.Certificate, path: str) -> None:
+        assert not check_path(ent_v3, path)

pulp_file/app/__init__.py

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

pulp_file/app/migrations/0001_initial_squashed_0016_add_domain.py

@@ -7,28 +7,8 @@ import pulpcore.app.util
 
 class Migration(migrations.Migration):
 
-    replaces = [
-        ("file", "0001_initial"),
-        ("file", "0002_file_related_names"),
-        ("file", "0003_auto_20191014_1721"),
-        ("file", "0004_filefilesystemexporter"),
-        ("file", "0005_filerepository"),
-        ("file", "0006_delete_filefilesystemexporter"),
-        ("file", "0007_filefilesystemexporter"),
-        ("file", "0008_add_manifest_field"),
-        ("file", "0009_move_data_to_new_master_distribution_model"),
-        ("file", "0010_auto_publish"),
-        ("file", "0011_fix_auto_publish"),
-        ("file", "0012_delete_filefilesystemexporter"),
-        ("file", "0013_file_acs"),
-        ("file", "0014_new_rbac_permissions"),
-        ("file", "0015_allow_null_manifest"),
-        ("file", "0016_add_domain"),
-    ]
-
     dependencies = [
         ("core", "0102_add_domain_relations"),
-        ("core", "0091_systemid"),
     ]
 
     operations = [

pulp_file/app/migrations/0017_alter_filealternatecontentsource_alternatecontentsource_ptr_and_more.py

@@ -8,7 +8,7 @@ import pulpcore.app.util
 class Migration(migrations.Migration):
 
     dependencies = [
-        ('file', '0016_add_domain'),
+        ('file', '0001_initial_squashed_0016_add_domain'),
     ]
 
     operations = [

pulpcore/app/apps.py

@@ -5,6 +5,7 @@ from gettext import gettext as _
 from importlib import import_module
 
 from django import apps
+from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.db import connection, transaction
 from django.db.models.signals import post_migrate
@@ -67,15 +68,6 @@ class PulpPluginAppConfig(apps.AppConfig):
 
     def __init__(self, app_name, app_module):
         super().__init__(app_name, app_module)
-        # begin Compatilibity layer for DEFAULT_FILE_STORAGE deprecation
-        # Remove on pulpcore=3.85 or pulpcore=4.0
-        # * Workaround for getting the up-to-date settings instance, otherwise is doesnt
-        #   get the patch in settings.py
-        # * Update code in signal handlers to use module-level imports again
-        from django.conf import settings
-
-        self.settings = settings
-        # end
 
         try:
             self.version
@@ -247,7 +239,7 @@ class PulpAppConfig(PulpPluginAppConfig):
     label = "core"
 
     # The version of this app
-    version = "3.83.2"
+    version = "3.85.0"
 
     # The python package name providing this app
     python_package_name = "pulpcore"
@@ -322,7 +314,6 @@ def _populate_system_id(sender, apps, verbosity, **kwargs):
 
 
 def _ensure_default_domain(sender, **kwargs):
-    settings = sender.settings
     table_names = connection.introspection.table_names()
     if "core_domain" in table_names:
         from pulpcore.app.util import get_default_domain
@@ -402,7 +393,6 @@ def adjust_roles(apps, role_prefix, desired_roles, verbosity=1):
 
 
 def _populate_artifact_serving_distribution(sender, apps, verbosity, **kwargs):
-    settings = sender.settings
     if (
         settings.STORAGES["default"]["BACKEND"] == "pulpcore.app.models.storage.FileSystem"
         or not settings.REDIRECT_TO_OBJECT_STORAGE

pulpcore/app/entrypoint.py

@@ -7,7 +7,8 @@ import click
 import django
 from django.conf import settings
 from django.db import connection
-from django.db.utils import InterfaceError, DatabaseError
+from django.db.utils import IntegrityError, InterfaceError, DatabaseError
+from gunicorn.arbiter import Arbiter
 from gunicorn.workers.sync import SyncWorker
 
 from pulpcore.app.apps import pulp_plugin_configs
@@ -27,26 +28,21 @@ class PulpApiWorker(SyncWorker):
 
     def heartbeat(self):
         try:
-            self.api_app_status, created = self.ApiAppStatus.objects.get_or_create(
-                name=self.name, defaults={"versions": self.versions}
-            )
-
-            if not created:
-                self.api_app_status.save_heartbeat()
-
-                if self.api_app_status.versions != self.versions:
-                    self.api_app_status.versions = self.versions
-                    self.api_app_status.save(update_fields=["versions"])
-
+            self.app_status.save_heartbeat()
             logger.debug(self.beat_msg)
         except (InterfaceError, DatabaseError):
             connection.close_if_unusable_or_obsolete()
-            logger.info(self.fail_beat_msg)
+            try:
+                self.app_status.save_heartbeat()
+                logger.debug(self.beat_msg)
+            except (InterfaceError, DatabaseError):
+                logger.error(self.fail_beat_msg)
+                exit(Arbiter.WORKER_BOOT_ERROR)
 
     def init_process(self):
         os.environ.setdefault("DJANGO_SETTINGS_MODULE", "pulpcore.app.settings")
         django.setup()
-        from pulpcore.app.models import ApiAppStatus
+        from pulpcore.app.models import AppStatus
 
         if settings.API_APP_TTL < 2 * self.timeout:
             logger.warning(
@@ -56,9 +52,6 @@ class PulpApiWorker(SyncWorker):
                 self.timeout,
             )
 
-        self.ApiAppStatus = ApiAppStatus
-        self.api_app_status = None
-
         self.name = "{pid}@{hostname}".format(pid=self.pid, hostname=socket.gethostname())
         self.versions = {app.label: app.version for app in pulp_plugin_configs()}
         self.beat_msg = (
@@ -67,9 +60,16 @@ class PulpApiWorker(SyncWorker):
             )
         )
         self.fail_beat_msg = (
-            "Api App '{name}' failed to write a heartbeat to the database, sleeping for "
-            "'{interarrival}' seconds."
-        ).format(name=self.name, interarrival=self.timeout)
+            "Api App '{name}' failed to write a heartbeat to the database."
+        ).format(name=self.name)
+        try:
+            self.app_status = AppStatus.objects.create(
+                name=self.name, app_type="api", versions=self.versions
+            )
+        except IntegrityError:
+            logger.error(f"An API app with name {self.name} already exists in the database.")
+            exit(Arbiter.WORKER_BOOT_ERROR)
+
         super().init_process()
 
     def run(self):
@@ -77,8 +77,8 @@ class PulpApiWorker(SyncWorker):
             super().run()
         finally:
             # cleanup
-            if self.api_app_status:
-                self.api_app_status.delete()
+            if self.app_status:
+                self.app_status.delete()
 
 
 class PulpcoreApiApplication(PulpcoreGunicornApplication):

pulpcore/app/migrations/0001_squashed_0090_char_to_text_field.py

@@ -20,105 +20,10 @@ import uuid
 
 class Migration(migrations.Migration):
 
-    replaces = [
-        ("core", "0001_initial"),
-        ("core", "0002_increase_artifact_size_field"),
-        ("core", "0003_remove_upload_completed"),
-        ("core", "0004_add_duplicated_reserved_resources"),
-        ("core", "0005_progressreport_code"),
-        ("core", "0006_repository_plugin_managed"),
-        ("core", "0007_delete_progress_proxies"),
-        ("core", "0008_published_metadata_as_content"),
-        ("core", "0009_remove_task_non_fatal_errors"),
-        ("core", "0010_pulp_fields"),
-        ("core", "0011_relative_path"),
-        ("core", "0012_auto_20191104_2000"),
-        ("core", "0013_repository_pulp_type"),
-        ("core", "0014_remove_repository_plugin_managed"),
-        ("core", "0015_auto_20191112_1426"),
-        ("core", "0016_charfield_to_textfield"),
-        ("core", "0017_remove_task_parent"),
-        ("core", "0018_auto_20191127_2350"),
-        ("core", "0019_add_signing_service_model"),
-        ("core", "0020_change_publishedartifact_constraints"),
-        ("core", "0021_add_signing_service_foreign_key"),
-        ("core", "0022_rename_last_version"),
-        ("core", "0023_change_exporter_models"),
-        ("core", "0024_use_local_storage_for_uploads"),
-        ("core", "0025_task_parent_task"),
-        ("core", "0026_task_group"),
-        ("core", "0027_export_backend"),
-        ("core", "0028_import_importer_pulpimporter_pulpimporterrepository"),
-        ("core", "0029_export_delete"),
-        ("core", "0030_taskgroup_all_tasks_dispatched"),
-        ("core", "0031_import_export_validate_params"),
-        ("core", "0032_export_to_chunks"),
-        ("core", "0033_increase_remote_artifact_size_field"),
-        ("core", "0034_groupprogressreport"),
-        ("core", "0035_content_upstream_id"),
-        ("core", "0036_unprotect_last_export"),
-        ("core", "0037_pulptemporaryfile"),
-        ("core", "0038_repository_remote"),
-        ("core", "0039_change_download_concurrency"),
-        ("core", "0040_set_admin_is_staff"),
-        ("core", "0041_accesspolicy"),
-        ("core", "0042_rbac_for_tasks"),
-        ("core", "0043_toc_attribute"),
-        ("core", "0044_temp_file_artifact_field"),
-        ("core", "0045_accesspolicy_permissions_allow_null"),
-        ("core", "0046_task__resource_job_id"),
-        ("core", "0047_improve_orphan_cleanup"),
-        ("core", "0048_fips_checksums"),
-        ("core", "0049_add_file_field_to_uploadchunk"),
-        ("core", "0050_namespace_access_policies"),
-        ("core", "0051_timeoutfields"),
-        ("core", "0052_tasking_logging_cid"),
-        ("core", "0053_remote_headers"),
-        ("core", "0054_add_public_key"),
-        ("core", "0055_label"),
-        ("core", "0056_remote_rate_limit"),
-        ("core", "0057_add_label_indexes"),
-        ("core", "0058_accesspolicy_customized"),
-        ("core", "0059_proxy_creds"),
-        ("core", "0060_data_migration_proxy_creds"),
-        ("core", "0061_call_handle_artifact_checksums_command"),
-        ("core", "0062_add_new_distribution_mastermodel"),
-        ("core", "0063_repository_retained_versions"),
-        ("core", "0064_repository_user_hidden"),
-        ("core", "0064_add_new_style_task_columns"),
-        ("core", "0065_merge_20210615_1211"),
-        ("core", "0066_download_concurrency_and_retry_changes"),
-        ("core", "0067_add_protect_to_task_reservation"),
-        ("core", "0068_add_timestamp_of_interest"),
-        ("core", "0069_update_json_fields"),
-        ("core", "0070_rename_retained_versions"),
-        ("core", "0071_filesystemexport_filesystemexporter"),
-        ("core", "0072_add_method_to_filesystem_exporter"),
-        ("core", "0073_encrypt_remote_fields"),
-        ("core", "0074_acs"),
-        ("core", "0075_rbaccontentguard"),
-        ("core", "0076_remove_reserved_resource"),
-        ("core", "0077_move_remote_url_credentials"),
-        ("core", "0078_grouprole_role_userrole"),
-        ("core", "0079_rename_permissions_assignment_accesspolicy_creation_hooks"),
-        ("core", "0080_proxy_group_model"),
-        ("core", "0081_reapplabel_group_permissions"),
-        ("core", "0082_add_manage_roles_permissions"),
-        ("core", "0083_alter_group_options"),
-        ("core", "0084_alter_rbaccontentguard_options"),
-        ("core", "0085_contentredirectcontentguard"),
-        ("core", "0086_task_json_fields"),
-        ("core", "0087_taskschedule"),
-        ("core", "0088_accesspolicy_queryset_scoping"),
-        ("core", "0089_alter_contentredirectcontentguard_options"),
-        ("core", "0090_char_to_text_field"),
-    ]
-
     initial = True
 
     dependencies = [
         ("auth", "0012_alter_user_first_name_max_length"),
-        ("auth", "__first__"),
         ("contenttypes", "0002_remove_content_type_name"),
     ]
 

pulpcore/app/migrations/0091_systemid.py

@@ -8,7 +8,7 @@ import uuid
 class Migration(migrations.Migration):
 
     dependencies = [
-        ('core', '0090_char_to_text_field'),
+        ('core', '0001_squashed_0090_char_to_text_field'),
     ]
 
     operations = [

pulpcore/app/migrations/0134_task_insert_trigger.py

@@ -0,0 +1,81 @@
+# Generated by Django 4.2.22 on 2025-06-06 14:32
+
+from django.db import migrations
+from pulpcore.migrations import RequireVersion
+
+# This migration is supposed to be zero downtime upgrade safe.
+
+
+TASK_INSERT_TRIGGER_UP = """
+CREATE FUNCTION on_insert_timestamp_task()
+  RETURNS TRIGGER
+  LANGUAGE plpgsql
+  AS $$
+    DECLARE
+      res_list text[];
+      res_list_shared text[];
+    BEGIN
+      res_list := array_agg(q.res) FROM (SELECT regexp_replace(unnest(NEW.reserved_resources_record), '^shared:', '') res) AS q;
+      res_list_shared := array_agg(q.res) FROM (SELECT 'shared:' || unnest(res_list) AS res) AS q;
+      PERFORM pg_advisory_xact_lock(4711, q.id) FROM (SELECT hashtext(res) AS id FROM unnest(res_list) AS res ORDER BY id) AS q;
+      NEW.pulp_created = clock_timestamp();
+      IF NEW.pulp_created <= (
+        SELECT max(pulp_created) FROM core_task
+        WHERE
+          state NOT IN ('completed', 'failed', 'canceled', 'skipped')
+        AND
+          reserved_resources_record && (res_list || res_list_shared)
+      )
+      THEN
+        RAISE EXCEPTION 'Clock screw detected.';
+      END IF;
+      RETURN NEW;
+    END;
+  $$
+;
+
+CREATE FUNCTION on_update_timestamp_task()
+  RETURNS TRIGGER
+  LANGUAGE plpgsql
+  AS $$
+    BEGIN
+      -- This is mainly a safeguard to prevent old code from messing with the timestamp, now that the database is in charge.
+      RAISE EXCEPTION 'Updating pulp_created is not allowed.';
+    END;
+  $$
+;
+
+CREATE TRIGGER on_insert_timestamp_task_trigger
+  BEFORE INSERT
+  ON core_task
+  FOR EACH ROW
+  EXECUTE FUNCTION on_insert_timestamp_task()
+;
+
+CREATE TRIGGER on_update_timestamp_task_trigger
+  BEFORE UPDATE
+  ON core_task
+  FOR EACH ROW
+  WHEN (OLD.pulp_created <> NEW.pulp_created)
+  EXECUTE FUNCTION on_update_timestamp_task()
+;
+"""
+
+TASK_INSERT_TRIGGER_DOWN = """
+DROP TRIGGER on_update_timestamp_task_trigger on core_task;
+DROP TRIGGER on_insert_timestamp_task_trigger on core_task;
+DROP FUNCTION on_update_timestamp_task;
+DROP FUNCTION on_insert_timestamp_task;
+"""
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0133_repositoryversion_content_ids"),
+    ]
+
+    operations = [
+        RequireVersion("core", "3.82.1"),
+        migrations.RunSQL(sql=TASK_INSERT_TRIGGER_UP, reverse_sql=TASK_INSERT_TRIGGER_DOWN),
+    ]

pulpcore/app/migrations/0135_task_pulp_task_resources_index.py

@@ -0,0 +1,25 @@
+# Generated by Django 4.2.22 on 2025-07-07 11:07
+
+import django.contrib.postgres.indexes
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0134_task_insert_trigger"),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name="task",
+            index=django.contrib.postgres.indexes.GinIndex(
+                condition=models.Q(
+                    ("state__in", ["completed", "failed", "canceled", "skipped"]), _negated=True
+                ),
+                fields=["reserved_resources_record"],
+                name="pulp_task_resources_index",
+                opclasses=["array_ops"],
+            ),
+        ),
+    ]

pulp_file/app/migrations/0006_delete_filefilesystemexporter.py → pulpcore/app/migrations/0136_delete_basedistribution.py

@@ -1,4 +1,4 @@
-# Generated by Django 2.2.6 on 2020-03-13 16:18
+# Generated by Django 4.2.16 on 2024-12-05 12:37
 
 from django.db import migrations
 
@@ -6,11 +6,11 @@ from django.db import migrations
 class Migration(migrations.Migration):
 
     dependencies = [
-        ('file', '0005_filerepository'),
+        ("core", "0135_task_pulp_task_resources_index"),
     ]
 
     operations = [
         migrations.DeleteModel(
-            name='FileFileSystemExporter',
+            name="BaseDistribution",
         ),
     ]

pulpcore/app/migrations/0137_appstatus.py

@@ -0,0 +1,33 @@
+# Generated by Django 4.2.23 on 2025-08-07 08:46
+
+import django.contrib.postgres.fields.hstore
+from django.db import migrations, models
+import django_lifecycle.mixins
+import pulpcore.app.models.base
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0136_delete_basedistribution'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AppStatus',
+            fields=[
+                ('pulp_id', models.UUIDField(default=pulpcore.app.models.base.pulp_uuid, editable=False, primary_key=True, serialize=False)),
+                ('pulp_created', models.DateTimeField(auto_now_add=True)),
+                ('pulp_last_updated', models.DateTimeField(auto_now=True, null=True)),
+                ('app_type', models.CharField(choices=[('api', 'api'), ('content', 'content'), ('worker', 'worker')], max_length=10)),
+                ('name', models.TextField(db_index=True, unique=True)),
+                ('versions', django.contrib.postgres.fields.hstore.HStoreField(default=dict)),
+                ('ttl', models.DurationField()),
+                ('last_heartbeat', models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                'abstract': False,
+            },
+            bases=(django_lifecycle.mixins.LifecycleModelMixin, models.Model),
+        ),
+    ]