[IMP] add external command verification at startup

Add check_required_commands() function to verify that all required
external tools are available before the script begins execution:
- docker: Container runtime
- compose: Docker compose wrapper (0k-scripts)
- sudo: Required for filestore operations

Benefits:
- Fails fast with a clear error message listing missing commands
- Prevents cryptic 'command not found' errors mid-execution
- Documents script dependencies explicitly
- Called immediately after argument validation in upgrade.sh

lib/common.sh

@@ -0,0 +1,82 @@
+#!/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; 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" "$*"; }
+
+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 "$dst_path"
+    sudo rm -rf "$dst_path"
+    sudo cp -a "$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
+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,37 +42,34 @@ echo "Base neutralized..."
 ## List add-ons not in final version ##
 #######################################
 
-# Retrieve add-ons not available on the final Odoo version
+SQL_404_ADDONS_LIST=$(cat <<EOF
-SQL_404_ADDONS_LIST="
 SELECT module_origin.name
 FROM ir_module_module module_origin
 LEFT JOIN (
     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 module_dest ON module_dest.name = module_origin.name
-
+WHERE (module_dest.name IS NULL)
-	WHERE (module_dest.name IS NULL) AND (module_origin.state = 'installed') AND (module_origin.author NOT IN ('Odoo S.A.', 'Lokavaluto', 'Elabore'))
+  AND (module_origin.state = 'installed')
-	ORDER BY module_origin.name
+  AND (module_origin.author NOT IN ('Odoo S.A.', 'Lokavaluto', 'Elabore'))
-;
+ORDER BY module_origin.name;
-"
+EOF
+)
 echo "Retrieve 404 addons... "
 echo "SQL REQUEST = $SQL_404_ADDONS_LIST"
-query_postgres_container "$SQL_404_ADDONS_LIST" "$DB_NAME" > 404_addons || exit 1
+query_postgres_container "$SQL_404_ADDONS_LIST" "$DB_NAME" > "${TMPDIR}/404_addons"
 
-# 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
+query_postgres_container "$INSTALLED_ADDONS" "$DB_NAME" > "${TMPDIR}/installed_addons"
 
-grep -Fx -f 404_addons installed_addons > final_404_addons
+grep -Fx -f "${TMPDIR}/404_addons" "${TMPDIR}/installed_addons" > "${TMPDIR}/final_404_addons" || true
-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
+cat "${TMPDIR}/final_404_addons"
 
 
 echo "

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,124 @@ 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)
+postgres_containers=$(docker ps --format '{{.Names}}' | grep postgres || true)
-POSTGRES_CONTAINERS=$(docker ps --format '{{.Names}}' | grep postgres)
+postgres_count=$(echo "$postgres_containers" | grep -c . || echo 0)
-POSTGRES_COUNT=$(echo "$POSTGRES_CONTAINERS" | grep -c .)
 
-if [[ "$POSTGRES_COUNT" -eq 0 ]]; then
+if [[ "$postgres_count" -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_count" -gt 1 ]]; then
-    echo "ERROR: Multiple PostgreSQL containers found:" >&2
+    log_error "Multiple PostgreSQL containers found:"
-    echo "$POSTGRES_CONTAINERS" >&2
+    echo "$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"
+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 "
-==== PATH OF MIGRATION ===="
-# 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
     versions[i]=$((ORIGIN_VERSION + 1 + i))
 done
-echo "UPGRADE: Migration path is ${versions[@]}"
+log_info "Migration path is ${versions[*]}"
 
 
-########################
+log_step "DATABASE PREPARATION"
-# DATABASE PREPARATION #
-########################
 
-echo "
+./prepare_db.sh "$COPY_DB_NAME" "$COPY_DB_NAME" "$FINALE_DB_MODEL_NAME" "$FINALE_SERVICE_NAME"
-==== DATABASE PREPARATION ===="
-
-./prepare_db.sh "$COPY_DB_NAME" "$COPY_DB_NAME" "$FINALE_DB_MODEL_NAME" "$FINALE_SERVICE_NAME" || exit 1
 
 
-###################
+log_step "UPGRADE PROCESS"
-# UPGRADE PROCESS #
-###################
 
-for version in "${versions[@]}"
+for version in "${versions[@]}"; do
-do
+    log_info "START UPGRADE TO ${version}.0"
-    echo "START UPGRADE TO ${version}.0"
-    start_version=$((version-1))
-    end_version="$version"
 
-    ### Go to the repository holding the upgrate scripts
+    cd "${version}.0"
-    cd "${end_version}.0"
 
-    ### Execute pre_upgrade scripts
+    ./pre_upgrade.sh
-    ./pre_upgrade.sh || exit 1
+    ./upgrade.sh
+    ./post_upgrade.sh
 
-    ### 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"
+    log_info "END UPGRADE TO ${version}.0"
 done
-## END UPGRADE LOOP
 
-##########################
+log_step "POST-UPGRADE PROCESSES"
-# POST-UPGRADE PROCESSES #
-##########################
-./finalize_db.sh "$FINALE_DB_NAME" "$FINALE_SERVICE_NAME" || exit 1
 
+./finalize_db.sh "$FINALE_DB_NAME" "$FINALE_SERVICE_NAME"
 
-echo "UPGRADE PROCESS ENDED WITH SUCCESS"
+log_step "UPGRADE PROCESS ENDED WITH SUCCESS"