postgresql-charms-single-kernel 16.1.4__py3-none-any.whl → 16.1.6__py3-none-any.whl

{postgresql_charms_single_kernel-16.1.4.dist-info → postgresql_charms_single_kernel-16.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: postgresql-charms-single-kernel
-Version: 16.1.4
+Version: 16.1.6
 Summary: Shared and reusable code for PostgreSQL-related charms
 Author: Canonical Data Platform
 Author-email: Canonical Data Platform <data-platform@lists.launchpad.net>

{postgresql_charms_single_kernel-16.1.4.dist-info → postgresql_charms_single_kernel-16.1.6.dist-info}/RECORD

@@ -4,8 +4,8 @@ single_kernel_postgresql/charmcraft.yaml,sha256=TbqNxQtjeAB-xPLpZXOnolxEnP75Rmgb
 single_kernel_postgresql/config/__init__.py,sha256=k9Ud5ZZNd3l0nn8xi8AIlT45oZk8hJ542BjAFGDJzuc,140
 single_kernel_postgresql/config/literals.py,sha256=88r33TBX7SXqgpV6EEXtZmSJrfOtsFiVJ_omop0RuBo,643
 single_kernel_postgresql/utils/__init__.py,sha256=VwAEW3wYjs99q38bid47aS6Os4s3catK4H5HfdPkp94,121
-single_kernel_postgresql/utils/filesystem.py,sha256=CJ2iXqFPKM0NfqqZSTDlENOrM0RW7rmTmcuzwV0bR9A,552
-single_kernel_postgresql/utils/postgresql.py,sha256=KMA9QYCuRXTsge5Wgj4H7p5Vd0XKLY0QsZGueF0MqCA,81209
-postgresql_charms_single_kernel-16.1.4.dist-info/WHEEL,sha256=ePp19eyRASTHUPCpRsqjeFjsybXoCLYnd2O6QHdRRAY,79
-postgresql_charms_single_kernel-16.1.4.dist-info/METADATA,sha256=00Edrj_dZxlZ-9G9O5zGM77psTx6dQkp4WN8qjOwxcM,13662
-postgresql_charms_single_kernel-16.1.4.dist-info/RECORD,,
+single_kernel_postgresql/utils/filesystem.py,sha256=7sMR64DavtuIKlwf8p5UWG5l1x0B3NgCSV8Yg52mpb4,1832
+single_kernel_postgresql/utils/postgresql.py,sha256=ZhyBU47F2idaLCzOY41ypgkUKeBoXv_-hd1tWLhPnTw,83440
+postgresql_charms_single_kernel-16.1.6.dist-info/WHEEL,sha256=RRVLqVugUmFOqBedBFAmA4bsgFcROUBiSUKlERi0Hcg,79
+postgresql_charms_single_kernel-16.1.6.dist-info/METADATA,sha256=c0HwkwL4DEnZDNqiCDIryxrhhL0z17tu7gB_d9aeWYw,13662
+postgresql_charms_single_kernel-16.1.6.dist-info/RECORD,,

{postgresql_charms_single_kernel-16.1.4.dist-info → postgresql_charms_single_kernel-16.1.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.14
+Generator: uv 0.9.21
 Root-Is-Purelib: true
 Tag: py3-none-any

single_kernel_postgresql/utils/filesystem.py

@@ -18,3 +18,45 @@ def change_owner(path: str) -> None:
     user_database = pwd.getpwnam(SNAP_USER)
     # Set the correct ownership for the file or directory.
     os.chown(path, uid=user_database.pw_uid, gid=user_database.pw_gid)
+
+
+def is_tmpfs(path: str) -> bool:
+    """Check if a path is on a tmpfs filesystem.
+
+    This function reads /proc/mounts to determine the filesystem type of the
+    mount point containing the given path.
+
+    Args:
+        path: Path to check.
+
+    Returns:
+        True if the path is on a tmpfs filesystem, False otherwise.
+        Returns False if /proc/mounts cannot be read (e.g., not on Linux).
+    """
+    try:
+        with open("/proc/mounts") as f:
+            mounts = f.readlines()
+    except (FileNotFoundError, PermissionError):
+        # Not on Linux or /proc not available, assume persistent storage
+        return False
+
+    # Get absolute path to handle relative paths and symlinks
+    abs_path = os.path.abspath(path)
+
+    # Find the longest matching mount point (most specific)
+    best_match_fs = None
+    best_match_len = 0
+
+    for line in mounts:
+        parts = line.split()
+        if len(parts) < 3:
+            continue
+        mount_point = parts[1]
+        fs_type = parts[2]
+
+        # Check if path is under this mount point and is more specific
+        if abs_path.startswith(mount_point) and len(mount_point) > best_match_len:
+            best_match_fs = fs_type
+            best_match_len = len(mount_point)
+
+    return best_match_fs == "tmpfs"

single_kernel_postgresql/utils/postgresql.py

@@ -37,7 +37,7 @@ from ..config.literals import (
     SYSTEM_USERS,
     Substrates,
 )
-from .filesystem import change_owner
+from .filesystem import change_owner, is_tmpfs
 
 # Groups to distinguish HBA access
 ACCESS_GROUP_IDENTITY = "identity_access"
@@ -644,6 +644,7 @@ class PostgreSQL:
                 with self._connect_to_database(
                     database
                 ) as connection, connection.cursor() as cursor:
+                    cursor.execute(SQL("RESET ROLE;"))
                     cursor.execute(
                         SQL("REASSIGN OWNED BY {} TO {};").format(
                             Identifier(user), Identifier(self.user)
@@ -653,6 +654,7 @@ class PostgreSQL:
 
             # Delete the user.
             with self._connect_to_database() as connection, connection.cursor() as cursor:
+                cursor.execute(SQL("RESET ROLE;"))
                 cursor.execute(SQL("DROP ROLE {};").format(Identifier(user)))
         except psycopg2.Error as e:
             logger.error(f"Failed to delete user: {e}")
@@ -1107,8 +1109,64 @@ class PostgreSQL:
                 connection.close()
         return databases
 
+    def _handle_temp_tablespace_on_reboot(
+        self, cursor, temp_location: str, temp_tablespace_exists: bool
+    ) -> None:
+        """Handle temp tablespace when permissions need fixing after reboot.
+
+        Args:
+            cursor: Database cursor.
+            temp_location: Path to the temp tablespace location.
+            temp_tablespace_exists: Whether the temp tablespace already exists.
+        """
+        if not temp_tablespace_exists:
+            return
+
+        # Different handling based on storage type
+        if is_tmpfs(temp_location):
+            # tmpfs: Directory is empty after reboot, safe to rename and recreate
+            # Rename existing temp tablespace instead of dropping it.
+            # Timestamp collision is not possible: the charm ensures this code runs leader-only,
+            # and it executes within a single database transaction holding exclusive locks.
+            new_name = f"temp_{datetime.now(timezone.utc).strftime('%Y%m%d%H%M%S')}"
+            cursor.execute(f"ALTER TABLESPACE temp RENAME TO {new_name};")
+
+            # List temp tablespaces with suffix for operator follow-up cleanup
+            cursor.execute("SELECT spcname FROM pg_tablespace WHERE spcname LIKE 'temp_%';")
+            temp_tbls = sorted([row[0] for row in cursor.fetchall()])
+            logger.info(
+                "There are %d temp tablespaces that should be checked and removed: %s",
+                len(temp_tbls),
+                ", ".join(temp_tbls),
+            )
+        else:
+            # Persistent storage: Tablespace is still valid, permissions already fixed
+            # Log that we fixed permissions but didn't recreate
+            logger.info(
+                "Fixed permissions on temp tablespace directory at %s (persistent storage), "
+                "existing tablespace remains valid",
+                temp_location,
+            )
+
     def set_up_database(self, temp_location: Optional[str] = None) -> None:
-        """Set up postgres database with the right permissions."""
+        """Set up postgres database with the right permissions.
+
+        This method configures the postgres database with appropriate permissions and
+        optionally creates a temporary tablespace.
+
+        Args:
+            temp_location: Optional path for the temp tablespace. If provided, the method
+                will ensure proper permissions and create the tablespace if it doesn't exist.
+
+        Behavior on reboot:
+            - For tmpfs storage: If permissions are incorrect after reboot, renames the old
+              tablespace and creates a new one (tmpfs directory is empty after reboot).
+            - For persistent storage: If permissions are incorrect after reboot, fixes
+              permissions but keeps the existing tablespace (directory contents persist).
+
+        Raises:
+            PostgreSQLDatabasesSetupError: If database setup fails.
+        """
         connection = None
         cursor = None
         try:
@@ -1116,30 +1174,23 @@ class PostgreSQL:
             cursor = connection.cursor()
 
             if temp_location is not None:
-                # Fix permissions on the temporary tablespace location when a reboot happens and tmpfs is being used.
+                # Fix permissions on the temporary tablespace location when a reboot happens.
                 temp_location_stats = os.stat(temp_location)
-                if self.substrate == Substrates.VM and (
+                permissions_need_fix = self.substrate == Substrates.VM and (
                     pwd.getpwuid(temp_location_stats.st_uid).pw_name != SNAP_USER
                     or int(temp_location_stats.st_mode & 0o777) != POSTGRESQL_STORAGE_PERMISSIONS
-                ):
+                )
+
+                if permissions_need_fix:
                     change_owner(temp_location)
                     os.chmod(temp_location, POSTGRESQL_STORAGE_PERMISSIONS)
-                    # Rename existing temp tablespace if it exists, instead of dropping it.
-                    cursor.execute("SELECT TRUE FROM pg_tablespace WHERE spcname='temp';")
-                    if cursor.fetchone() is not None:
-                        new_name = f"temp_{datetime.now(timezone.utc).strftime('%Y%m%d%H%M%S')}"
-                        cursor.execute(f"ALTER TABLESPACE temp RENAME TO {new_name};")
 
-                        # List temp tablespaces with suffix for operator follow-up cleanup and log them.
-                        cursor.execute(
-                            "SELECT spcname FROM pg_tablespace WHERE spcname LIKE 'temp_%';"
-                        )
-                        temp_tbls = sorted([row[0] for row in cursor.fetchall()])
-                        logger.info(
-                            "There are %d temp tablespaces that should be checked and removed: %s",
-                            len(temp_tbls),
-                            ", ".join(temp_tbls),
-                        )
+                    # Check if temp tablespace exists and handle it appropriately
+                    cursor.execute("SELECT TRUE FROM pg_tablespace WHERE spcname='temp';")
+                    temp_tablespace_exists = cursor.fetchone() is not None
+                    self._handle_temp_tablespace_on_reboot(
+                        cursor, temp_location, temp_tablespace_exists
+                    )
 
                 # Ensure a fresh temp tablespace exists at the expected location.
                 cursor.execute("SELECT TRUE FROM pg_tablespace WHERE spcname='temp';")