dump_instance.sh and load_instance.sh scripts

Issue #65 - Prepare regression test covering database backup/restore

Issue #4 use database backup to restore HAF

The scripts save or load the haf database along with the hived state.

OPTIONS:
  --backup-dir=DIR                 Allows to specify where the dumps are located, required
  --hived-executable-path=PATH     Allows to specify where the main executable is located, required
  --hived-data-dir=DIR             Allows to specify where node data is located, required
  --haf-db-name=NAME               Allows to specify a name of database to store HAF data, required
  --haf-db-admin=NAME              Allows to specify a name of database admin role having permission to create the database
  --haf-db-host=VALUE              Allows to specify a PostgreSQL host location
  --haf-db-port=NUMBER             Allows to specify a PostgreSQL operating port
  --haf-db-jobs=NUMBER             Allows to specify how many processes are run during dump/restore
  --override-existing-backup-dir   Erases backup directory and its contents
  --help                           Display this help screen and exit

A note using Docker: hivemind SELECT * on hivemind_app view issues an error "could not resize shared memory segment" . Fixed by adding --shm-size=2gb to the docker run command.

tests/integration/system/haf/test_pg_dump.py

-import os
+from __future__ import annotations
+
 import subprocess
-import sqlalchemy
-from sqlalchemy.pool import NullPool
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy.ext.automap import automap_base
+from typing import TYPE_CHECKING, List
 
-import test_tools as tt
 
+import test_tools as tt
 from local_tools import make_fork, wait_for_irreversible_progress, run_networks, create_node_with_database, get_blocklog_directory
 
+if TYPE_CHECKING:
+    from sqlalchemy.orm.session import Session
+    from sqlalchemy.engine.row import Row
+
 
 # MTTK TODO once the errrors disappear we could use single pg_restore command
 ERRORS_IN_CREATE_POLICY = True
@@ -44,7 +46,7 @@ def prepare_source_db(database):
     return source_session, source_db_name
 
 
-def create_psql_tool_dumped_schema(session):
+def create_psql_tool_dumped_schema(session: Session) -> str:
     databasename = session.bind.url.database
     schema_filename = databasename + '_schema.txt'
 
@@ -53,25 +55,11 @@ def create_psql_tool_dumped_schema(session):
 
     return open(schema_filename).read()
 
-def pg_dump(db_name):
+def pg_dump(db_name : str) -> None:
     shell(f'pg_dump -Fc -d {db_name} -f adump.Fcsql')
 
 
-
-
-def wipe_db(db_name):
-    shell(f"""psql -U dev -d postgres \
-        -c \
-        "SELECT pg_terminate_backend(pg_stat_activity.pid) 
-        FROM pg_stat_activity 
-        WHERE pg_stat_activity.datname = '{db_name}' 
-            AND pid <> pg_backend_pid();"
-    """)
-    shell(f"psql -d postgres -c 'DROP DATABASE IF EXISTS {db_name};'")
-    shell(f"psql -d postgres -c 'CREATE DATABASE {db_name};'")
-
-
-def pg_restore(target_db_name):
+def pg_restore(target_db_name: str) -> None:
     """ For debugging purposes it is sometimes valuable to display dump contents like this:
     pg_restore --section=pre-data  --disable-triggers  -Fc -f adump-pre-data.sql  adump.Fcsql
     """
@@ -87,7 +75,7 @@ def pg_restore(target_db_name):
         shell(f"pg_restore --single-transaction  -Fc -d {target_db_name} adump.Fcsql")
 
 
-def compare_databases(source_session, target_session):
+def compare_databases(source_session: Session, target_session: Session) -> None:
     ask_for_tables_and_views_sql = f"SELECT table_name FROM information_schema.tables WHERE table_schema = 'hive' ORDER BY table_name"
     source_tables = execute_sql_col(source_session, ask_for_tables_and_views_sql)
     target_tables = execute_sql_col(target_session, ask_for_tables_and_views_sql)
@@ -100,20 +88,20 @@ def compare_databases(source_session, target_session):
         assert source_recordset == target_recordset, f"ERROR: in table_or_view: {table}"
 
         
-def take_table_contents(session, table):
+def take_table_contents(session: Session, table: str) -> list[Row]:
     recordset = execute_sql_row(session, f"SELECT column_name FROM information_schema.columns  WHERE table_schema = 'hive' AND table_name   = '{table}';")
     columns = ', '.join([e[0] for e in (recordset)])
     return execute_sql_row(session, f"SELECT * FROM hive.{table} ORDER BY {columns}")
 
 
-def compare_psql_tool_dumped_schemas(source_session, target_session):
+def compare_psql_tool_dumped_schemas(source_session: Session, target_session: Session) -> None:
     source_schema = create_psql_tool_dumped_schema(source_session)
     target_schema = create_psql_tool_dumped_schema(target_session)
 
     assert source_schema == target_schema
 
     
-def create_psql_tool_dumped_schema(session):
+def create_psql_tool_dumped_schema(session: Session) -> str:
     databasename = session.bind.url.database
     schema_filename = databasename + '_schema.txt'
 
@@ -123,14 +111,13 @@ def create_psql_tool_dumped_schema(session):
     return open(schema_filename).read()
 
 
-def shell(command):
+def shell(command: str):
     subprocess.call(command, shell=True)
 
-
-def execute_sql_col(session, s):
+    
+def execute_sql_col(session: Session, s: str):
     return [e[0] for e in session.execute(s)]
 
 
-def execute_sql_row(session, s):
+def execute_sql_row(session: Session, s: str):
     return [e for e in session.execute(s)]
-