writes version to db, wait for migration

Author: FelixKirschKern

start.py

@@ -6,8 +6,13 @@
     create_jwks_secret_if_not_existing,
     check_and_pull_exec_env_images,
     wait_until_refinery_is_ready,
+    wait_until_postgres_migration_is_exited,
+)
+from util.postgres_helper import (
+    create_database_dump,
+    update_db_versions,
+    wait_until_postgres_is_ready,
 )
-from util.postgres_helper import create_database_dump, wait_until_postgres_is_ready
 from util.template_processor import process_docker_compose_template
 from util.update_helper import (
     is_any_service_version_changed,
@@ -47,6 +52,8 @@
 print("Starting all containers...", flush=True)
 subprocess.call(["docker-compose", "-f", DOCKER_COMPOSE, "up", "-d"])
 
+wait_until_postgres_migration_is_exited()
+
 wait_until_db_and_updater_service_are_ready()
 if run_updates:
     print("Service versions have changed.", flush=True)
@@ -64,6 +71,9 @@
 else:
     print("Refinery is not ready!", flush=True)
 
+# write current versions to db
+update_db_versions()
+
 print("UI:           http://localhost:4455/app/")
 print(f"Minio:        {minio_endpoint}")
 print("MailHog:      http://localhost:4436/")

util/constants.py

@@ -10,5 +10,6 @@
 }
 JWKS_PATH = "/refinery/oathkeeper/jwks.json"
 PG_CONTAINER = "graphql-postgres"
+POSTGRES_MIGRATE_CONTAINER = "postgres-migrate"
 SERVICE_VERSIONS = "/refinery/versions.json"
 SETTINGS = "/refinery/settings.json"

util/docker_helper.py

@@ -5,7 +5,12 @@
 import time
 from typing import Any, Tuple
 
-from util.constants import EXEC_ENVS, SERVICE_VERSIONS, JWKS_PATH
+from util.constants import (
+    EXEC_ENVS,
+    SERVICE_VERSIONS,
+    JWKS_PATH,
+    POSTGRES_MIGRATE_CONTAINER,
+)
 
 client = docker.from_env()
 
@@ -80,7 +85,7 @@ def is_uvicorn_application_started(container_name: str) -> bool:
     try:
         container = client.containers.list(filters={"name": container_name})[0]
         return "Application startup complete." in container.logs().decode("utf-8")
-    except docker.errors.ImageNotFound:
+    except IndexError:
         return False
 
 
@@ -90,11 +95,27 @@ def is_ui_service_ready(container_name: str) -> bool:
         return "Configuration complete; ready for start up" in container.logs().decode(
             "utf-8"
         )
-    except docker.errors.ImageNotFound:
+    except IndexError:
         return False
 
 
-def wait_until_refinery_is_ready(timeout: int = 60) -> None:
+def wait_until_postgres_migration_is_exited(timeout: int = 600) -> bool:
+    start_time = time.time()
+
+    while start_time + timeout > time.time():
+        try:
+            container = client.containers.list(
+                filters={"name": POSTGRES_MIGRATE_CONTAINER}
+            )[0]
+            if container.status == "exited":
+                return True
+        except Exception:
+            return False
+        time.sleep(1)
+    return False
+
+
+def wait_until_refinery_is_ready(timeout: int = 60) -> bool:
     start_time = time.time()
 
     while start_time + timeout > time.time():

util/postgres_helper.py

@@ -1,11 +1,14 @@
+import json
 import os
 import time
 from datetime import datetime
-from util.constants import BACKUP_DIR, CONNECTION_STRING, PG_CONTAINER
+from typing import Dict
+from zipfile import ZipFile
+from util.constants import BACKUP_DIR, CONNECTION_STRING, PG_CONTAINER, SERVICE_VERSIONS
 from util.docker_helper import exec_command_on_container
 
 
-def create_database_dump():
+def create_database_dump() -> bool:
     exit_code, result = exec_command_on_container(
         PG_CONTAINER, f"pg_dump -d {CONNECTION_STRING}"
     )
@@ -14,22 +17,23 @@ def create_database_dump():
 
     now = datetime.now()
     timestamp = now.strftime("%m_%d_%Y_%H_%M_%S")
-    backup_path = os.path.join(BACKUP_DIR, f"db_dump_{timestamp}.sql")
+    backup_zip = os.path.join(BACKUP_DIR, f"db_dump_{timestamp}.zip")
+    backup_fname = os.path.join(BACKUP_DIR, f"db_dump_{timestamp}.sql")
 
     if not os.path.exists(BACKUP_DIR):
         os.makedirs(BACKUP_DIR)
 
-    with open(backup_path, "wb") as f:
-        f.write(result)
+    with ZipFile(backup_zip, "w") as zf:
+        zf.writestr(backup_fname, result)
 
     return True
 
 
-def get_psql_command(sql: str):
+def get_psql_command(sql: str) -> str:
     return f'psql -d {CONNECTION_STRING} -c "{sql}" -qtAX'
 
 
-def wait_until_postgres_is_ready(timeout: int = 300):
+def wait_until_postgres_is_ready(timeout: int = 300) -> bool:
     start_time = time.time()
 
     while start_time + timeout > time.time():
@@ -40,7 +44,7 @@ def wait_until_postgres_is_ready(timeout: int = 300):
     return False
 
 
-def get_db_versions():
+def get_db_versions() -> Dict[str, str]:
     exit_code, result = exec_command_on_container(
         PG_CONTAINER,
         get_psql_command("SELECT service, installed_version FROM app_version"),
@@ -52,3 +56,47 @@ def get_db_versions():
             service, installed_version = line.split("|")
             versions[service] = installed_version
     return versions
+
+
+def update_db_versions() -> bool:
+
+    with open(SERVICE_VERSIONS, "r") as f:
+        current_versions = json.load(f)
+    db_versions = get_db_versions()
+
+    # update existing service versions
+    sql_commands = []
+    for service, db_version in db_versions.items():
+        current_version = current_versions[service].lstrip("v")
+        if current_version != db_version:
+            sql_commands.append(
+                f"""
+                UPDATE app_version
+                SET installed_version = '{current_version}'
+                WHERE service = '{service}';
+                """
+            )
+    if sql_commands:
+        exit_code, _ = exec_command_on_container(
+            PG_CONTAINER,
+            get_psql_command("\n".join(sql_commands)),
+        )
+        if exit_code != 0:
+            return False
+
+    # add new service versions
+    for service, version in current_versions.items():
+        if service not in db_versions:
+            sql_commands.append(
+                f"""
+                INSERT INTO app_version (service, installed_version)
+                VALUES ('{service}', '{version.lstrip("v")}');
+                """
+            )
+    if sql_commands:
+        exit_code, _ = exec_command_on_container(
+            PG_CONTAINER, get_psql_command("\n".join(sql_commands))
+        )
+        if exit_code != 0:
+            return False
+    return True

util/update_helper.py

@@ -14,8 +14,7 @@ def is_any_service_version_changed() -> bool:
 
     any_service_updated = False
     for service, version in db_versions.items():
-        if is_newer(version, current_versions[service].lstrip("v")):
-            print(service, flush=True)
+        if is_newer(current_versions[service].lstrip("v"), version):
             any_service_updated = True
             break
     return any_service_updated
@@ -40,6 +39,11 @@ def __is_newer_int(v1: List[int], v2: List[int]) -> bool:
 
 
 def updater_service_update_to_newest():
+    # the updater service is part of the docker-compose stack and therefore located
+    # in a differrent network than alfred. Therefore, the updater service can not
+    # be reached via the alfred network. Therefore, we need to use the docker
+    # exec command to update the updater service.
+    # The following command executes the update_to_current command on the updater service.
     exit_code, output = exec_command_on_container(
         "refinery-updater", "python -c 'import app; app.update_to_newest()'"
     )