Better handling of extension versions

plugins/modules/postgresql_ext.py

@@ -72,9 +72,9 @@
     description:
       - Extension version to add or update to. Has effect with I(state=present) only.
       - If not specified, the latest extension version will be created.
-      - It can't downgrade an extension version.
-        When version downgrade is needed, remove the extension and create new one with appropriate version.
-      - Set I(version=latest) to update the extension to the latest available version.
+      - Version downgrade is only supported if extension provides a downgrade path.
+        Otherwise extension must be removed and lower version of extension must be made available.
+      - Set I(version=latest) to always update the extension to the latest available version.
     type: str
   trust_input:
     description:
@@ -114,6 +114,7 @@
 - Thomas O'Donnell (@andytom)
 - Sandro Santilli (@strk)
 - Andrew Klychkov (@Andersson007)
+- Keith Fiske (@keithf4)
 extends_documentation_fragment:
 - community.postgresql.postgres
 
@@ -147,13 +148,13 @@
     cascade: yes
     state: absent
 
-- name: Create extension foo of version 1.2 or update it if it's already created
+- name: Create extension foo of version 1.2 or update it to that version if it's already created and a valid update path exists
   community.postgresql.postgresql_ext:
     db: acme
     name: foo
     version: 1.2
 
-- name: Assuming extension foo is created, update it to the latest version
+- name: Create latest available version of extension foo. If already installed, update it to the latest version
   community.postgresql.postgresql_ext:
     db: acme
     name: foo
@@ -171,8 +172,6 @@
 
 import traceback
 
-from distutils.version import LooseVersion
-
 try:
     from psycopg2.extras import DictCursor
 except ImportError:
@@ -198,14 +197,9 @@
 # PostgreSQL module specific support methods.
 #
 
-def ext_exists(cursor, ext):
-    query = "SELECT * FROM pg_extension WHERE extname=%(ext)s"
-    cursor.execute(query, {'ext': ext})
-    return cursor.rowcount == 1
-
 
-def ext_delete(cursor, ext, cascade):
-    if ext_exists(cursor, ext):
+def ext_delete(cursor, ext, curr_version, cascade):
+    if curr_version:
         query = "DROP EXTENSION \"%s\"" % ext
         if cascade:
             query += " CASCADE"
@@ -245,7 +239,7 @@ def ext_create(cursor, ext, schema, cascade, version):
 
     if schema:
         query += " WITH SCHEMA \"%s\"" % schema
-    if version:
+    if version != 'latest':
         query += " VERSION %(ver)s"
         params['ver'] = version
     if cascade:
@@ -272,60 +266,59 @@ def ext_get_versions(cursor, ext):
       ext (str) -- extension name
     """
 
+    current_version = None
+    params = {}
+    params['ext'] = ext
+
     # 1. Get the current extension version:
     query = ("SELECT extversion FROM pg_catalog.pg_extension "
              "WHERE extname = %(ext)s")
 
-    current_version = None
-    cursor.execute(query, {'ext': ext})
+    cursor.execute(query, params)
+
     res = cursor.fetchone()
     if res:
         current_version = res[0]
 
     # 2. Get available versions:
     query = ("SELECT version FROM pg_available_extension_versions "
              "WHERE name = %(ext)s")
-    cursor.execute(query, {'ext': ext})
-    res = cursor.fetchall()
 
-    available_versions = parse_ext_versions(current_version, res)
+    cursor.execute(query, params)
+
+    available_versions = [r[0] for r in cursor.fetchall()]
 
     if current_version is None:
         current_version = False
 
     return (current_version, available_versions)
 
 
-def parse_ext_versions(current_version, ext_ver_list):
-    """Parse ext versions.
-
-    Args:
-      current_version (str) -- version to compare elements of ext_ver_list with
-      ext_ver_list (list) -- list containing dicts with versions
-
-    Return a sorted list with versions that are higher than current_version.
-
-    Note: Incomparable versions (e.g., postgis version "unpackaged") are skipped.
+def ext_valid_update_path(cursor, ext, current_version, version):
+    """
+        Value of 'latest' is always a valid path.
     """
-    available_versions = []
 
-    for line in ext_ver_list:
-        if line['version'] == 'unpackaged':
-            continue
+    valid_path = False
+    params = {}
+    if version != 'latest':
+        query = ("SELECT path FROM pg_extension_update_paths(%(ext)s)"
+                  "WHERE source = %(cv)s"
+                  "AND target = %(ver)s")
 
-        try:
-            if current_version is None:
-                if LooseVersion(line['version']) >= LooseVersion('0'):
-                    available_versions.append(line['version'])
-            else:
-                if LooseVersion(line['version']) > LooseVersion(current_version):
-                    available_versions.append(line['version'])
-        except Exception:
-            # When a version cannot be compared, skip it
-            # (there's a note in the documentation)
-            continue
+        params['ext'] = ext
+        params['cv'] = current_version
+        params['ver'] = version
+
+        cursor.execute(query, params)
+        res = cursor.fetchone()
+        if res != None:
+            valid_path = True
+    else:
+        valid_path = True
+
+    return (valid_path)
 
-    return sorted(available_versions, key=LooseVersion)
 
 # ===========================================
 # Module execution.
@@ -374,65 +367,67 @@ def main():
         curr_version, available_versions = ext_get_versions(cursor, ext)
 
         if state == "present":
-            if version == 'latest':
-                if available_versions:
-                    version = available_versions[-1]
-                else:
-                    version = ''
 
+            # If version passed
             if version:
-                # If the specific version is passed and it is not available for update:
-                if version not in available_versions:
-                    if not curr_version:
-                        module.fail_json(msg="Passed version '%s' is not available" % version)
-
-                    elif LooseVersion(curr_version) == LooseVersion(version):
+                # If extension is installed, update to passed version if a valid path exists
+                if curr_version:
+                    # Given version already installed
+                    if curr_version == version:
                         changed = False
-
                     else:
-                        module.fail_json(msg="Passed version '%s' is lower than "
-                                             "the current created version '%s' or "
-                                             "the passed version is not available" % (version, curr_version))
-
-                # If the specific version is passed and it is higher that the current version:
-                if curr_version:
-                    if LooseVersion(curr_version) < LooseVersion(version):
+                        valid_update_path = ext_valid_update_path(cursor, ext, curr_version, version)
+                        if valid_update_path:
+                            if module.check_mode:
+                                changed = True
+                            else:
+                                changed = ext_update_version(cursor, ext, version)
+                        else:
+                            module.fail_json(msg="Passed version '%s' has no valid update path from "
+                                                 "the currently installed version '%s' or "
+                                                 "the passed version is not available" % (version, curr_version))
+                else:
+                    # If not requesting latest version and passed version not available
+                    if version != 'latest' and version not in available_versions:
+                        module.fail_json(msg="Passed version '%s' is not available" % version)
+                    # Else install the passed version when available
+                    else:
                         if module.check_mode:
                             changed = True
                         else:
-                            changed = ext_update_version(cursor, ext, version)
-
-                    # If the specific version is passed and it is created now:
-                    if curr_version == version:
-                        changed = False
+                            changed = ext_create(cursor, ext, schema, cascade, 'latest')
 
-                # If the ext doesn't exist and installed:
-                elif not curr_version and available_versions:
+            # If version is not passed:
+            else:
+                # Extension exists, attempt to update to latest version defined in extension control file
+                # ALTER EXTENSION is actually run, so 'changed' is technically true even if nothing updated
+                if curr_version and version == 'latest':
                     if module.check_mode:
                         changed = True
                     else:
-                        changed = ext_create(cursor, ext, schema, cascade, version)
-
-            # If version is not passed:
-            else:
-                if not curr_version:
-                    # If the ext doesn't exist and it's installed:
+                        changed = ext_update_version(cursor, ext, version)
+                # Extension exists, no request to update so no change
+                elif curr_version:
+                      changed = False
+                else:
+                    # If the ext doesn't exist and is available:
                     if available_versions:
                         if module.check_mode:
                             changed = True
                         else:
-                            changed = ext_create(cursor, ext, schema, cascade, version)
+                            changed = ext_create(cursor, ext, schema, cascade, 'latest')
 
-                    # If the ext doesn't exist and not installed:
+                    # If the ext doesn't exist and is not available:
                     else:
-                        module.fail_json(msg="Extension %s is not installed" % ext)
+                        module.fail_json(msg="Extension %s is not available" % ext)
+
 
         elif state == "absent":
             if curr_version:
                 if module.check_mode:
                     changed = True
                 else:
-                    changed = ext_delete(cursor, ext, cascade)
+                    changed = ext_delete(cursor, ext, curr_version, cascade)
             else:
                 changed = False