[IMP] avoid directory changes in migration loop

Replace cd into version directories with absolute path execution:

Before:
  cd "${version}.0"
  ./pre_upgrade.sh
  ./upgrade.sh
  ./post_upgrade.sh
  cd ..

After:
  "${SCRIPT_DIR}/${version}.0/pre_upgrade.sh"
  "${SCRIPT_DIR}/${version}.0/upgrade.sh"
  "${SCRIPT_DIR}/${version}.0/post_upgrade.sh"

Benefits:
- No working directory state to track
- More robust: script works regardless of where it's called from
- Easier debugging: no need to remember current directory
- Avoids potential issues if a subscript changes directory

finalize_db.sh

@@ -4,42 +4,41 @@ set -euo pipefail
 DB_NAME="$1"
 ODOO_SERVICE="$2"
 
-FINALE_SQL=$(cat <<'EOF'
+echo "Running SQL cleanup..."
-/*Delete sequences that prevent Odoo to start*/
+CLEANUP_SQL=$(cat <<'EOF'
-drop sequence base_registry_signaling;
+-- Drop sequences that prevent Odoo from starting.
-drop sequence base_cache_signaling;
+-- These sequences are recreated by Odoo on startup but stale values
-EOF
+-- from the old version can cause conflicts.
-)
+DROP SEQUENCE IF EXISTS base_registry_signaling;
-query_postgres_container "$FINALE_SQL" "$DB_NAME" || exit 1
+DROP SEQUENCE IF EXISTS base_cache_signaling;
 
-# Fix duplicated views
+-- Reset website templates to their original state.
-PYTHON_SCRIPT=post_migration_fix_duplicated_views.py
+-- Views with arch_fs (file source) that have been customized (arch_db not null)
-echo "Remove duplicated views with script $PYTHON_SCRIPT ..."
+-- are reset to use the file version, EXCEPT for actual website pages which
-exec_python_script_in_odoo_shell "$DB_NAME" "$DB_NAME" "$PYTHON_SCRIPT" || exit 1
+-- contain user content that must be preserved.
-
-# Reset all website templates with custom content
-FINALE_SQL_2=$(cat <<'EOF'
 UPDATE ir_ui_view
 SET arch_db = NULL
 WHERE arch_fs IS NOT NULL
   AND arch_fs LIKE 'website/%'
   AND arch_db IS NOT NULL
   AND id NOT IN (SELECT view_id FROM website_page);
-EOF
-)
-query_postgres_container "$FINALE_SQL_2" "$DB_NAME" || exit 1
 
-# Purge QWeb cache from compiled assets
+-- Purge compiled frontend assets (CSS/JS bundles).
-FINALE_SQL_3=$(cat <<'EOF'
+-- These cached files reference old asset versions and must be regenerated
+-- by Odoo after migration to avoid broken stylesheets and scripts.
 DELETE FROM ir_attachment
 WHERE name LIKE '/web/assets/%'
    OR name LIKE '%.assets_%'
    OR (res_model = 'ir.ui.view' AND mimetype = 'text/css');
 EOF
 )
-query_postgres_container "$FINALE_SQL_3" "$DB_NAME" || exit 1
+query_postgres_container "$CLEANUP_SQL" "$DB_NAME"
 
-# Uninstall obsolette add-ons
+PYTHON_SCRIPT=post_migration_fix_duplicated_views.py
+echo "Remove duplicated views with script $PYTHON_SCRIPT ..."
+exec_python_script_in_odoo_shell "$DB_NAME" "$DB_NAME" "$PYTHON_SCRIPT"
+
+# Uninstall obsolete add-ons
 PYTHON_SCRIPT=post_migration_cleanup_obsolete_modules.py
 echo "Uninstall obsolete add-ons with script $PYTHON_SCRIPT ..."
 exec_python_script_in_odoo_shell "$DB_NAME" "$DB_NAME" "$PYTHON_SCRIPT" || exit 1

lib/common.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+#
+# Common functions for Odoo migration scripts
+# Source this file from other scripts: source "$(dirname "$0")/lib/common.sh"
+#
+
+set -euo pipefail
+
+readonly DATASTORE_PATH="/srv/datastore/data"
+readonly FILESTORE_SUBPATH="var/lib/odoo/filestore"
+
+check_required_commands() {
+    local missing=()
+    for cmd in docker compose sudo rsync; do
+        if ! command -v "$cmd" &>/dev/null; then
+            missing+=("$cmd")
+        fi
+    done
+    if [[ ${#missing[@]} -gt 0 ]]; then
+        log_error "Required commands not found: ${missing[*]}"
+        log_error "Please install them before running this script."
+        exit 1
+    fi
+}
+
+log_info()  { printf "[INFO]  %s\n" "$*"; }
+log_warn()  { printf "[WARN]  %s\n" "$*" >&2; }
+log_error() { printf "[ERROR] %s\n" "$*" >&2; }
+log_step()  { printf "\n===== %s =====\n" "$*"; }
+
+confirm_or_exit() {
+    local message="$1"
+    local choice
+    echo ""
+    echo "$message"
+    echo "Y - Yes, continue"
+    echo "N - No, cancel"
+    read -r -n 1 -p "Your choice: " choice
+    echo ""
+    case "$choice" in
+        [Yy]) return 0 ;;
+        *) log_error "Cancelled by user."; exit 1 ;;
+    esac
+}
+
+query_postgres_container() {
+    local query="$1"
+    local db_name="$2"
+
+    if [[ -z "$query" ]]; then
+        return 0
+    fi
+
+    local result
+    if ! result=$(docker exec -u 70 "$POSTGRES_SERVICE_NAME" psql -d "$db_name" -t -A -c "$query"); then
+        printf "Failed to execute SQL query: %s\n" "$query" >&2
+        printf "Error: %s\n" "$result" >&2
+        return 1
+    fi
+    echo "$result"
+}
+
+copy_database() {
+    local from_db="$1"
+    local to_service="$2"
+    local to_db="$3"
+
+    docker exec -u 70 "$POSTGRES_SERVICE_NAME" pgm cp -f "$from_db" "${to_db}@${to_service}"
+}
+
+copy_filestore() {
+    local from_service="$1"
+    local from_db="$2"
+    local to_service="$3"
+    local to_db="$4"
+
+    local src_path="${DATASTORE_PATH}/${from_service}/${FILESTORE_SUBPATH}/${from_db}"
+    local dst_path="${DATASTORE_PATH}/${to_service}/${FILESTORE_SUBPATH}/${to_db}"
+
+    sudo mkdir -p "$(dirname "$dst_path")"
+    sudo rsync -a --delete "${src_path}/" "${dst_path}/"
+    echo "Filestore ${from_service}/${from_db} copied to ${to_service}/${to_db}."
+}
+
+exec_python_script_in_odoo_shell() {
+    local service_name="$1"
+    local db_name="$2"
+    local python_script="$3"
+
+    compose --debug run "$service_name" shell -d "$db_name" --no-http --stop-after-init < "$python_script"
+}
+
+export DATASTORE_PATH FILESTORE_SUBPATH
+export -f log_info log_warn log_error log_step confirm_or_exit
+export -f check_required_commands
+export -f query_postgres_container copy_database copy_filestore exec_python_script_in_odoo_shell

prepare_db.sh

@@ -1,18 +1,20 @@
 #!/bin/bash
 set -euo pipefail
 
-# Global variables
 ODOO_SERVICE="$1"
 DB_NAME="$2"
 DB_FINALE_MODEL="$3"
 DB_FINALE_SERVICE="$4"
 
+TMPDIR=$(mktemp -d)
+trap 'rm -rf "$TMPDIR"' EXIT
+
 echo "Start database preparation"
 
 # Check POSTGRES container is running
-if ! docker ps | grep -q "$DB_CONTAINER_NAME"; then
+if ! docker ps | grep -q "$POSTGRES_SERVICE_NAME"; then
-    printf "Docker container %s is not running.\n" "$DB_CONTAINER_NAME" >&2
+    printf "Docker container %s is not running.\n" "$POSTGRES_SERVICE_NAME" >&2
-    return 1
+    exit 1
 fi
 
 EXT_EXISTS=$(query_postgres_container "SELECT 1 FROM pg_extension WHERE extname = 'dblink'" "$DB_NAME") || exit 1
@@ -40,71 +42,32 @@ echo "Base neutralized..."
 ## List add-ons not in final version ##
 #######################################
 
-# Retrieve add-ons not available on the final Odoo version
+SQL_MISSING_ADDONS=$(cat <<EOF
-SQL_404_ADDONS_LIST="
+SELECT module_origin.name
-	SELECT module_origin.name
+FROM ir_module_module module_origin
-	FROM ir_module_module module_origin
+LEFT JOIN (
-	LEFT   JOIN (
+    SELECT *
-	   SELECT *
+    FROM dblink('dbname=${FINALE_DB_NAME}','SELECT name, shortdesc, author FROM ir_module_module')
-	   FROM   dblink('dbname=$FINALE_DB_NAME','SELECT name, shortdesc, author FROM ir_module_module')
+    AS tb2(name text, shortdesc text, author text)
-	   AS     tb2(name text, shortdesc text, author text)
+) AS module_dest ON module_dest.name = module_origin.name
-	) AS module_dest ON module_dest.name = module_origin.name
+WHERE (module_dest.name IS NULL)
+  AND (module_origin.state = 'installed')
+  AND (module_origin.author NOT IN ('Odoo S.A.', 'Lokavaluto', 'Elabore'))
+ORDER BY module_origin.name;
+EOF
+)
+echo "Retrieve missing addons..."
+missing_addons=$(query_postgres_container "$SQL_MISSING_ADDONS" "$DB_NAME")
 
-	WHERE (module_dest.name IS NULL) AND (module_origin.state = 'installed') AND (module_origin.author NOT IN ('Odoo S.A.', 'Lokavaluto', 'Elabore'))
+log_step "ADD-ONS CHECK"
-	ORDER BY module_origin.name
+echo "Installed add-ons not available in final Odoo version:"
-;
+echo "$missing_addons"
-"
+confirm_or_exit "Do you accept to migrate with these add-ons still installed?"
-echo "Retrieve 404 addons... "
-echo "SQL REQUEST = $SQL_404_ADDONS_LIST"
-query_postgres_container "$SQL_404_ADDONS_LIST" "$DB_NAME" > 404_addons || exit 1
 
-# Keep only the installed add-ons
-INSTALLED_ADDONS="SELECT name FROM ir_module_module WHERE state='installed';"
-query_postgres_container "$INSTALLED_ADDONS" "$DB_NAME" > installed_addons || exit 1
-
-grep -Fx -f 404_addons installed_addons > final_404_addons
-rm -f 404_addons installed_addons
-
-# Ask confirmation to uninstall the selected add-ons
-echo "
-==== ADD-ONS CHECK ====
-Installed add-ons not available in final Odoo version:
-"
-cat final_404_addons
-
-
-echo "
-Do you accept to migrate the database with all these add-ons still installed? (Y/N/R)"
-echo "Y - Yes, let's go on with the upgrade."
-echo "N - No, stop the upgrade"
-read -n 1 -p "Your choice: " choice
-case "$choice" in
-    [Yy] ) echo "
-Let's go on!";;
-    [Nn] ) echo "
-Upgrade cancelled!"; exit 1;;
-    * ) echo "
-Please answer by Y or N.";;
-esac
-
-
-# Check the views
 PYTHON_SCRIPT=pre_migration_view_checking.py
 echo "Check views with script $PYTHON_SCRIPT ..."
-exec_python_script_in_odoo_shell "$DB_NAME" "$DB_NAME" "$PYTHON_SCRIPT" || exit 1
+exec_python_script_in_odoo_shell "$DB_NAME" "$DB_NAME" "$PYTHON_SCRIPT"
 
-echo "
+confirm_or_exit "Do you accept to migrate with the current views state?"
-Do you accept to migrate the database with the current views states? (Y/N/R)"
-echo "Y - Yes, let's go on with the upgrade."
-echo "N - No, stop the upgrade"
-read -n 1 -p "Your choice: " choice
-case "$choice" in
-    [Yy] ) echo "
-Upgrade confirmed!";;
-    [Nn] ) echo "
-Upgrade cancelled!"; exit 1;;
-    * ) echo "
-Please answer by Y or N.";;
-esac
 
 echo "Database successfully prepared!"

upgrade.sh

@@ -1,6 +1,9 @@
 #!/bin/bash
 set -euo pipefail
 
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/common.sh"
+
 ####################
 # USAGE & ARGUMENTS
 ####################
@@ -22,225 +25,115 @@ EOF
 }
 
 if [[ $# -lt 4 ]]; then
-    echo "ERROR: Missing arguments. Expected 4, got $#." >&2
+    log_error "Missing arguments. Expected 4, got $#."
     usage
 fi
 
-####################
+check_required_commands
-# GLOBAL VARIABLES #
-####################
 
-ORIGIN_VERSION="$1" # "12" for version 12.0
+readonly ORIGIN_VERSION="$1"
-FINAL_VERSION="$2" # "16" for version 16.0
+readonly FINAL_VERSION="$2"
-# Path to the database to migrate. Must be a .zip file with the following syntax: {DATABASE_NAME}.zip
+readonly ORIGIN_DB_NAME="$3"
-ORIGIN_DB_NAME="$3"
+readonly ORIGIN_SERVICE_NAME="$4"
-ORIGIN_SERVICE_NAME="$4"
 
-# Get origin database name
+readonly COPY_DB_NAME="ou${ORIGIN_VERSION}"
-COPY_DB_NAME="ou${ORIGIN_VERSION}"
-# Define finale database name
 export FINALE_DB_NAME="ou${FINAL_VERSION}"
-# Define finale odoo service name
+readonly FINALE_DB_NAME
-FINALE_SERVICE_NAME="${FINALE_DB_NAME}"
+readonly FINALE_SERVICE_NAME="${FINALE_DB_NAME}"
 
-# Service postgres name (dynamically retrieved from running containers)
+readarray -t postgres_containers < <(docker ps --format '{{.Names}}' | grep postgres || true)
-POSTGRES_CONTAINERS=$(docker ps --format '{{.Names}}' | grep postgres)
-POSTGRES_COUNT=$(echo "$POSTGRES_CONTAINERS" | grep -c .)
 
-if [[ "$POSTGRES_COUNT" -eq 0 ]]; then
+if [[ ${#postgres_containers[@]} -eq 0 ]]; then
-    echo "ERROR: No running PostgreSQL container found. Please start a PostgreSQL container and try again." >&2
+    log_error "No running PostgreSQL container found. Please start a PostgreSQL container and try again."
     exit 1
-elif [[ "$POSTGRES_COUNT" -gt 1 ]]; then
+elif [[ ${#postgres_containers[@]} -gt 1 ]]; then
-    echo "ERROR: Multiple PostgreSQL containers found:" >&2
+    log_error "Multiple PostgreSQL containers found:"
-    echo "$POSTGRES_CONTAINERS" >&2
+    printf '  %s\n' "${postgres_containers[@]}" >&2
-    echo "Please ensure only one PostgreSQL container is running." >&2
+    log_error "Please ensure only one PostgreSQL container is running."
     exit 1
 fi
 
-export POSTGRES_SERVICE_NAME="$POSTGRES_CONTAINERS"
+export POSTGRES_SERVICE_NAME="${postgres_containers[0]}"
+readonly POSTGRES_SERVICE_NAME
 
-#############################################
+log_step "INPUT PARAMETERS"
-# DISPLAYS ALL INPUTS PARAMETERS
+log_info "Origin version .......... $ORIGIN_VERSION"
-#############################################
+log_info "Final version ........... $FINAL_VERSION"
+log_info "Origin DB name ........... $ORIGIN_DB_NAME"
+log_info "Origin service name ..... $ORIGIN_SERVICE_NAME"
 
-echo "===== INPUT PARAMETERS ====="
+log_step "COMPUTED GLOBAL VARIABLES"
-echo "Origin version .......... $ORIGIN_VERSION"
+log_info "Copy DB name ............. $COPY_DB_NAME"
-echo "Final version ........... $FINAL_VERSION"
+log_info "Finale DB name ........... $FINALE_DB_NAME"
-echo "Origin DB name ........... $ORIGIN_DB_NAME"
+log_info "Finale service name ...... $FINALE_SERVICE_NAME"
-echo "Origin service name ..... $ORIGIN_SERVICE_NAME"
+log_info "Postgres service name .... $POSTGRES_SERVICE_NAME"
-
-echo "
-===== COMPUTED GLOBALE VARIABLES ====="
-echo "Copy DB name ............. $COPY_DB_NAME"
-echo "Finale DB name ........... $FINALE_DB_NAME"
-echo "Finale service name ...... $FINALE_SERVICE_NAME"
-echo "Postgres service name .... $POSTGRES_SERVICE_NAME"
 
 
 
-# Function to launch an SQL request to the postgres container
+log_step "CHECKS ALL NEEDED COMPONENTS ARE AVAILABLE"
-query_postgres_container(){
-    local QUERY="$1"
-    local DB_NAME="$2"
-    if [[ -z "$QUERY" ]]; then
-	return 0
-    fi
-    local result
-    if ! result=$(docker exec -u 70 "$POSTGRES_SERVICE_NAME" psql -d "$DB_NAME" -t -A -c "$QUERY"); then
-        printf "Failed to execute SQL query: %s\n" "$query" >&2
-        printf "Error: %s\n" "$result" >&2
-        exit 1
-    fi
-    echo "$result"
-}
-export -f query_postgres_container
 
-# Function to copy the postgres databases
+db_exists=$(docker exec -it -u 70 "$POSTGRES_SERVICE_NAME" psql -tc "SELECT 1 FROM pg_database WHERE datname = '$ORIGIN_DB_NAME'" | tr -d '[:space:]')
-copy_database(){
+if [[ "$db_exists" ]]; then
-    local FROM_DB="$1"
+    log_info "Database '$ORIGIN_DB_NAME' found."
-    local TO_SERVICE="$2"
-    local TO_DB="$3"
-    docker exec -u 70 "$POSTGRES_SERVICE_NAME" pgm cp -f "$FROM_DB" "$TO_DB"@"$TO_SERVICE"
-}
-export -f copy_database
-
-# Function to copy the filetores
-copy_filestore(){
-    local FROM_SERVICE="$1"
-    local FROM_DB="$2"
-    local TO_SERVICE="$3"
-    local TO_DB="$4"
-    sudo mkdir -p /srv/datastore/data/"$TO_SERVICE"/var/lib/odoo/filestore/"$TO_DB" || exit 1
-    sudo rm -rf /srv/datastore/data/"$TO_SERVICE"/var/lib/odoo/filestore/"$TO_DB" || exit 1
-    sudo cp -a /srv/datastore/data/"$FROM_SERVICE"/var/lib/odoo/filestore/"$FROM_DB" /srv/datastore/data/"$TO_SERVICE"/var/lib/odoo/filestore/"$TO_DB" || exit 1
-    echo "Filestore $FROM_SERVICE/$FROM_DB copied."
-}
-export -f copy_filestore
-
-# Function to launch python scripts in Odoo Shell
-exec_python_script_in_odoo_shell(){
-	local SERVICE_NAME="$1"
-	local DB_NAME="$2"
-	local PYTHON_SCRIPT="$3"
-	compose --debug run "$SERVICE_NAME" shell -d "$DB_NAME" --no-http --stop-after-init < "$PYTHON_SCRIPT"
-}
-export -f exec_python_script_in_odoo_shell
-
-##############################################
-# CHECKS ALL NEEDED COMPONENTS ARE AVAILABLE #
-##############################################
-
-echo "
-==== CHECKS ALL NEEDED COMPONENTS ARE AVAILABLE ===="
-
-# Check origin database is in the local postgres
-DB_EXISTS=$(docker exec -it -u 70 "$POSTGRES_SERVICE_NAME" psql -tc "SELECT 1 FROM pg_database WHERE datname = '$ORIGIN_DB_NAME'" | tr -d '[:space:]')
-if [[ "$DB_EXISTS" ]]; then
-    echo "UPGRADE: Database '$ORIGIN_DB_NAME' found."
 else
-    echo "ERROR: Database '$ORIGIN_DB_NAME' not found in the local postgress service. Please add it and restart the upgrade process."
+    log_error "Database '$ORIGIN_DB_NAME' not found in the local postgres service. Please add it and restart the upgrade process."
     exit 1
 fi
 
-# Check that the origin filestore exist
+filestore_path="${DATASTORE_PATH}/${ORIGIN_SERVICE_NAME}/${FILESTORE_SUBPATH}/${ORIGIN_DB_NAME}"
-REPERTOIRE="/srv/datastore/data/${ORIGIN_SERVICE_NAME}/var/lib/odoo/filestore/${ORIGIN_DB_NAME}"
+if [[ -d "$filestore_path" ]]; then
-if [[ -d "$REPERTOIRE" ]]; then
+    log_info "Filestore '$filestore_path' found."
-    echo "UPGRADE: '$REPERTOIRE' filestore found."
 else
-    echo "ERROR: '$REPERTOIRE' filestore not found, please add it and restart the upgrade process."
+    log_error "Filestore '$filestore_path' not found, please add it and restart the upgrade process."
     exit 1
 fi
 
-#######################################
+log_step "LAUNCH VIRGIN ODOO IN FINAL VERSION"
-# LAUNCH VIRGIN ODOO IN FINAL VERSION #
-#######################################
 
-# Remove finale database and datastore if already exists (we need a virgin Odoo)
 if docker exec -u 70 "$POSTGRES_SERVICE_NAME" pgm ls | grep -q "$FINALE_SERVICE_NAME"; then
+    log_info "Removing existing finale database and filestore..."
     docker exec -u 70 "$POSTGRES_SERVICE_NAME" pgm rm -f "$FINALE_SERVICE_NAME"
-    sudo rm -rf /srv/datastore/data/"$FINALE_SERVICE_NAME"/var/lib/odoo/filestore/"$FINALE_SERVICE_NAME"
+    sudo rm -rf "${DATASTORE_PATH}/${FINALE_SERVICE_NAME}/${FILESTORE_SUBPATH}/${FINALE_SERVICE_NAME}"
 fi
 
 compose --debug run "$FINALE_SERVICE_NAME" -i base --stop-after-init --no-http
 
-echo "Model database in final Odoo version created."
+log_info "Model database in final Odoo version created."
 
-############################
+log_step "COPY ORIGINAL COMPONENTS"
-# COPY ORIGINAL COMPONENTS #
-############################
 
-echo "
+copy_database "$ORIGIN_DB_NAME" "$COPY_DB_NAME" "$COPY_DB_NAME"
-==== COPY ORIGINAL COMPONENTS ===="
+log_info "Original database copied to ${COPY_DB_NAME}@${COPY_DB_NAME}."
-echo "UPGRADE: Start copy"
 
-# Copy database
+copy_filestore "$ORIGIN_SERVICE_NAME" "$ORIGIN_DB_NAME" "$COPY_DB_NAME" "$COPY_DB_NAME"
-copy_database "$ORIGIN_DB_NAME" "$COPY_DB_NAME" "$COPY_DB_NAME" || exit 1
+log_info "Original filestore copied."
-echo "UPGRADE: original database copied in ${COPY_DB_NAME}@${COPY_DB_NAME}."
-
-# Copy filestore
-copy_filestore "$ORIGIN_SERVICE_NAME" "$ORIGIN_DB_NAME" "$COPY_DB_NAME" "$COPY_DB_NAME" || exit 1
-echo "UPGRADE: original filestore copied."
 
 
-#####################
+log_step "PATH OF MIGRATION"
-# PATH OF MIGRATION #
-####################
 
-echo "
+readarray -t versions < <(seq $((ORIGIN_VERSION + 1)) "$FINAL_VERSION")
-==== PATH OF MIGRATION ===="
+log_info "Migration path is ${versions[*]}"
-# List all the versions to migrate through
-declare -a versions
-nb_migrations=$((FINAL_VERSION - ORIGIN_VERSION))
 
-# Build the migration path
+
-for ((i = 0; i < nb_migrations; i++)); do
+log_step "DATABASE PREPARATION"
-    versions[i]=$((ORIGIN_VERSION + 1 + i))
+
+./prepare_db.sh "$COPY_DB_NAME" "$COPY_DB_NAME" "$FINALE_DB_NAME" "$FINALE_SERVICE_NAME"
+
+
+log_step "UPGRADE PROCESS"
+
+for version in "${versions[@]}"; do
+    log_info "START UPGRADE TO ${version}.0"
+
+    "${SCRIPT_DIR}/${version}.0/pre_upgrade.sh"
+    "${SCRIPT_DIR}/${version}.0/upgrade.sh"
+    "${SCRIPT_DIR}/${version}.0/post_upgrade.sh"
+
+    log_info "END UPGRADE TO ${version}.0"
 done
-echo "UPGRADE: Migration path is ${versions[@]}"
 
+log_step "POST-UPGRADE PROCESSES"
 
-########################
+./finalize_db.sh "$FINALE_DB_NAME" "$FINALE_SERVICE_NAME"
-# DATABASE PREPARATION #
-########################
 
-echo "
+log_step "UPGRADE PROCESS ENDED WITH SUCCESS"
-==== DATABASE PREPARATION ===="
-
-./prepare_db.sh "$COPY_DB_NAME" "$COPY_DB_NAME" "$FINALE_DB_MODEL_NAME" "$FINALE_SERVICE_NAME" || exit 1
-
-
-###################
-# UPGRADE PROCESS #
-###################
-
-for version in "${versions[@]}"
-do
-    echo "START UPGRADE TO ${version}.0"
-    start_version=$((version-1))
-    end_version="$version"
-
-    ### Go to the repository holding the upgrate scripts
-    cd "${end_version}.0"
-
-    ### Execute pre_upgrade scripts
-    ./pre_upgrade.sh || exit 1
-
-    ### Start upgrade
-    ./upgrade.sh || exit 1
-
-    ### Execute post-upgrade scripts
-    ./post_upgrade.sh || exit 1
-
-    ### Return to parent repository for the following steps
-    cd ..
-    echo "END UPGRADE TO ${version}.0"
-done
-## END UPGRADE LOOP
-
-##########################
-# POST-UPGRADE PROCESSES #
-##########################
-./finalize_db.sh "$FINALE_DB_NAME" "$FINALE_SERVICE_NAME" || exit 1
-
-
-echo "UPGRADE PROCESS ENDED WITH SUCCESS"