From 5b372610ec2fddeb6ac9e396bab3b98a84959069 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Chastanet?= Date: Tue, 5 Dec 2023 23:06:19 +0100 Subject: [PATCH] binaries - fixed colors were replaced during compilation --- .pre-commit-config.yaml | 12 ++- bin/dbQueryAllDatabases | 4 +- bin/dbScriptAllDatabases | 4 +- bin/doc | 5 +- bin/installRequirements | 20 +++- bin/mysql2puml | 19 ++-- bin/upgradeGithubRelease | 55 +++++------ bin/waitForIt | 24 ++--- bin/waitForMysql | 8 +- conf/mysql2pumlSkins/default.png | Bin 0 -> 952 bytes conf/mysql2pumlSkins/default.svg | 1 + .../Converters/mysql2puml.options.tpl | 16 ++-- .../Converters/testsData/mysql2puml.help.txt | 11 ++- .../Converters/testsData/mysql2puml.png | Bin 0 -> 47051 bytes .../Converters/testsData/mysql2puml.svg | 1 + .../testsData/mysql2pumlSkins/default.png | Bin 0 -> 952 bytes .../testsData/mysql2pumlSkins/default.svg | 1 + src/_binaries/DbImport/dbImport.bats | 2 +- .../testsData/upgradeGithubRelease.help.txt | 68 +++++++------- src/_binaries/Git/upgradeGithubRelease.bats | 2 +- .../Git/upgradeGithubRelease.help.txt | 38 ++++++++ .../Git/upgradeGithubRelease.options.tpl | 86 +++++------------- src/_binaries/Utils/waitForIt.options.tpl | 4 +- src/_binaries/Utils/waitForMysql.options.tpl | 4 +- .../build/installRequirements.options.tpl | 7 +- 25 files changed, 216 insertions(+), 176 deletions(-) create mode 100644 conf/mysql2pumlSkins/default.png create mode 100644 conf/mysql2pumlSkins/default.svg create mode 100644 src/_binaries/Converters/testsData/mysql2puml.png create mode 100644 src/_binaries/Converters/testsData/mysql2puml.svg create mode 100644 src/_binaries/Converters/testsData/mysql2pumlSkins/default.png create mode 100644 src/_binaries/Converters/testsData/mysql2pumlSkins/default.svg create mode 100644 src/_binaries/Git/upgradeGithubRelease.help.txt diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a3d70d1d..0c331385 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -20,10 +20,12 @@ repos: (?x)( .svg$ ) + - id: trailing-whitespace - id: check-executables-have-shebangs - id: check-shebang-scripts-are-executable - id: check-xml - id: check-yaml + - id: check-added-large-files - id: forbid-new-submodules - id: mixed-line-ending args: [--fix=lf] @@ -35,6 +37,11 @@ repos: .vscode\/launch.json )$ + - repo: https://github.com/pre-commit/mirrors-prettier + rev: v3.1.0 + hooks: + - id: prettier + - repo: https://github.com/fchastanet/jumanjihouse-pre-commit-hooks rev: 3.0.2 hooks: @@ -55,11 +62,6 @@ repos: - id: git-check exclude: /testsData/ - - repo: https://github.com/pre-commit/mirrors-prettier - rev: v3.1.0 - hooks: - - id: prettier - - repo: https://github.com/fchastanet/bash-tools-framework rev: 2.0.1 hooks: diff --git a/bin/dbQueryAllDatabases b/bin/dbQueryAllDatabases index f5c52013..96980d37 100755 --- a/bin/dbQueryAllDatabases +++ b/bin/dbQueryAllDatabases @@ -1094,8 +1094,8 @@ Log::logSkipped() { # @require Compiler::Embed::requireEmbedBinDir -declare -gx embed_function_DbQueryOneDatabase="${PERSISTENT_TMPDIR:-/tmp}/bin/c6442837509215243421aff83f20328b/dbQueryOneDatabase" -declare -gx encoded_binary_file_DbQueryOneDatabase="#!/usr/bin/env bash
###############################################################################
# GENERATED FACADE FROM https://github.com/fchastanet/bash-tools/tree/master/../bash-dev-env/vendor/bash-tools-framework/src/Compiler/Embed/embedFrameworkFunction.binFile.tpl
# DO NOT EDIT IT
# @generated
###############################################################################
# shellcheck disable=SC2288,SC2034
# BIN_FILE=${BIN_FILE}
# FACADE

# ensure that no user aliases could interfere with
# commands used in this script
unalias -a || true
shopt -u expand_aliases

# shellcheck disable=SC2034
((failures = 0)) || true

# Bash will remember & return the highest exit code in a chain of pipes.
# This way you can catch the error inside pipes, e.g. mysqldump | gzip
set -o pipefail
set -o errexit

# Command Substitution can inherit errexit option since bash v4.4
shopt -s inherit_errexit || true

# a log is generated when a command fails
set -o errtrace

# use nullglob so that (file*.php) will return an empty array if no file matches the wildcard
shopt -s nullglob

# ensure regexp are interpreted without accentuated characters
export LC_ALL=POSIX

export TERM=xterm-256color

# avoid interactive install
export DEBIAN_FRONTEND=noninteractive
export DEBCONF_NONINTERACTIVE_SEEN=true

# store command arguments for later usage
# shellcheck disable=SC2034
declare -a BASH_FRAMEWORK_ARGV=("$@")
# shellcheck disable=SC2034
declare -a ORIGINAL_BASH_FRAMEWORK_ARGV=("$@")

# @see https://unix.stackexchange.com/a/386856
# shellcheck disable=SC2317
interruptManagement() {
  # restore SIGINT handler
  trap - INT
  # ensure that Ctrl-C is trapped by this script and not by sub process
  # report to the parent that we have indeed been interrupted
  kill -s INT "$$"
}
trap interruptManagement INT
SCRIPT_NAME=${0##*/}
REAL_SCRIPT_FILE="$(readlink -e "$(realpath "${BASH_SOURCE[0]}")")"
if [[ -n "${EMBED_CURRENT_DIR}" ]]; then
  CURRENT_DIR="${EMBED_CURRENT_DIR}"
else
  CURRENT_DIR="$(cd "$(readlink -e "${REAL_SCRIPT_FILE%/*}")" && pwd -P)"
fi

################################################
# Temp dir management
################################################

KEEP_TEMP_FILES="${KEEP_TEMP_FILES:-0}"
export KEEP_TEMP_FILES

# PERSISTENT_TMPDIR is not deleted by traps
PERSISTENT_TMPDIR="${TMPDIR:-/tmp}/bash-framework"
export PERSISTENT_TMPDIR
mkdir -p "${PERSISTENT_TMPDIR}"

# shellcheck disable=SC2034
TMPDIR="$(mktemp -d -p "${PERSISTENT_TMPDIR:-/tmp}" -t bash-framework-$$-XXXXXX)"
export TMPDIR

# temp dir cleaning
# shellcheck disable=SC2317
cleanOnExit() {
  if [[ "${KEEP_TEMP_FILES:-0}" = "1" ]]; then
    Log::displayInfo "KEEP_TEMP_FILES=1 temp files kept here '${TMPDIR}'"
  elif [[ -n "${TMPDIR+xxx}" ]]; then
    Log::displayDebug "KEEP_TEMP_FILES=0 removing temp files '${TMPDIR}'"
    rm -Rf "${TMPDIR:-/tmp/fake}" >/dev/null 2>&1
  fi
}
trap cleanOnExit EXIT HUP QUIT ABRT TERM

# VAR_MAIN_FUNCTION_VAR_NAME=dbQueryAllDatabasesFacade

# @description used to execute given query when using
# dbScriptAllDatabases
# @arg $1 dsn:String
# @arg $2 db:String
# @env query String
# @env optionSeparator String
# @require Linux::requireExecutedAsUser
Db::queryOneDatabase() {
  # query and optionSeparator are passed via export
  local dsn="$1"
  local db="$2"

  local -A dbInstance
  Database::newInstance dbInstance "${dsn}"
  Database::setQueryOptions dbInstance "${dbInstance[QUERY_OPTIONS]} --connect-timeout=5"

  # identify columns header
  echo -n "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
  Database::skipColumnNames dbInstance 0

  # shellcheck disable=SC2154
  if ! Database::query dbInstance "${query}" "${db}" | sed "s/\t/${optionSeparator}/g"; then
    Log::fatal "database ${db} error" 1>&2
  fi
}

# @description Log namespace provides 2 kind of functions
# - Log::display* allows to display given message with
#   given display level
# - Log::log* allows to log given message with
#   given log level
# Log::display* functions automatically log the message too
# @see Env::requireLoad to load the display and log level from .env file

# @description log level off
export __LEVEL_OFF=0
# @description log level error
export __LEVEL_ERROR=1
# @description log level warning
export __LEVEL_WARNING=2
# @description log level info
export __LEVEL_INFO=3
# @description log level success
export __LEVEL_SUCCESS=3
# @description log level debug
export __LEVEL_DEBUG=4

# @description verbose level off
export __VERBOSE_LEVEL_OFF=0
# @description verbose level info
export __VERBOSE_LEVEL_INFO=1
# @description verbose level info
export __VERBOSE_LEVEL_DEBUG=2
# @description verbose level info
export __VERBOSE_LEVEL_TRACE=3

# @description Display message using debug color (grey)
# @arg $1 message:String the message to display
Log::displayDebug() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_DEBUG)); then
    echo -e "${__DEBUG_COLOR}DEBUG   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logDebug "$1"
}

# @description Display message using info color (bg light blue/fg white)
# @arg $1 message:String the message to display
Log::displayInfo() {
  local type="${2:-INFO}"
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__INFO_COLOR}${type}    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logInfo "$1" "${type}"
}

# @description ensure COMMAND_BIN_DIR env var is set
# and PATH correctly prepared
# @noargs
# @set COMMAND_BIN_DIR string the directory where to find this command
# @set PATH string add directory where to find this command binary
Compiler::Facade::requireCommandBinDir() {
  COMMAND_BIN_DIR="${CURRENT_DIR}"
  Env::pathPrepend "${COMMAND_BIN_DIR}"
}

# @description create a new db instance
# Returns immediately if the instance is already initialized
#
# @arg $1 instanceNewInstance:&Map<String,String> (passed by reference) database instance to use
# @arg $2 dsn:String dsn profile - load the dsn.env profile deduced using rules defined in Conf::getAbsoluteFile
#
# @example
#   declare -Agx dbInstance
#   Database::newInstance dbInstance "default.local"
#
# @exitcode 1 if dns file not able to loaded
Database::newInstance() {
  local -n instanceNewInstance=$1
  local dsn="$2"
  local DSN_FILE

  if [[ -v instanceNewInstance['INITIALIZED'] && "${instanceNewInstance['INITIALIZED']:-0}" == "1" ]]; then
    return
  fi

  # final auth file generated from dns file
  instanceNewInstance['AUTH_FILE']=""
  instanceNewInstance['DSN_FILE']=""

  # check dsn file
  DSN_FILE="$(Conf::getAbsoluteFile "dsn" "${dsn}" "env")" || return 1
  Database::checkDsnFile "${DSN_FILE}" || return 1
  instanceNewInstance['DSN_FILE']="${DSN_FILE}"

  # shellcheck source=/src/Database/testsData/dsn_valid.env
  source "${instanceNewInstance['DSN_FILE']}"

  instanceNewInstance['USER']="${USER}"
  instanceNewInstance['PASSWORD']="${PASSWORD}"
  instanceNewInstance['HOSTNAME']="${HOSTNAME}"
  instanceNewInstance['PORT']="${PORT}"

  # generate authFile for easy authentication
  instanceNewInstance['AUTH_FILE']=$(mktemp -p "${TMPDIR:-/tmp}" -t "mysql.XXXXXXXXXXXX")
  (
    echo "[client]"
    echo "user = ${USER}"
    echo "password = ${PASSWORD}"
    echo "host = ${HOSTNAME}"
    echo "port = ${PORT}"
  ) >"${instanceNewInstance['AUTH_FILE']}"

  # some of those values can be overridden using the dsn file
  # SKIP_COLUMN_NAMES enabled by default
  instanceNewInstance['SKIP_COLUMN_NAMES']="${SKIP_COLUMN_NAMES:-1}"
  instanceNewInstance['SSL_OPTIONS']="${MYSQL_SSL_OPTIONS:---ssl-mode=DISABLED}"
  instanceNewInstance['QUERY_OPTIONS']="${MYSQL_QUERY_OPTIONS:---batch --raw --default-character-set=utf8}"
  instanceNewInstance['DUMP_OPTIONS']="${MYSQL_DUMP_OPTIONS:---default-character-set=utf8 --compress --hex-blob --routines --triggers --single-transaction --set-gtid-purged=OFF --column-statistics=0 ${instanceNewInstance['SSL_OPTIONS']}}"
  instanceNewInstance['DB_IMPORT_OPTIONS']="${DB_IMPORT_OPTIONS:---connect-timeout=5 --batch --raw --default-character-set=utf8}"

  instanceNewInstance['INITIALIZED']=1
}

# @description mysql query on a given db
# @warning could use QUERY_OPTIONS variable from dsn if defined
# @example
#   cat file.sql | Database::query ...
# @arg $1 instanceQuery:&Map<String,String> (passed by reference) database instance to use
# @arg $2 sqlQuery:String (optional) sql query or sql file to execute. if not provided or empty, the command can be piped
# @arg $3 dbName:String (optional) the db name
#
# @exitcode mysql command status code
Database::query() {
  local -n instanceQuery=$1
  local -a mysqlCommand=()
  local -a queryOptions

  mysqlCommand+=(mysql)
  mysqlCommand+=("--defaults-extra-file=${instanceQuery['AUTH_FILE']}")
  IFS=' ' read -r -a queryOptions <<<"${instanceQuery['QUERY_OPTIONS']}"
  mysqlCommand+=("${queryOptions[@]}")
  if [[ "${instanceQuery['SKIP_COLUMN_NAMES']}" = "1" ]]; then
    mysqlCommand+=("-s" "--skip-column-names")
  fi
  # add optional db name
  if [[ -n "${3+x}" ]]; then
    mysqlCommand+=("$3")
  fi
  # add optional sql query
  if [[ -n "${2+x}" && -n "$2" && ! -f "$2" ]]; then
    mysqlCommand+=("-e")
    mysqlCommand+=("$2")
  fi
  Log::displayDebug "$(printf "execute command: '%s'" "${mysqlCommand[*]}")"

  if [[ -f "$2" ]]; then
    "${mysqlCommand[@]}" <"$2"
  else
    "${mysqlCommand[@]}"
  fi
}

# @description set the general options to use on mysql command to query the database
# Differs than setOptions in the way that these options could change each time
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 optionsList:String query options list
Database::setQueryOptions() {
  local -n instanceSetQueryOptions=$1
  # shellcheck disable=SC2034
  instanceSetQueryOptions['QUERY_OPTIONS']="$2"
}

# @description by default we skip the column names
# but sometimes we need column names to display some results
# disable this option temporarily and then restore it to true
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 skipColumnNames:Boolean 0 to disable, 1 to enable (hide column names)
Database::skipColumnNames() {
  local -n instanceSkipColumnNames=$1
  # shellcheck disable=SC2034
  instanceSkipColumnNames['SKIP_COLUMN_NAMES']="$2"
}

# @description prepend directories to the PATH environment variable
# @arg $@ args:String[] list of directories to prepend
# @set PATH update PATH with the directories prepended
Env::pathPrepend() {
  local arg
  for arg in "$@"; do
    if [[ -d "${arg}" && ":${PATH}:" != *":${arg}:"* ]]; then
      PATH="$(realpath "${arg}"):${PATH}"
    fi
  done
}

# @description Display message using error color (red) and exit immediately with error status 1
# @arg $1 message:String the message to display
Log::fatal() {
  echo -e "${__ERROR_COLOR}FATAL   - ${1}${__RESET_COLOR}" >&2
  Log::logFatal "$1"
  exit 1
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logDebug() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_DEBUG)); then
    Log::logMessage "${2:-DEBUG}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logInfo() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-INFO}" "$1"
  fi
}

# @description ensure running user is not root
# @exitcode 1 if current user is root
# @stderr diagnostics information is displayed
Linux::requireExecutedAsUser() {
  if [[ "$(id -u)" = "0" ]]; then
    Log::fatal "this script should be executed as normal user"
  fi
}

# @description get absolute conf file from specified conf folder deduced using these rules
#   * from absolute file (ignores <confFolder> and <extension>)
#   * relative to where script is executed (ignores <confFolder> and <extension>)
#   * from home/.bash-tools/<confFolder>
#   * from framework conf/<confFolder>
#
# @arg $1 confFolder:String the directory name (not the path) to list
# @arg $2 conf:String file to use without extension
# @arg $3 extension:String the extension (.sh by default)
#
# @stdout absolute conf filename
# @exitcode 1 if file is not found in any location
Conf::getAbsoluteFile() {
  local confFolder="$1"
  local conf="$2"
  local extension="${3-.sh}"
  if [[ -n "${extension}" && "${extension:0:1}" != "." ]]; then
    extension=".${extension}"
  fi

  testAbs() {
    local result
    result="$(realpath -e "$1" 2>/dev/null)"
    # shellcheck disable=SC2181
    if [[ "$?" = "0" && -f "${result}" ]]; then
      echo "${result}"
      return 0
    fi
    return 1
  }

  # conf is absolute file (including extension)
  testAbs "${confFolder}${extension}" && return 0
  # conf is absolute file
  testAbs "${confFolder}" && return 0
  # conf is absolute file (including extension)
  testAbs "${conf}${extension}" && return 0
  # conf is absolute file
  testAbs "${conf}" && return 0

  # relative to where script is executed (including extension)
  if [[ -n "${CURRENT_DIR+xxx}" ]]; then
    testAbs "$(File::concatenatePath "${CURRENT_DIR}" "${confFolder}")/${conf}${extension}" && return 0
  fi
  # from home/.bash-tools/<confFolder>
  testAbs "$(File::concatenatePath "${HOME}/.bash-tools" "${confFolder}")/${conf}${extension}" && return 0

  if [[ -n "${FRAMEWORK_ROOT_DIR+xxx}" ]]; then
    # from framework conf/<confFolder> (including extension)
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}${extension}" && return 0

    # from framework conf/<confFolder>
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}" && return 0
  fi

  # file not found
  Log::displayError "conf file '${conf}' not found"

  return 1
}

# @description check if dsn file has all the mandatory variables set
# Mandatory variables are: HOSTNAME, USER, PASSWORD, PORT
#
# @arg $1 dsnFileName:String dsn absolute filename
# @set HOSTNAME loaded from dsn file
# @set PORT loaded from dsn file
# @set USER loaded from dsn file
# @set PASSWORD loaded from dsn file
# @exitcode 0 on valid file
# @exitcode 1 if one of the properties of the conf file is invalid or if file not found
# @stderr log output if error found in conf file
Database::checkDsnFile() {
  local dsnFileName="$1"
  if [[ ! -f "${dsnFileName}" ]]; then
    Log::displayError "dsn file ${dsnFileName} not found"
    return 1
  fi

  (
    unset HOSTNAME PORT PASSWORD USER
    # shellcheck source=/src/Database/testsData/dsn_valid.env
    source "${dsnFileName}"
    if [[ -z ${HOSTNAME+x} ]]; then
      Log::displayError "dsn file ${dsnFileName} : HOSTNAME not provided"
      return 1
    fi
    if [[ -z "${HOSTNAME}" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : HOSTNAME value not provided"
    fi
    if [[ "${HOSTNAME}" = "localhost" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : check that HOSTNAME should not be 127.0.0.1 instead of localhost"
    fi
    if [[ -z "${PORT+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT not provided"
      return 1
    fi
    if ! [[ ${PORT} =~ ^[0-9]+$ ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT invalid"
      return 1
    fi
    if [[ -z "${USER+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : USER not provided"
      return 1
    fi
    if [[ -z "${PASSWORD+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PASSWORD not provided"
      return 1
    fi
  )
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logFatal() {
  Log::logMessage "${2:-FATAL}" "$1"
}

# @description Internal: common log message
# @example text
#   [date]|[levelMsg]|message
#
# @example text
#   2020-01-19 19:20:21|ERROR  |log error
#   2020-01-19 19:20:21|SKIPPED|log skipped
#
# @arg $1 levelMsg:String message's level description (eg: STATUS, ERROR, ...)
# @arg $2 msg:String the message to display
# @env BASH_FRAMEWORK_LOG_FILE String log file to use, do nothing if empty
# @env BASH_FRAMEWORK_LOG_LEVEL int log level log only if > OFF or fatal messages
# @stderr diagnostics information is displayed
# @require Env::requireLoad
# @require Log::requireLoad
Log::logMessage() {
  local levelMsg="$1"
  local msg="$2"
  local date

  if [[ -n "${BASH_FRAMEWORK_LOG_FILE}" ]] && ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    date="$(date '+%Y-%m-%d %H:%M:%S')"
    touch "${BASH_FRAMEWORK_LOG_FILE}"
    printf "%s|%7s|%s\n" "${date}" "${levelMsg}" "${msg}" >>"${BASH_FRAMEWORK_LOG_FILE}"
  fi
}

# @description concatenate 2 paths and ensure the path is correct using realpath -m
# @arg $1 basePath:String
# @arg $2 subPath:String
# @require Linux::requireRealpathCommand
File::concatenatePath() {
  local basePath="$1"
  local subPath="$2"
  local fullPath="${basePath:+${basePath}/}${subPath}"

  realpath -m "${fullPath}" 2>/dev/null
}

# @description Display message using error color (red)
# @arg $1 message:String the message to display
Log::displayError() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_ERROR)); then
    echo -e "${__ERROR_COLOR}ERROR   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logError "$1"
}

# @description Display message using warning color (yellow)
# @arg $1 message:String the message to display
Log::displayWarning() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_WARNING)); then
    echo -e "${__WARNING_COLOR}WARN    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logWarning "$1"
}

# @description ensure env files are loaded
# @arg $@ list of default files to load at the end
# @exitcode 1 if one of env files fails to load
# @stderr diagnostics information is displayed
# shellcheck disable=SC2120
Env::requireLoad() {
  local -a defaultFiles=("$@")
  # get list of possible config files
  local -a configFiles=()
  if [[ -n "${BASH_FRAMEWORK_ENV_FILES[0]+1}" ]]; then
    # BASH_FRAMEWORK_ENV_FILES is an array
    configFiles+=("${BASH_FRAMEWORK_ENV_FILES[@]}")
  fi
  if [[ -f "$(pwd)/.framework-config" ]]; then
    configFiles+=("$(pwd)/.framework-config")
  fi
  if [[ -f "${FRAMEWORK_ROOT_DIR}/.framework-config" ]]; then
    configFiles+=("${FRAMEWORK_ROOT_DIR}/.framework-config")
  fi
  if [[ -n "${optionBashFrameworkConfig}" && -f "${optionBashFrameworkConfig}" ]]; then
    # shellcheck disable=SC2034
    configFiles+=("${optionBashFrameworkConfig}")
  fi
  configFiles+=("${optionEnvFiles[@]}")
  configFiles+=("${defaultFiles[@]}")

  for file in "${configFiles[@]}"; do
    # shellcheck source=/.framework-config
    CURRENT_LOADED_ENV_FILE="${file}" source "${file}" || {
      Log::displayError "while loading config file: ${file}"
      return 1
    }
  done
}

# @description activate or not Log::display* and Log::log* functions
# based on BASH_FRAMEWORK_DISPLAY_LEVEL and BASH_FRAMEWORK_LOG_LEVEL
# environment variables loaded by Env::requireLoad
# try to create log file and rotate it if necessary
# @noargs
# @set BASH_FRAMEWORK_LOG_LEVEL int to OFF level if BASH_FRAMEWORK_LOG_FILE is empty or not writable
# @env BASH_FRAMEWORK_DISPLAY_LEVEL int
# @env BASH_FRAMEWORK_LOG_LEVEL int
# @env BASH_FRAMEWORK_LOG_FILE String
# @env BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION int do log rotation if > 0
# @exitcode 0 always successful
# @stderr diagnostics information about log file is displayed
# @require Env::requireLoad
# @require UI::requireTheme
Log::requireLoad() {
  if [[ -z "${BASH_FRAMEWORK_LOG_FILE:-}" ]]; then
    BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
    export BASH_FRAMEWORK_LOG_LEVEL
  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    if [[ ! -f "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      if
        ! mkdir -p "$(dirname "${BASH_FRAMEWORK_LOG_FILE}")" 2>/dev/null ||
          ! touch --no-create "${BASH_FRAMEWORK_LOG_FILE}" 2>/dev/null
      then
        BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
        echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
      fi
    elif [[ ! -w "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
      echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
    fi

  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    # will always be created even if not in info level
    Log::logMessage "INFO" "Logging to file ${BASH_FRAMEWORK_LOG_FILE} - Log level ${BASH_FRAMEWORK_LOG_LEVEL}"
    if ((BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION > 0)); then
      Log::rotate "${BASH_FRAMEWORK_LOG_FILE}" "${BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION}"
    fi
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logError() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_ERROR)); then
    Log::logMessage "${2:-ERROR}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logWarning() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_WARNING)); then
    Log::logMessage "${2:-WARNING}" "$1"
  fi
}

# @description To be called before logging in the log file
# @arg $1 file:string log file name
# @arg $2 maxLogFilesCount:int maximum number of log files
Log::rotate() {
  local file="$1"
  local maxLogFilesCount="${2:-5}"

  if [[ ! -f "${file}" ]]; then
    Log::displaySkipped "Log file ${file} doesn't exist yet"
    return 0
  fi
  for i in $(seq $((maxLogFilesCount - 1)) -1 1); do
    Log::displayInfo "Log rotation ${file}.${i} to ${file}.$((i + 1))"
    mv "${file}."{"${i}","$((i + 1))"} &>/dev/null || true
  done
  if cp "${file}" "${file}.1" &>/dev/null; then
    echo >"${file}" # reset log file
    Log::displayInfo "Log rotation ${file} to ${file}.1"
  fi
}

# @description ensure command realpath is available
# @exitcode 1 if realpath command not available
# @stderr diagnostics information is displayed
Linux::requireRealpathCommand() {
  Assert::commandExists realpath
}

# @description load color theme
# @noargs
# @env BASH_FRAMEWORK_THEME String theme to use
# @exitcode 0 always successful
UI::requireTheme() {
  UI::theme "${BASH_FRAMEWORK_THEME-default}"
}

# @description check if command specified exists or return 1
# with error and message if not
#
# @arg $1 commandName:String on which existence must be checked
# @arg $2 helpIfNotExists:String a help command to display if the command does not exist
#
# @exitcode 1 if the command specified does not exist
# @stderr diagnostic information + help if second argument is provided
Assert::commandExists() {
  local commandName="$1"
  local helpIfNotExists="$2"

  "${BASH_FRAMEWORK_COMMAND:-command}" -v "${commandName}" >/dev/null 2>/dev/null || {
    Log::displayError "${commandName} is not installed, please install it"
    if [[ -n "${helpIfNotExists}" ]]; then
      Log::displayInfo "${helpIfNotExists}"
    fi
    return 1
  }
  return 0
}

# @description Display message using skip color (yellow)
# @arg $1 message:String the message to display
Log::displaySkipped() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__SKIPPED_COLOR}SKIPPED - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logSkipped "$1"
}

# @description load colors theme constants
# @warning if tty not opened, noColor theme will be chosen
# @arg $1 theme:String the theme to use (default, noColor)
# @arg $@ args:String[]
# @set __ERROR_COLOR String indicate error status
# @set __INFO_COLOR String indicate info status
# @set __SUCCESS_COLOR String indicate success status
# @set __WARNING_COLOR String indicate warning status
# @set __SKIPPED_COLOR String indicate skipped status
# @set __DEBUG_COLOR String indicate debug status
# @set __HELP_COLOR String indicate help status
# @set __TEST_COLOR String not used
# @set __TEST_ERROR_COLOR String not used
# @set __HELP_TITLE_COLOR String used to display help title in help strings
# @set __HELP_OPTION_COLOR String used to display highlight options in help strings
#
# @set __RESET_COLOR String reset default color
#
# @set __HELP_EXAMPLE String to remove
# @set __HELP_TITLE String to remove
# @set __HELP_NORMAL String to remove
# shellcheck disable=SC2034
UI::theme() {
  local theme="${1-default}"
  if [[ ! "${theme}" =~ -force$ ]] && ! Assert::tty; then
    theme="noColor"
  fi
  case "${theme}" in
    default | default-force)
      theme="default"
      ;;
    noColor) ;;
    *)
      Log::fatal "invalid theme provided"
      ;;
  esac
  if [[ "${theme}" = "default" ]]; then
    BASH_FRAMEWORK_THEME="default"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR='\e[31m'         # Red
    __INFO_COLOR='\e[44m'          # white on lightBlue
    __SUCCESS_COLOR='\e[32m'       # Green
    __WARNING_COLOR='\e[33m'       # Yellow
    __SKIPPED_COLOR='\e[33m'       # Yellow
    __DEBUG_COLOR='\e[37m'         # Grey
    __HELP_COLOR='\e[7;49;33m'     # Black on Gold
    __TEST_COLOR='\e[100m'         # Light magenta
    __TEST_ERROR_COLOR='\e[41m'    # white on red
    __HELP_TITLE_COLOR="\e[1;37m"  # Bold
    __HELP_OPTION_COLOR="\e[1;34m" # Blue
    # Internal: reset color
    __RESET_COLOR='\e[0m' # Reset Color
    # shellcheck disable=SC2155,SC2034
    __HELP_EXAMPLE="$(echo -e "\e[2;97m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_TITLE="$(echo -e "\e[1;37m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_NORMAL="$(echo -e "\033[0m")"
  else
    BASH_FRAMEWORK_THEME="noColor"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR=''
    __INFO_COLOR=''
    __SUCCESS_COLOR=''
    __WARNING_COLOR=''
    __SKIPPED_COLOR=''
    __DEBUG_COLOR=''
    __HELP_COLOR=''
    __TEST_COLOR=''
    __TEST_ERROR_COLOR=''
    __HELP_TITLE_COLOR=''
    __HELP_OPTION_COLOR=''
    # Internal: reset color
    __RESET_COLOR=''
    __HELP_EXAMPLE=''
    __HELP_TITLE=''
    __HELP_NORMAL=''
  fi
}

# @description check if tty (interactive mode) is active
# @noargs
# @exitcode 1 if tty not active
# @env NON_INTERACTIVE if 1 consider as not interactive even if environment is interactive
# @env INTERACTIVE if 1 consider as interactive even if environment is not interactive
# @stderr diagnostic information + help if second argument is provided
Assert::tty() {
  if [[ "${NON_INTERACTIVE:-0}" = "1" ]]; then
    return 1
  fi
  if [[ "${INTERACTIVE:-0}" = "1" ]]; then
    return 0
  fi
  [[ -t 1 || -t 2 ]]
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logSkipped() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-SKIPPED}" "$1"
  fi
}

# FUNCTIONS

facade_main_embedFrameworkFunctionbinFiletpl() {
# REQUIRES
Linux::requireExecutedAsUser
Env::requireLoad
Log::requireLoad
Linux::requireRealpathCommand
UI::requireTheme
Compiler::Facade::requireCommandBinDir

# @require Compiler::Facade::requireCommandBinDir

# shellcheck disable=SC2154,SC2016
functionToCall='Db::queryOneDatabase'
"${functionToCall}" "$@"

}

facade_main_embedFrameworkFunctionbinFiletpl "$@"
" +declare -gx embed_function_DbQueryOneDatabase="${PERSISTENT_TMPDIR:-/tmp}/bin/4199f1403a7b340c22de7a6b0fda71a8/dbQueryOneDatabase" +declare -gx encoded_binary_file_DbQueryOneDatabase="#!/usr/bin/env bash
###############################################################################
# GENERATED FACADE FROM https://github.com/fchastanet/bash-tools/tree/master/../../.cache/pre-commit/repob0v8ngyh/src/Compiler/Embed/embedFrameworkFunction.binFile.tpl
# DO NOT EDIT IT
# @generated
###############################################################################
# shellcheck disable=SC2288,SC2034
# BIN_FILE=${BIN_FILE}
# FACADE

# ensure that no user aliases could interfere with
# commands used in this script
unalias -a || true
shopt -u expand_aliases

# shellcheck disable=SC2034
((failures = 0)) || true

# Bash will remember & return the highest exit code in a chain of pipes.
# This way you can catch the error inside pipes, e.g. mysqldump | gzip
set -o pipefail
set -o errexit

# Command Substitution can inherit errexit option since bash v4.4
shopt -s inherit_errexit || true

# a log is generated when a command fails
set -o errtrace

# use nullglob so that (file*.php) will return an empty array if no file matches the wildcard
shopt -s nullglob

# ensure regexp are interpreted without accentuated characters
export LC_ALL=POSIX

export TERM=xterm-256color

# avoid interactive install
export DEBIAN_FRONTEND=noninteractive
export DEBCONF_NONINTERACTIVE_SEEN=true

# store command arguments for later usage
# shellcheck disable=SC2034
declare -a BASH_FRAMEWORK_ARGV=("$@")
# shellcheck disable=SC2034
declare -a ORIGINAL_BASH_FRAMEWORK_ARGV=("$@")

# @see https://unix.stackexchange.com/a/386856
# shellcheck disable=SC2317
interruptManagement() {
  # restore SIGINT handler
  trap - INT
  # ensure that Ctrl-C is trapped by this script and not by sub process
  # report to the parent that we have indeed been interrupted
  kill -s INT "$$"
}
trap interruptManagement INT
SCRIPT_NAME=${0##*/}
REAL_SCRIPT_FILE="$(readlink -e "$(realpath "${BASH_SOURCE[0]}")")"
if [[ -n "${EMBED_CURRENT_DIR}" ]]; then
  CURRENT_DIR="${EMBED_CURRENT_DIR}"
else
  CURRENT_DIR="$(cd "$(readlink -e "${REAL_SCRIPT_FILE%/*}")" && pwd -P)"
fi

################################################
# Temp dir management
################################################

KEEP_TEMP_FILES="${KEEP_TEMP_FILES:-0}"
export KEEP_TEMP_FILES

# PERSISTENT_TMPDIR is not deleted by traps
PERSISTENT_TMPDIR="${TMPDIR:-/tmp}/bash-framework"
export PERSISTENT_TMPDIR
mkdir -p "${PERSISTENT_TMPDIR}"

# shellcheck disable=SC2034
TMPDIR="$(mktemp -d -p "${PERSISTENT_TMPDIR:-/tmp}" -t bash-framework-$$-XXXXXX)"
export TMPDIR

# temp dir cleaning
# shellcheck disable=SC2317
cleanOnExit() {
  if [[ "${KEEP_TEMP_FILES:-0}" = "1" ]]; then
    Log::displayInfo "KEEP_TEMP_FILES=1 temp files kept here '${TMPDIR}'"
  elif [[ -n "${TMPDIR+xxx}" ]]; then
    Log::displayDebug "KEEP_TEMP_FILES=0 removing temp files '${TMPDIR}'"
    rm -Rf "${TMPDIR:-/tmp/fake}" >/dev/null 2>&1
  fi
}
trap cleanOnExit EXIT HUP QUIT ABRT TERM

# VAR_MAIN_FUNCTION_VAR_NAME=dbQueryAllDatabasesFacade

# @description used to execute given query when using
# dbScriptAllDatabases
# @arg $1 dsn:String
# @arg $2 db:String
# @env query String
# @env optionSeparator String
# @require Linux::requireExecutedAsUser
Db::queryOneDatabase() {
  # query and optionSeparator are passed via export
  local dsn="$1"
  local db="$2"

  local -A dbInstance
  Database::newInstance dbInstance "${dsn}"
  Database::setQueryOptions dbInstance "${dbInstance[QUERY_OPTIONS]} --connect-timeout=5"

  # identify columns header
  echo -n "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
  Database::skipColumnNames dbInstance 0

  # shellcheck disable=SC2154
  if ! Database::query dbInstance "${query}" "${db}" | sed "s/\t/${optionSeparator}/g"; then
    Log::fatal "database ${db} error" 1>&2
  fi
}

# @description Log namespace provides 2 kind of functions
# - Log::display* allows to display given message with
#   given display level
# - Log::log* allows to log given message with
#   given log level
# Log::display* functions automatically log the message too
# @see Env::requireLoad to load the display and log level from .env file

# @description log level off
export __LEVEL_OFF=0
# @description log level error
export __LEVEL_ERROR=1
# @description log level warning
export __LEVEL_WARNING=2
# @description log level info
export __LEVEL_INFO=3
# @description log level success
export __LEVEL_SUCCESS=3
# @description log level debug
export __LEVEL_DEBUG=4

# @description verbose level off
export __VERBOSE_LEVEL_OFF=0
# @description verbose level info
export __VERBOSE_LEVEL_INFO=1
# @description verbose level info
export __VERBOSE_LEVEL_DEBUG=2
# @description verbose level info
export __VERBOSE_LEVEL_TRACE=3

# @description Display message using debug color (grey)
# @arg $1 message:String the message to display
Log::displayDebug() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_DEBUG)); then
    echo -e "${__DEBUG_COLOR}DEBUG   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logDebug "$1"
}

# @description Display message using info color (bg light blue/fg white)
# @arg $1 message:String the message to display
Log::displayInfo() {
  local type="${2:-INFO}"
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__INFO_COLOR}${type}    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logInfo "$1" "${type}"
}

# @description ensure COMMAND_BIN_DIR env var is set
# and PATH correctly prepared
# @noargs
# @set COMMAND_BIN_DIR string the directory where to find this command
# @set PATH string add directory where to find this command binary
Compiler::Facade::requireCommandBinDir() {
  COMMAND_BIN_DIR="${CURRENT_DIR}"
  Env::pathPrepend "${COMMAND_BIN_DIR}"
}

# @description create a new db instance
# Returns immediately if the instance is already initialized
#
# @arg $1 instanceNewInstance:&Map<String,String> (passed by reference) database instance to use
# @arg $2 dsn:String dsn profile - load the dsn.env profile deduced using rules defined in Conf::getAbsoluteFile
#
# @example
#   declare -Agx dbInstance
#   Database::newInstance dbInstance "default.local"
#
# @exitcode 1 if dns file not able to loaded
Database::newInstance() {
  local -n instanceNewInstance=$1
  local dsn="$2"
  local DSN_FILE

  if [[ -v instanceNewInstance['INITIALIZED'] && "${instanceNewInstance['INITIALIZED']:-0}" == "1" ]]; then
    return
  fi

  # final auth file generated from dns file
  instanceNewInstance['AUTH_FILE']=""
  instanceNewInstance['DSN_FILE']=""

  # check dsn file
  DSN_FILE="$(Conf::getAbsoluteFile "dsn" "${dsn}" "env")" || return 1
  Database::checkDsnFile "${DSN_FILE}" || return 1
  instanceNewInstance['DSN_FILE']="${DSN_FILE}"

  # shellcheck source=/src/Database/testsData/dsn_valid.env
  source "${instanceNewInstance['DSN_FILE']}"

  instanceNewInstance['USER']="${USER}"
  instanceNewInstance['PASSWORD']="${PASSWORD}"
  instanceNewInstance['HOSTNAME']="${HOSTNAME}"
  instanceNewInstance['PORT']="${PORT}"

  # generate authFile for easy authentication
  instanceNewInstance['AUTH_FILE']=$(mktemp -p "${TMPDIR:-/tmp}" -t "mysql.XXXXXXXXXXXX")
  (
    echo "[client]"
    echo "user = ${USER}"
    echo "password = ${PASSWORD}"
    echo "host = ${HOSTNAME}"
    echo "port = ${PORT}"
  ) >"${instanceNewInstance['AUTH_FILE']}"

  # some of those values can be overridden using the dsn file
  # SKIP_COLUMN_NAMES enabled by default
  instanceNewInstance['SKIP_COLUMN_NAMES']="${SKIP_COLUMN_NAMES:-1}"
  instanceNewInstance['SSL_OPTIONS']="${MYSQL_SSL_OPTIONS:---ssl-mode=DISABLED}"
  instanceNewInstance['QUERY_OPTIONS']="${MYSQL_QUERY_OPTIONS:---batch --raw --default-character-set=utf8}"
  instanceNewInstance['DUMP_OPTIONS']="${MYSQL_DUMP_OPTIONS:---default-character-set=utf8 --compress --hex-blob --routines --triggers --single-transaction --set-gtid-purged=OFF --column-statistics=0 ${instanceNewInstance['SSL_OPTIONS']}}"
  instanceNewInstance['DB_IMPORT_OPTIONS']="${DB_IMPORT_OPTIONS:---connect-timeout=5 --batch --raw --default-character-set=utf8}"

  instanceNewInstance['INITIALIZED']=1
}

# @description mysql query on a given db
# @warning could use QUERY_OPTIONS variable from dsn if defined
# @example
#   cat file.sql | Database::query ...
# @arg $1 instanceQuery:&Map<String,String> (passed by reference) database instance to use
# @arg $2 sqlQuery:String (optional) sql query or sql file to execute. if not provided or empty, the command can be piped
# @arg $3 dbName:String (optional) the db name
#
# @exitcode mysql command status code
Database::query() {
  local -n instanceQuery=$1
  local -a mysqlCommand=()
  local -a queryOptions

  mysqlCommand+=(mysql)
  mysqlCommand+=("--defaults-extra-file=${instanceQuery['AUTH_FILE']}")
  IFS=' ' read -r -a queryOptions <<<"${instanceQuery['QUERY_OPTIONS']}"
  mysqlCommand+=("${queryOptions[@]}")
  if [[ "${instanceQuery['SKIP_COLUMN_NAMES']}" = "1" ]]; then
    mysqlCommand+=("-s" "--skip-column-names")
  fi
  # add optional db name
  if [[ -n "${3+x}" ]]; then
    mysqlCommand+=("$3")
  fi
  # add optional sql query
  if [[ -n "${2+x}" && -n "$2" && ! -f "$2" ]]; then
    mysqlCommand+=("-e")
    mysqlCommand+=("$2")
  fi
  Log::displayDebug "$(printf "execute command: '%s'" "${mysqlCommand[*]}")"

  if [[ -f "$2" ]]; then
    "${mysqlCommand[@]}" <"$2"
  else
    "${mysqlCommand[@]}"
  fi
}

# @description set the general options to use on mysql command to query the database
# Differs than setOptions in the way that these options could change each time
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 optionsList:String query options list
Database::setQueryOptions() {
  local -n instanceSetQueryOptions=$1
  # shellcheck disable=SC2034
  instanceSetQueryOptions['QUERY_OPTIONS']="$2"
}

# @description by default we skip the column names
# but sometimes we need column names to display some results
# disable this option temporarily and then restore it to true
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 skipColumnNames:Boolean 0 to disable, 1 to enable (hide column names)
Database::skipColumnNames() {
  local -n instanceSkipColumnNames=$1
  # shellcheck disable=SC2034
  instanceSkipColumnNames['SKIP_COLUMN_NAMES']="$2"
}

# @description prepend directories to the PATH environment variable
# @arg $@ args:String[] list of directories to prepend
# @set PATH update PATH with the directories prepended
Env::pathPrepend() {
  local arg
  for arg in "$@"; do
    if [[ -d "${arg}" && ":${PATH}:" != *":${arg}:"* ]]; then
      PATH="$(realpath "${arg}"):${PATH}"
    fi
  done
}

# @description Display message using error color (red) and exit immediately with error status 1
# @arg $1 message:String the message to display
Log::fatal() {
  echo -e "${__ERROR_COLOR}FATAL   - ${1}${__RESET_COLOR}" >&2
  Log::logFatal "$1"
  exit 1
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logDebug() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_DEBUG)); then
    Log::logMessage "${2:-DEBUG}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logInfo() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-INFO}" "$1"
  fi
}

# @description ensure running user is not root
# @exitcode 1 if current user is root
# @stderr diagnostics information is displayed
Linux::requireExecutedAsUser() {
  if [[ "$(id -u)" = "0" ]]; then
    Log::fatal "this script should be executed as normal user"
  fi
}

# @description get absolute conf file from specified conf folder deduced using these rules
#   * from absolute file (ignores <confFolder> and <extension>)
#   * relative to where script is executed (ignores <confFolder> and <extension>)
#   * from home/.bash-tools/<confFolder>
#   * from framework conf/<confFolder>
#
# @arg $1 confFolder:String the directory name (not the path) to list
# @arg $2 conf:String file to use without extension
# @arg $3 extension:String the extension (.sh by default)
#
# @stdout absolute conf filename
# @exitcode 1 if file is not found in any location
Conf::getAbsoluteFile() {
  local confFolder="$1"
  local conf="$2"
  local extension="${3-.sh}"
  if [[ -n "${extension}" && "${extension:0:1}" != "." ]]; then
    extension=".${extension}"
  fi

  testAbs() {
    local result
    result="$(realpath -e "$1" 2>/dev/null)"
    # shellcheck disable=SC2181
    if [[ "$?" = "0" && -f "${result}" ]]; then
      echo "${result}"
      return 0
    fi
    return 1
  }

  # conf is absolute file (including extension)
  testAbs "${confFolder}${extension}" && return 0
  # conf is absolute file
  testAbs "${confFolder}" && return 0
  # conf is absolute file (including extension)
  testAbs "${conf}${extension}" && return 0
  # conf is absolute file
  testAbs "${conf}" && return 0

  # relative to where script is executed (including extension)
  if [[ -n "${CURRENT_DIR+xxx}" ]]; then
    testAbs "$(File::concatenatePath "${CURRENT_DIR}" "${confFolder}")/${conf}${extension}" && return 0
  fi
  # from home/.bash-tools/<confFolder>
  testAbs "$(File::concatenatePath "${HOME}/.bash-tools" "${confFolder}")/${conf}${extension}" && return 0

  if [[ -n "${FRAMEWORK_ROOT_DIR+xxx}" ]]; then
    # from framework conf/<confFolder> (including extension)
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}${extension}" && return 0

    # from framework conf/<confFolder>
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}" && return 0
  fi

  # file not found
  Log::displayError "conf file '${conf}' not found"

  return 1
}

# @description check if dsn file has all the mandatory variables set
# Mandatory variables are: HOSTNAME, USER, PASSWORD, PORT
#
# @arg $1 dsnFileName:String dsn absolute filename
# @set HOSTNAME loaded from dsn file
# @set PORT loaded from dsn file
# @set USER loaded from dsn file
# @set PASSWORD loaded from dsn file
# @exitcode 0 on valid file
# @exitcode 1 if one of the properties of the conf file is invalid or if file not found
# @stderr log output if error found in conf file
Database::checkDsnFile() {
  local dsnFileName="$1"
  if [[ ! -f "${dsnFileName}" ]]; then
    Log::displayError "dsn file ${dsnFileName} not found"
    return 1
  fi

  (
    unset HOSTNAME PORT PASSWORD USER
    # shellcheck source=/src/Database/testsData/dsn_valid.env
    source "${dsnFileName}"
    if [[ -z ${HOSTNAME+x} ]]; then
      Log::displayError "dsn file ${dsnFileName} : HOSTNAME not provided"
      return 1
    fi
    if [[ -z "${HOSTNAME}" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : HOSTNAME value not provided"
    fi
    if [[ "${HOSTNAME}" = "localhost" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : check that HOSTNAME should not be 127.0.0.1 instead of localhost"
    fi
    if [[ -z "${PORT+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT not provided"
      return 1
    fi
    if ! [[ ${PORT} =~ ^[0-9]+$ ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT invalid"
      return 1
    fi
    if [[ -z "${USER+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : USER not provided"
      return 1
    fi
    if [[ -z "${PASSWORD+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PASSWORD not provided"
      return 1
    fi
  )
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logFatal() {
  Log::logMessage "${2:-FATAL}" "$1"
}

# @description Internal: common log message
# @example text
#   [date]|[levelMsg]|message
#
# @example text
#   2020-01-19 19:20:21|ERROR  |log error
#   2020-01-19 19:20:21|SKIPPED|log skipped
#
# @arg $1 levelMsg:String message's level description (eg: STATUS, ERROR, ...)
# @arg $2 msg:String the message to display
# @env BASH_FRAMEWORK_LOG_FILE String log file to use, do nothing if empty
# @env BASH_FRAMEWORK_LOG_LEVEL int log level log only if > OFF or fatal messages
# @stderr diagnostics information is displayed
# @require Env::requireLoad
# @require Log::requireLoad
Log::logMessage() {
  local levelMsg="$1"
  local msg="$2"
  local date

  if [[ -n "${BASH_FRAMEWORK_LOG_FILE}" ]] && ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    date="$(date '+%Y-%m-%d %H:%M:%S')"
    touch "${BASH_FRAMEWORK_LOG_FILE}"
    printf "%s|%7s|%s\n" "${date}" "${levelMsg}" "${msg}" >>"${BASH_FRAMEWORK_LOG_FILE}"
  fi
}

# @description concatenate 2 paths and ensure the path is correct using realpath -m
# @arg $1 basePath:String
# @arg $2 subPath:String
# @require Linux::requireRealpathCommand
File::concatenatePath() {
  local basePath="$1"
  local subPath="$2"
  local fullPath="${basePath:+${basePath}/}${subPath}"

  realpath -m "${fullPath}" 2>/dev/null
}

# @description Display message using error color (red)
# @arg $1 message:String the message to display
Log::displayError() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_ERROR)); then
    echo -e "${__ERROR_COLOR}ERROR   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logError "$1"
}

# @description Display message using warning color (yellow)
# @arg $1 message:String the message to display
Log::displayWarning() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_WARNING)); then
    echo -e "${__WARNING_COLOR}WARN    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logWarning "$1"
}

# @description ensure env files are loaded
# @arg $@ list of default files to load at the end
# @exitcode 1 if one of env files fails to load
# @stderr diagnostics information is displayed
# shellcheck disable=SC2120
Env::requireLoad() {
  local -a defaultFiles=("$@")
  # get list of possible config files
  local -a configFiles=()
  if [[ -n "${BASH_FRAMEWORK_ENV_FILES[0]+1}" ]]; then
    # BASH_FRAMEWORK_ENV_FILES is an array
    configFiles+=("${BASH_FRAMEWORK_ENV_FILES[@]}")
  fi
  if [[ -f "$(pwd)/.framework-config" ]]; then
    configFiles+=("$(pwd)/.framework-config")
  fi
  if [[ -f "${FRAMEWORK_ROOT_DIR}/.framework-config" ]]; then
    configFiles+=("${FRAMEWORK_ROOT_DIR}/.framework-config")
  fi
  if [[ -n "${optionBashFrameworkConfig}" && -f "${optionBashFrameworkConfig}" ]]; then
    # shellcheck disable=SC2034
    configFiles+=("${optionBashFrameworkConfig}")
  fi
  configFiles+=("${optionEnvFiles[@]}")
  configFiles+=("${defaultFiles[@]}")

  for file in "${configFiles[@]}"; do
    # shellcheck source=/.framework-config
    CURRENT_LOADED_ENV_FILE="${file}" source "${file}" || {
      Log::displayError "while loading config file: ${file}"
      return 1
    }
  done
}

# @description activate or not Log::display* and Log::log* functions
# based on BASH_FRAMEWORK_DISPLAY_LEVEL and BASH_FRAMEWORK_LOG_LEVEL
# environment variables loaded by Env::requireLoad
# try to create log file and rotate it if necessary
# @noargs
# @set BASH_FRAMEWORK_LOG_LEVEL int to OFF level if BASH_FRAMEWORK_LOG_FILE is empty or not writable
# @env BASH_FRAMEWORK_DISPLAY_LEVEL int
# @env BASH_FRAMEWORK_LOG_LEVEL int
# @env BASH_FRAMEWORK_LOG_FILE String
# @env BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION int do log rotation if > 0
# @exitcode 0 always successful
# @stderr diagnostics information about log file is displayed
# @require Env::requireLoad
# @require UI::requireTheme
Log::requireLoad() {
  if [[ -z "${BASH_FRAMEWORK_LOG_FILE:-}" ]]; then
    BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
    export BASH_FRAMEWORK_LOG_LEVEL
  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    if [[ ! -f "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      if
        ! mkdir -p "$(dirname "${BASH_FRAMEWORK_LOG_FILE}")" 2>/dev/null ||
          ! touch --no-create "${BASH_FRAMEWORK_LOG_FILE}" 2>/dev/null
      then
        BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
        echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
      fi
    elif [[ ! -w "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
      echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
    fi

  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    # will always be created even if not in info level
    Log::logMessage "INFO" "Logging to file ${BASH_FRAMEWORK_LOG_FILE} - Log level ${BASH_FRAMEWORK_LOG_LEVEL}"
    if ((BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION > 0)); then
      Log::rotate "${BASH_FRAMEWORK_LOG_FILE}" "${BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION}"
    fi
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logError() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_ERROR)); then
    Log::logMessage "${2:-ERROR}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logWarning() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_WARNING)); then
    Log::logMessage "${2:-WARNING}" "$1"
  fi
}

# @description To be called before logging in the log file
# @arg $1 file:string log file name
# @arg $2 maxLogFilesCount:int maximum number of log files
Log::rotate() {
  local file="$1"
  local maxLogFilesCount="${2:-5}"

  if [[ ! -f "${file}" ]]; then
    Log::displaySkipped "Log file ${file} doesn't exist yet"
    return 0
  fi
  for i in $(seq $((maxLogFilesCount - 1)) -1 1); do
    Log::displayInfo "Log rotation ${file}.${i} to ${file}.$((i + 1))"
    mv "${file}."{"${i}","$((i + 1))"} &>/dev/null || true
  done
  if cp "${file}" "${file}.1" &>/dev/null; then
    echo >"${file}" # reset log file
    Log::displayInfo "Log rotation ${file} to ${file}.1"
  fi
}

# @description ensure command realpath is available
# @exitcode 1 if realpath command not available
# @stderr diagnostics information is displayed
Linux::requireRealpathCommand() {
  Assert::commandExists realpath
}

# @description load color theme
# @noargs
# @env BASH_FRAMEWORK_THEME String theme to use
# @exitcode 0 always successful
UI::requireTheme() {
  UI::theme "${BASH_FRAMEWORK_THEME-default}"
}

# @description check if command specified exists or return 1
# with error and message if not
#
# @arg $1 commandName:String on which existence must be checked
# @arg $2 helpIfNotExists:String a help command to display if the command does not exist
#
# @exitcode 1 if the command specified does not exist
# @stderr diagnostic information + help if second argument is provided
Assert::commandExists() {
  local commandName="$1"
  local helpIfNotExists="$2"

  "${BASH_FRAMEWORK_COMMAND:-command}" -v "${commandName}" >/dev/null 2>/dev/null || {
    Log::displayError "${commandName} is not installed, please install it"
    if [[ -n "${helpIfNotExists}" ]]; then
      Log::displayInfo "${helpIfNotExists}"
    fi
    return 1
  }
  return 0
}

# @description Display message using skip color (yellow)
# @arg $1 message:String the message to display
Log::displaySkipped() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__SKIPPED_COLOR}SKIPPED - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logSkipped "$1"
}

# @description load colors theme constants
# @warning if tty not opened, noColor theme will be chosen
# @arg $1 theme:String the theme to use (default, noColor)
# @arg $@ args:String[]
# @set __ERROR_COLOR String indicate error status
# @set __INFO_COLOR String indicate info status
# @set __SUCCESS_COLOR String indicate success status
# @set __WARNING_COLOR String indicate warning status
# @set __SKIPPED_COLOR String indicate skipped status
# @set __DEBUG_COLOR String indicate debug status
# @set __HELP_COLOR String indicate help status
# @set __TEST_COLOR String not used
# @set __TEST_ERROR_COLOR String not used
# @set __HELP_TITLE_COLOR String used to display help title in help strings
# @set __HELP_OPTION_COLOR String used to display highlight options in help strings
#
# @set __RESET_COLOR String reset default color
#
# @set __HELP_EXAMPLE String to remove
# @set __HELP_TITLE String to remove
# @set __HELP_NORMAL String to remove
# shellcheck disable=SC2034
UI::theme() {
  local theme="${1-default}"
  if [[ ! "${theme}" =~ -force$ ]] && ! Assert::tty; then
    theme="noColor"
  fi
  case "${theme}" in
    default | default-force)
      theme="default"
      ;;
    noColor) ;;
    *)
      Log::fatal "invalid theme provided"
      ;;
  esac
  if [[ "${theme}" = "default" ]]; then
    BASH_FRAMEWORK_THEME="default"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR='\e[31m'         # Red
    __INFO_COLOR='\e[44m'          # white on lightBlue
    __SUCCESS_COLOR='\e[32m'       # Green
    __WARNING_COLOR='\e[33m'       # Yellow
    __SKIPPED_COLOR='\e[33m'       # Yellow
    __DEBUG_COLOR='\e[37m'         # Grey
    __HELP_COLOR='\e[7;49;33m'     # Black on Gold
    __TEST_COLOR='\e[100m'         # Light magenta
    __TEST_ERROR_COLOR='\e[41m'    # white on red
    __HELP_TITLE_COLOR="\e[1;37m"  # Bold
    __HELP_OPTION_COLOR="\e[1;34m" # Blue
    # Internal: reset color
    __RESET_COLOR='\e[0m' # Reset Color
    # shellcheck disable=SC2155,SC2034
    __HELP_EXAMPLE="$(echo -e "\e[2;97m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_TITLE="$(echo -e "\e[1;37m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_NORMAL="$(echo -e "\033[0m")"
  else
    BASH_FRAMEWORK_THEME="noColor"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR=''
    __INFO_COLOR=''
    __SUCCESS_COLOR=''
    __WARNING_COLOR=''
    __SKIPPED_COLOR=''
    __DEBUG_COLOR=''
    __HELP_COLOR=''
    __TEST_COLOR=''
    __TEST_ERROR_COLOR=''
    __HELP_TITLE_COLOR=''
    __HELP_OPTION_COLOR=''
    # Internal: reset color
    __RESET_COLOR=''
    __HELP_EXAMPLE=''
    __HELP_TITLE=''
    __HELP_NORMAL=''
  fi
}

# @description check if tty (interactive mode) is active
# @noargs
# @exitcode 1 if tty not active
# @env NON_INTERACTIVE if 1 consider as not interactive even if environment is interactive
# @env INTERACTIVE if 1 consider as interactive even if environment is not interactive
# @stderr diagnostic information + help if second argument is provided
Assert::tty() {
  if [[ "${NON_INTERACTIVE:-0}" = "1" ]]; then
    return 1
  fi
  if [[ "${INTERACTIVE:-0}" = "1" ]]; then
    return 0
  fi
  [[ -t 1 || -t 2 ]]
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logSkipped() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-SKIPPED}" "$1"
  fi
}

# FUNCTIONS

facade_main_embedFrameworkFunctionbinFiletpl() {
# REQUIRES
Linux::requireExecutedAsUser
Env::requireLoad
Log::requireLoad
Linux::requireRealpathCommand
UI::requireTheme
Compiler::Facade::requireCommandBinDir

# @require Compiler::Facade::requireCommandBinDir

# shellcheck disable=SC2154,SC2016
functionToCall='Db::queryOneDatabase'
"${functionToCall}" "$@"

}

facade_main_embedFrameworkFunctionbinFiletpl "$@"
" Compiler::Embed::extractFileFromBase64 \ "${embed_function_DbQueryOneDatabase}" \ diff --git a/bin/dbScriptAllDatabases b/bin/dbScriptAllDatabases index 1806bdf0..bc6ddc93 100755 --- a/bin/dbScriptAllDatabases +++ b/bin/dbScriptAllDatabases @@ -1014,8 +1014,8 @@ Log::logSkipped() { # @require Compiler::Embed::requireEmbedBinDir -declare -gx embed_function_DbQueryOneDatabase="${PERSISTENT_TMPDIR:-/tmp}/bin/c6442837509215243421aff83f20328b/dbQueryOneDatabase" -declare -gx encoded_binary_file_DbQueryOneDatabase="#!/usr/bin/env bash
###############################################################################
# GENERATED FACADE FROM https://github.com/fchastanet/bash-tools/tree/master/../bash-dev-env/vendor/bash-tools-framework/src/Compiler/Embed/embedFrameworkFunction.binFile.tpl
# DO NOT EDIT IT
# @generated
###############################################################################
# shellcheck disable=SC2288,SC2034
# BIN_FILE=${BIN_FILE}
# FACADE

# ensure that no user aliases could interfere with
# commands used in this script
unalias -a || true
shopt -u expand_aliases

# shellcheck disable=SC2034
((failures = 0)) || true

# Bash will remember & return the highest exit code in a chain of pipes.
# This way you can catch the error inside pipes, e.g. mysqldump | gzip
set -o pipefail
set -o errexit

# Command Substitution can inherit errexit option since bash v4.4
shopt -s inherit_errexit || true

# a log is generated when a command fails
set -o errtrace

# use nullglob so that (file*.php) will return an empty array if no file matches the wildcard
shopt -s nullglob

# ensure regexp are interpreted without accentuated characters
export LC_ALL=POSIX

export TERM=xterm-256color

# avoid interactive install
export DEBIAN_FRONTEND=noninteractive
export DEBCONF_NONINTERACTIVE_SEEN=true

# store command arguments for later usage
# shellcheck disable=SC2034
declare -a BASH_FRAMEWORK_ARGV=("$@")
# shellcheck disable=SC2034
declare -a ORIGINAL_BASH_FRAMEWORK_ARGV=("$@")

# @see https://unix.stackexchange.com/a/386856
# shellcheck disable=SC2317
interruptManagement() {
  # restore SIGINT handler
  trap - INT
  # ensure that Ctrl-C is trapped by this script and not by sub process
  # report to the parent that we have indeed been interrupted
  kill -s INT "$$"
}
trap interruptManagement INT
SCRIPT_NAME=${0##*/}
REAL_SCRIPT_FILE="$(readlink -e "$(realpath "${BASH_SOURCE[0]}")")"
if [[ -n "${EMBED_CURRENT_DIR}" ]]; then
  CURRENT_DIR="${EMBED_CURRENT_DIR}"
else
  CURRENT_DIR="$(cd "$(readlink -e "${REAL_SCRIPT_FILE%/*}")" && pwd -P)"
fi

################################################
# Temp dir management
################################################

KEEP_TEMP_FILES="${KEEP_TEMP_FILES:-0}"
export KEEP_TEMP_FILES

# PERSISTENT_TMPDIR is not deleted by traps
PERSISTENT_TMPDIR="${TMPDIR:-/tmp}/bash-framework"
export PERSISTENT_TMPDIR
mkdir -p "${PERSISTENT_TMPDIR}"

# shellcheck disable=SC2034
TMPDIR="$(mktemp -d -p "${PERSISTENT_TMPDIR:-/tmp}" -t bash-framework-$$-XXXXXX)"
export TMPDIR

# temp dir cleaning
# shellcheck disable=SC2317
cleanOnExit() {
  if [[ "${KEEP_TEMP_FILES:-0}" = "1" ]]; then
    Log::displayInfo "KEEP_TEMP_FILES=1 temp files kept here '${TMPDIR}'"
  elif [[ -n "${TMPDIR+xxx}" ]]; then
    Log::displayDebug "KEEP_TEMP_FILES=0 removing temp files '${TMPDIR}'"
    rm -Rf "${TMPDIR:-/tmp/fake}" >/dev/null 2>&1
  fi
}
trap cleanOnExit EXIT HUP QUIT ABRT TERM

# VAR_MAIN_FUNCTION_VAR_NAME=dbQueryAllDatabasesFacade

# @description used to execute given query when using
# dbScriptAllDatabases
# @arg $1 dsn:String
# @arg $2 db:String
# @env query String
# @env optionSeparator String
# @require Linux::requireExecutedAsUser
Db::queryOneDatabase() {
  # query and optionSeparator are passed via export
  local dsn="$1"
  local db="$2"

  local -A dbInstance
  Database::newInstance dbInstance "${dsn}"
  Database::setQueryOptions dbInstance "${dbInstance[QUERY_OPTIONS]} --connect-timeout=5"

  # identify columns header
  echo -n "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
  Database::skipColumnNames dbInstance 0

  # shellcheck disable=SC2154
  if ! Database::query dbInstance "${query}" "${db}" | sed "s/\t/${optionSeparator}/g"; then
    Log::fatal "database ${db} error" 1>&2
  fi
}

# @description Log namespace provides 2 kind of functions
# - Log::display* allows to display given message with
#   given display level
# - Log::log* allows to log given message with
#   given log level
# Log::display* functions automatically log the message too
# @see Env::requireLoad to load the display and log level from .env file

# @description log level off
export __LEVEL_OFF=0
# @description log level error
export __LEVEL_ERROR=1
# @description log level warning
export __LEVEL_WARNING=2
# @description log level info
export __LEVEL_INFO=3
# @description log level success
export __LEVEL_SUCCESS=3
# @description log level debug
export __LEVEL_DEBUG=4

# @description verbose level off
export __VERBOSE_LEVEL_OFF=0
# @description verbose level info
export __VERBOSE_LEVEL_INFO=1
# @description verbose level info
export __VERBOSE_LEVEL_DEBUG=2
# @description verbose level info
export __VERBOSE_LEVEL_TRACE=3

# @description Display message using debug color (grey)
# @arg $1 message:String the message to display
Log::displayDebug() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_DEBUG)); then
    echo -e "${__DEBUG_COLOR}DEBUG   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logDebug "$1"
}

# @description Display message using info color (bg light blue/fg white)
# @arg $1 message:String the message to display
Log::displayInfo() {
  local type="${2:-INFO}"
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__INFO_COLOR}${type}    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logInfo "$1" "${type}"
}

# @description ensure COMMAND_BIN_DIR env var is set
# and PATH correctly prepared
# @noargs
# @set COMMAND_BIN_DIR string the directory where to find this command
# @set PATH string add directory where to find this command binary
Compiler::Facade::requireCommandBinDir() {
  COMMAND_BIN_DIR="${CURRENT_DIR}"
  Env::pathPrepend "${COMMAND_BIN_DIR}"
}

# @description create a new db instance
# Returns immediately if the instance is already initialized
#
# @arg $1 instanceNewInstance:&Map<String,String> (passed by reference) database instance to use
# @arg $2 dsn:String dsn profile - load the dsn.env profile deduced using rules defined in Conf::getAbsoluteFile
#
# @example
#   declare -Agx dbInstance
#   Database::newInstance dbInstance "default.local"
#
# @exitcode 1 if dns file not able to loaded
Database::newInstance() {
  local -n instanceNewInstance=$1
  local dsn="$2"
  local DSN_FILE

  if [[ -v instanceNewInstance['INITIALIZED'] && "${instanceNewInstance['INITIALIZED']:-0}" == "1" ]]; then
    return
  fi

  # final auth file generated from dns file
  instanceNewInstance['AUTH_FILE']=""
  instanceNewInstance['DSN_FILE']=""

  # check dsn file
  DSN_FILE="$(Conf::getAbsoluteFile "dsn" "${dsn}" "env")" || return 1
  Database::checkDsnFile "${DSN_FILE}" || return 1
  instanceNewInstance['DSN_FILE']="${DSN_FILE}"

  # shellcheck source=/src/Database/testsData/dsn_valid.env
  source "${instanceNewInstance['DSN_FILE']}"

  instanceNewInstance['USER']="${USER}"
  instanceNewInstance['PASSWORD']="${PASSWORD}"
  instanceNewInstance['HOSTNAME']="${HOSTNAME}"
  instanceNewInstance['PORT']="${PORT}"

  # generate authFile for easy authentication
  instanceNewInstance['AUTH_FILE']=$(mktemp -p "${TMPDIR:-/tmp}" -t "mysql.XXXXXXXXXXXX")
  (
    echo "[client]"
    echo "user = ${USER}"
    echo "password = ${PASSWORD}"
    echo "host = ${HOSTNAME}"
    echo "port = ${PORT}"
  ) >"${instanceNewInstance['AUTH_FILE']}"

  # some of those values can be overridden using the dsn file
  # SKIP_COLUMN_NAMES enabled by default
  instanceNewInstance['SKIP_COLUMN_NAMES']="${SKIP_COLUMN_NAMES:-1}"
  instanceNewInstance['SSL_OPTIONS']="${MYSQL_SSL_OPTIONS:---ssl-mode=DISABLED}"
  instanceNewInstance['QUERY_OPTIONS']="${MYSQL_QUERY_OPTIONS:---batch --raw --default-character-set=utf8}"
  instanceNewInstance['DUMP_OPTIONS']="${MYSQL_DUMP_OPTIONS:---default-character-set=utf8 --compress --hex-blob --routines --triggers --single-transaction --set-gtid-purged=OFF --column-statistics=0 ${instanceNewInstance['SSL_OPTIONS']}}"
  instanceNewInstance['DB_IMPORT_OPTIONS']="${DB_IMPORT_OPTIONS:---connect-timeout=5 --batch --raw --default-character-set=utf8}"

  instanceNewInstance['INITIALIZED']=1
}

# @description mysql query on a given db
# @warning could use QUERY_OPTIONS variable from dsn if defined
# @example
#   cat file.sql | Database::query ...
# @arg $1 instanceQuery:&Map<String,String> (passed by reference) database instance to use
# @arg $2 sqlQuery:String (optional) sql query or sql file to execute. if not provided or empty, the command can be piped
# @arg $3 dbName:String (optional) the db name
#
# @exitcode mysql command status code
Database::query() {
  local -n instanceQuery=$1
  local -a mysqlCommand=()
  local -a queryOptions

  mysqlCommand+=(mysql)
  mysqlCommand+=("--defaults-extra-file=${instanceQuery['AUTH_FILE']}")
  IFS=' ' read -r -a queryOptions <<<"${instanceQuery['QUERY_OPTIONS']}"
  mysqlCommand+=("${queryOptions[@]}")
  if [[ "${instanceQuery['SKIP_COLUMN_NAMES']}" = "1" ]]; then
    mysqlCommand+=("-s" "--skip-column-names")
  fi
  # add optional db name
  if [[ -n "${3+x}" ]]; then
    mysqlCommand+=("$3")
  fi
  # add optional sql query
  if [[ -n "${2+x}" && -n "$2" && ! -f "$2" ]]; then
    mysqlCommand+=("-e")
    mysqlCommand+=("$2")
  fi
  Log::displayDebug "$(printf "execute command: '%s'" "${mysqlCommand[*]}")"

  if [[ -f "$2" ]]; then
    "${mysqlCommand[@]}" <"$2"
  else
    "${mysqlCommand[@]}"
  fi
}

# @description set the general options to use on mysql command to query the database
# Differs than setOptions in the way that these options could change each time
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 optionsList:String query options list
Database::setQueryOptions() {
  local -n instanceSetQueryOptions=$1
  # shellcheck disable=SC2034
  instanceSetQueryOptions['QUERY_OPTIONS']="$2"
}

# @description by default we skip the column names
# but sometimes we need column names to display some results
# disable this option temporarily and then restore it to true
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 skipColumnNames:Boolean 0 to disable, 1 to enable (hide column names)
Database::skipColumnNames() {
  local -n instanceSkipColumnNames=$1
  # shellcheck disable=SC2034
  instanceSkipColumnNames['SKIP_COLUMN_NAMES']="$2"
}

# @description prepend directories to the PATH environment variable
# @arg $@ args:String[] list of directories to prepend
# @set PATH update PATH with the directories prepended
Env::pathPrepend() {
  local arg
  for arg in "$@"; do
    if [[ -d "${arg}" && ":${PATH}:" != *":${arg}:"* ]]; then
      PATH="$(realpath "${arg}"):${PATH}"
    fi
  done
}

# @description Display message using error color (red) and exit immediately with error status 1
# @arg $1 message:String the message to display
Log::fatal() {
  echo -e "${__ERROR_COLOR}FATAL   - ${1}${__RESET_COLOR}" >&2
  Log::logFatal "$1"
  exit 1
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logDebug() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_DEBUG)); then
    Log::logMessage "${2:-DEBUG}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logInfo() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-INFO}" "$1"
  fi
}

# @description ensure running user is not root
# @exitcode 1 if current user is root
# @stderr diagnostics information is displayed
Linux::requireExecutedAsUser() {
  if [[ "$(id -u)" = "0" ]]; then
    Log::fatal "this script should be executed as normal user"
  fi
}

# @description get absolute conf file from specified conf folder deduced using these rules
#   * from absolute file (ignores <confFolder> and <extension>)
#   * relative to where script is executed (ignores <confFolder> and <extension>)
#   * from home/.bash-tools/<confFolder>
#   * from framework conf/<confFolder>
#
# @arg $1 confFolder:String the directory name (not the path) to list
# @arg $2 conf:String file to use without extension
# @arg $3 extension:String the extension (.sh by default)
#
# @stdout absolute conf filename
# @exitcode 1 if file is not found in any location
Conf::getAbsoluteFile() {
  local confFolder="$1"
  local conf="$2"
  local extension="${3-.sh}"
  if [[ -n "${extension}" && "${extension:0:1}" != "." ]]; then
    extension=".${extension}"
  fi

  testAbs() {
    local result
    result="$(realpath -e "$1" 2>/dev/null)"
    # shellcheck disable=SC2181
    if [[ "$?" = "0" && -f "${result}" ]]; then
      echo "${result}"
      return 0
    fi
    return 1
  }

  # conf is absolute file (including extension)
  testAbs "${confFolder}${extension}" && return 0
  # conf is absolute file
  testAbs "${confFolder}" && return 0
  # conf is absolute file (including extension)
  testAbs "${conf}${extension}" && return 0
  # conf is absolute file
  testAbs "${conf}" && return 0

  # relative to where script is executed (including extension)
  if [[ -n "${CURRENT_DIR+xxx}" ]]; then
    testAbs "$(File::concatenatePath "${CURRENT_DIR}" "${confFolder}")/${conf}${extension}" && return 0
  fi
  # from home/.bash-tools/<confFolder>
  testAbs "$(File::concatenatePath "${HOME}/.bash-tools" "${confFolder}")/${conf}${extension}" && return 0

  if [[ -n "${FRAMEWORK_ROOT_DIR+xxx}" ]]; then
    # from framework conf/<confFolder> (including extension)
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}${extension}" && return 0

    # from framework conf/<confFolder>
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}" && return 0
  fi

  # file not found
  Log::displayError "conf file '${conf}' not found"

  return 1
}

# @description check if dsn file has all the mandatory variables set
# Mandatory variables are: HOSTNAME, USER, PASSWORD, PORT
#
# @arg $1 dsnFileName:String dsn absolute filename
# @set HOSTNAME loaded from dsn file
# @set PORT loaded from dsn file
# @set USER loaded from dsn file
# @set PASSWORD loaded from dsn file
# @exitcode 0 on valid file
# @exitcode 1 if one of the properties of the conf file is invalid or if file not found
# @stderr log output if error found in conf file
Database::checkDsnFile() {
  local dsnFileName="$1"
  if [[ ! -f "${dsnFileName}" ]]; then
    Log::displayError "dsn file ${dsnFileName} not found"
    return 1
  fi

  (
    unset HOSTNAME PORT PASSWORD USER
    # shellcheck source=/src/Database/testsData/dsn_valid.env
    source "${dsnFileName}"
    if [[ -z ${HOSTNAME+x} ]]; then
      Log::displayError "dsn file ${dsnFileName} : HOSTNAME not provided"
      return 1
    fi
    if [[ -z "${HOSTNAME}" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : HOSTNAME value not provided"
    fi
    if [[ "${HOSTNAME}" = "localhost" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : check that HOSTNAME should not be 127.0.0.1 instead of localhost"
    fi
    if [[ -z "${PORT+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT not provided"
      return 1
    fi
    if ! [[ ${PORT} =~ ^[0-9]+$ ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT invalid"
      return 1
    fi
    if [[ -z "${USER+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : USER not provided"
      return 1
    fi
    if [[ -z "${PASSWORD+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PASSWORD not provided"
      return 1
    fi
  )
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logFatal() {
  Log::logMessage "${2:-FATAL}" "$1"
}

# @description Internal: common log message
# @example text
#   [date]|[levelMsg]|message
#
# @example text
#   2020-01-19 19:20:21|ERROR  |log error
#   2020-01-19 19:20:21|SKIPPED|log skipped
#
# @arg $1 levelMsg:String message's level description (eg: STATUS, ERROR, ...)
# @arg $2 msg:String the message to display
# @env BASH_FRAMEWORK_LOG_FILE String log file to use, do nothing if empty
# @env BASH_FRAMEWORK_LOG_LEVEL int log level log only if > OFF or fatal messages
# @stderr diagnostics information is displayed
# @require Env::requireLoad
# @require Log::requireLoad
Log::logMessage() {
  local levelMsg="$1"
  local msg="$2"
  local date

  if [[ -n "${BASH_FRAMEWORK_LOG_FILE}" ]] && ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    date="$(date '+%Y-%m-%d %H:%M:%S')"
    touch "${BASH_FRAMEWORK_LOG_FILE}"
    printf "%s|%7s|%s\n" "${date}" "${levelMsg}" "${msg}" >>"${BASH_FRAMEWORK_LOG_FILE}"
  fi
}

# @description concatenate 2 paths and ensure the path is correct using realpath -m
# @arg $1 basePath:String
# @arg $2 subPath:String
# @require Linux::requireRealpathCommand
File::concatenatePath() {
  local basePath="$1"
  local subPath="$2"
  local fullPath="${basePath:+${basePath}/}${subPath}"

  realpath -m "${fullPath}" 2>/dev/null
}

# @description Display message using error color (red)
# @arg $1 message:String the message to display
Log::displayError() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_ERROR)); then
    echo -e "${__ERROR_COLOR}ERROR   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logError "$1"
}

# @description Display message using warning color (yellow)
# @arg $1 message:String the message to display
Log::displayWarning() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_WARNING)); then
    echo -e "${__WARNING_COLOR}WARN    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logWarning "$1"
}

# @description ensure env files are loaded
# @arg $@ list of default files to load at the end
# @exitcode 1 if one of env files fails to load
# @stderr diagnostics information is displayed
# shellcheck disable=SC2120
Env::requireLoad() {
  local -a defaultFiles=("$@")
  # get list of possible config files
  local -a configFiles=()
  if [[ -n "${BASH_FRAMEWORK_ENV_FILES[0]+1}" ]]; then
    # BASH_FRAMEWORK_ENV_FILES is an array
    configFiles+=("${BASH_FRAMEWORK_ENV_FILES[@]}")
  fi
  if [[ -f "$(pwd)/.framework-config" ]]; then
    configFiles+=("$(pwd)/.framework-config")
  fi
  if [[ -f "${FRAMEWORK_ROOT_DIR}/.framework-config" ]]; then
    configFiles+=("${FRAMEWORK_ROOT_DIR}/.framework-config")
  fi
  if [[ -n "${optionBashFrameworkConfig}" && -f "${optionBashFrameworkConfig}" ]]; then
    # shellcheck disable=SC2034
    configFiles+=("${optionBashFrameworkConfig}")
  fi
  configFiles+=("${optionEnvFiles[@]}")
  configFiles+=("${defaultFiles[@]}")

  for file in "${configFiles[@]}"; do
    # shellcheck source=/.framework-config
    CURRENT_LOADED_ENV_FILE="${file}" source "${file}" || {
      Log::displayError "while loading config file: ${file}"
      return 1
    }
  done
}

# @description activate or not Log::display* and Log::log* functions
# based on BASH_FRAMEWORK_DISPLAY_LEVEL and BASH_FRAMEWORK_LOG_LEVEL
# environment variables loaded by Env::requireLoad
# try to create log file and rotate it if necessary
# @noargs
# @set BASH_FRAMEWORK_LOG_LEVEL int to OFF level if BASH_FRAMEWORK_LOG_FILE is empty or not writable
# @env BASH_FRAMEWORK_DISPLAY_LEVEL int
# @env BASH_FRAMEWORK_LOG_LEVEL int
# @env BASH_FRAMEWORK_LOG_FILE String
# @env BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION int do log rotation if > 0
# @exitcode 0 always successful
# @stderr diagnostics information about log file is displayed
# @require Env::requireLoad
# @require UI::requireTheme
Log::requireLoad() {
  if [[ -z "${BASH_FRAMEWORK_LOG_FILE:-}" ]]; then
    BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
    export BASH_FRAMEWORK_LOG_LEVEL
  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    if [[ ! -f "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      if
        ! mkdir -p "$(dirname "${BASH_FRAMEWORK_LOG_FILE}")" 2>/dev/null ||
          ! touch --no-create "${BASH_FRAMEWORK_LOG_FILE}" 2>/dev/null
      then
        BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
        echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
      fi
    elif [[ ! -w "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
      echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
    fi

  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    # will always be created even if not in info level
    Log::logMessage "INFO" "Logging to file ${BASH_FRAMEWORK_LOG_FILE} - Log level ${BASH_FRAMEWORK_LOG_LEVEL}"
    if ((BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION > 0)); then
      Log::rotate "${BASH_FRAMEWORK_LOG_FILE}" "${BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION}"
    fi
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logError() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_ERROR)); then
    Log::logMessage "${2:-ERROR}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logWarning() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_WARNING)); then
    Log::logMessage "${2:-WARNING}" "$1"
  fi
}

# @description To be called before logging in the log file
# @arg $1 file:string log file name
# @arg $2 maxLogFilesCount:int maximum number of log files
Log::rotate() {
  local file="$1"
  local maxLogFilesCount="${2:-5}"

  if [[ ! -f "${file}" ]]; then
    Log::displaySkipped "Log file ${file} doesn't exist yet"
    return 0
  fi
  for i in $(seq $((maxLogFilesCount - 1)) -1 1); do
    Log::displayInfo "Log rotation ${file}.${i} to ${file}.$((i + 1))"
    mv "${file}."{"${i}","$((i + 1))"} &>/dev/null || true
  done
  if cp "${file}" "${file}.1" &>/dev/null; then
    echo >"${file}" # reset log file
    Log::displayInfo "Log rotation ${file} to ${file}.1"
  fi
}

# @description ensure command realpath is available
# @exitcode 1 if realpath command not available
# @stderr diagnostics information is displayed
Linux::requireRealpathCommand() {
  Assert::commandExists realpath
}

# @description load color theme
# @noargs
# @env BASH_FRAMEWORK_THEME String theme to use
# @exitcode 0 always successful
UI::requireTheme() {
  UI::theme "${BASH_FRAMEWORK_THEME-default}"
}

# @description check if command specified exists or return 1
# with error and message if not
#
# @arg $1 commandName:String on which existence must be checked
# @arg $2 helpIfNotExists:String a help command to display if the command does not exist
#
# @exitcode 1 if the command specified does not exist
# @stderr diagnostic information + help if second argument is provided
Assert::commandExists() {
  local commandName="$1"
  local helpIfNotExists="$2"

  "${BASH_FRAMEWORK_COMMAND:-command}" -v "${commandName}" >/dev/null 2>/dev/null || {
    Log::displayError "${commandName} is not installed, please install it"
    if [[ -n "${helpIfNotExists}" ]]; then
      Log::displayInfo "${helpIfNotExists}"
    fi
    return 1
  }
  return 0
}

# @description Display message using skip color (yellow)
# @arg $1 message:String the message to display
Log::displaySkipped() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__SKIPPED_COLOR}SKIPPED - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logSkipped "$1"
}

# @description load colors theme constants
# @warning if tty not opened, noColor theme will be chosen
# @arg $1 theme:String the theme to use (default, noColor)
# @arg $@ args:String[]
# @set __ERROR_COLOR String indicate error status
# @set __INFO_COLOR String indicate info status
# @set __SUCCESS_COLOR String indicate success status
# @set __WARNING_COLOR String indicate warning status
# @set __SKIPPED_COLOR String indicate skipped status
# @set __DEBUG_COLOR String indicate debug status
# @set __HELP_COLOR String indicate help status
# @set __TEST_COLOR String not used
# @set __TEST_ERROR_COLOR String not used
# @set __HELP_TITLE_COLOR String used to display help title in help strings
# @set __HELP_OPTION_COLOR String used to display highlight options in help strings
#
# @set __RESET_COLOR String reset default color
#
# @set __HELP_EXAMPLE String to remove
# @set __HELP_TITLE String to remove
# @set __HELP_NORMAL String to remove
# shellcheck disable=SC2034
UI::theme() {
  local theme="${1-default}"
  if [[ ! "${theme}" =~ -force$ ]] && ! Assert::tty; then
    theme="noColor"
  fi
  case "${theme}" in
    default | default-force)
      theme="default"
      ;;
    noColor) ;;
    *)
      Log::fatal "invalid theme provided"
      ;;
  esac
  if [[ "${theme}" = "default" ]]; then
    BASH_FRAMEWORK_THEME="default"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR='\e[31m'         # Red
    __INFO_COLOR='\e[44m'          # white on lightBlue
    __SUCCESS_COLOR='\e[32m'       # Green
    __WARNING_COLOR='\e[33m'       # Yellow
    __SKIPPED_COLOR='\e[33m'       # Yellow
    __DEBUG_COLOR='\e[37m'         # Grey
    __HELP_COLOR='\e[7;49;33m'     # Black on Gold
    __TEST_COLOR='\e[100m'         # Light magenta
    __TEST_ERROR_COLOR='\e[41m'    # white on red
    __HELP_TITLE_COLOR="\e[1;37m"  # Bold
    __HELP_OPTION_COLOR="\e[1;34m" # Blue
    # Internal: reset color
    __RESET_COLOR='\e[0m' # Reset Color
    # shellcheck disable=SC2155,SC2034
    __HELP_EXAMPLE="$(echo -e "\e[2;97m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_TITLE="$(echo -e "\e[1;37m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_NORMAL="$(echo -e "\033[0m")"
  else
    BASH_FRAMEWORK_THEME="noColor"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR=''
    __INFO_COLOR=''
    __SUCCESS_COLOR=''
    __WARNING_COLOR=''
    __SKIPPED_COLOR=''
    __DEBUG_COLOR=''
    __HELP_COLOR=''
    __TEST_COLOR=''
    __TEST_ERROR_COLOR=''
    __HELP_TITLE_COLOR=''
    __HELP_OPTION_COLOR=''
    # Internal: reset color
    __RESET_COLOR=''
    __HELP_EXAMPLE=''
    __HELP_TITLE=''
    __HELP_NORMAL=''
  fi
}

# @description check if tty (interactive mode) is active
# @noargs
# @exitcode 1 if tty not active
# @env NON_INTERACTIVE if 1 consider as not interactive even if environment is interactive
# @env INTERACTIVE if 1 consider as interactive even if environment is not interactive
# @stderr diagnostic information + help if second argument is provided
Assert::tty() {
  if [[ "${NON_INTERACTIVE:-0}" = "1" ]]; then
    return 1
  fi
  if [[ "${INTERACTIVE:-0}" = "1" ]]; then
    return 0
  fi
  [[ -t 1 || -t 2 ]]
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logSkipped() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-SKIPPED}" "$1"
  fi
}

# FUNCTIONS

facade_main_embedFrameworkFunctionbinFiletpl() {
# REQUIRES
Linux::requireExecutedAsUser
Env::requireLoad
Log::requireLoad
Linux::requireRealpathCommand
UI::requireTheme
Compiler::Facade::requireCommandBinDir

# @require Compiler::Facade::requireCommandBinDir

# shellcheck disable=SC2154,SC2016
functionToCall='Db::queryOneDatabase'
"${functionToCall}" "$@"

}

facade_main_embedFrameworkFunctionbinFiletpl "$@"
" +declare -gx embed_function_DbQueryOneDatabase="${PERSISTENT_TMPDIR:-/tmp}/bin/4199f1403a7b340c22de7a6b0fda71a8/dbQueryOneDatabase" +declare -gx encoded_binary_file_DbQueryOneDatabase="#!/usr/bin/env bash
###############################################################################
# GENERATED FACADE FROM https://github.com/fchastanet/bash-tools/tree/master/../../.cache/pre-commit/repob0v8ngyh/src/Compiler/Embed/embedFrameworkFunction.binFile.tpl
# DO NOT EDIT IT
# @generated
###############################################################################
# shellcheck disable=SC2288,SC2034
# BIN_FILE=${BIN_FILE}
# FACADE

# ensure that no user aliases could interfere with
# commands used in this script
unalias -a || true
shopt -u expand_aliases

# shellcheck disable=SC2034
((failures = 0)) || true

# Bash will remember & return the highest exit code in a chain of pipes.
# This way you can catch the error inside pipes, e.g. mysqldump | gzip
set -o pipefail
set -o errexit

# Command Substitution can inherit errexit option since bash v4.4
shopt -s inherit_errexit || true

# a log is generated when a command fails
set -o errtrace

# use nullglob so that (file*.php) will return an empty array if no file matches the wildcard
shopt -s nullglob

# ensure regexp are interpreted without accentuated characters
export LC_ALL=POSIX

export TERM=xterm-256color

# avoid interactive install
export DEBIAN_FRONTEND=noninteractive
export DEBCONF_NONINTERACTIVE_SEEN=true

# store command arguments for later usage
# shellcheck disable=SC2034
declare -a BASH_FRAMEWORK_ARGV=("$@")
# shellcheck disable=SC2034
declare -a ORIGINAL_BASH_FRAMEWORK_ARGV=("$@")

# @see https://unix.stackexchange.com/a/386856
# shellcheck disable=SC2317
interruptManagement() {
  # restore SIGINT handler
  trap - INT
  # ensure that Ctrl-C is trapped by this script and not by sub process
  # report to the parent that we have indeed been interrupted
  kill -s INT "$$"
}
trap interruptManagement INT
SCRIPT_NAME=${0##*/}
REAL_SCRIPT_FILE="$(readlink -e "$(realpath "${BASH_SOURCE[0]}")")"
if [[ -n "${EMBED_CURRENT_DIR}" ]]; then
  CURRENT_DIR="${EMBED_CURRENT_DIR}"
else
  CURRENT_DIR="$(cd "$(readlink -e "${REAL_SCRIPT_FILE%/*}")" && pwd -P)"
fi

################################################
# Temp dir management
################################################

KEEP_TEMP_FILES="${KEEP_TEMP_FILES:-0}"
export KEEP_TEMP_FILES

# PERSISTENT_TMPDIR is not deleted by traps
PERSISTENT_TMPDIR="${TMPDIR:-/tmp}/bash-framework"
export PERSISTENT_TMPDIR
mkdir -p "${PERSISTENT_TMPDIR}"

# shellcheck disable=SC2034
TMPDIR="$(mktemp -d -p "${PERSISTENT_TMPDIR:-/tmp}" -t bash-framework-$$-XXXXXX)"
export TMPDIR

# temp dir cleaning
# shellcheck disable=SC2317
cleanOnExit() {
  if [[ "${KEEP_TEMP_FILES:-0}" = "1" ]]; then
    Log::displayInfo "KEEP_TEMP_FILES=1 temp files kept here '${TMPDIR}'"
  elif [[ -n "${TMPDIR+xxx}" ]]; then
    Log::displayDebug "KEEP_TEMP_FILES=0 removing temp files '${TMPDIR}'"
    rm -Rf "${TMPDIR:-/tmp/fake}" >/dev/null 2>&1
  fi
}
trap cleanOnExit EXIT HUP QUIT ABRT TERM

# VAR_MAIN_FUNCTION_VAR_NAME=dbQueryAllDatabasesFacade

# @description used to execute given query when using
# dbScriptAllDatabases
# @arg $1 dsn:String
# @arg $2 db:String
# @env query String
# @env optionSeparator String
# @require Linux::requireExecutedAsUser
Db::queryOneDatabase() {
  # query and optionSeparator are passed via export
  local dsn="$1"
  local db="$2"

  local -A dbInstance
  Database::newInstance dbInstance "${dsn}"
  Database::setQueryOptions dbInstance "${dbInstance[QUERY_OPTIONS]} --connect-timeout=5"

  # identify columns header
  echo -n "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
  Database::skipColumnNames dbInstance 0

  # shellcheck disable=SC2154
  if ! Database::query dbInstance "${query}" "${db}" | sed "s/\t/${optionSeparator}/g"; then
    Log::fatal "database ${db} error" 1>&2
  fi
}

# @description Log namespace provides 2 kind of functions
# - Log::display* allows to display given message with
#   given display level
# - Log::log* allows to log given message with
#   given log level
# Log::display* functions automatically log the message too
# @see Env::requireLoad to load the display and log level from .env file

# @description log level off
export __LEVEL_OFF=0
# @description log level error
export __LEVEL_ERROR=1
# @description log level warning
export __LEVEL_WARNING=2
# @description log level info
export __LEVEL_INFO=3
# @description log level success
export __LEVEL_SUCCESS=3
# @description log level debug
export __LEVEL_DEBUG=4

# @description verbose level off
export __VERBOSE_LEVEL_OFF=0
# @description verbose level info
export __VERBOSE_LEVEL_INFO=1
# @description verbose level info
export __VERBOSE_LEVEL_DEBUG=2
# @description verbose level info
export __VERBOSE_LEVEL_TRACE=3

# @description Display message using debug color (grey)
# @arg $1 message:String the message to display
Log::displayDebug() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_DEBUG)); then
    echo -e "${__DEBUG_COLOR}DEBUG   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logDebug "$1"
}

# @description Display message using info color (bg light blue/fg white)
# @arg $1 message:String the message to display
Log::displayInfo() {
  local type="${2:-INFO}"
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__INFO_COLOR}${type}    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logInfo "$1" "${type}"
}

# @description ensure COMMAND_BIN_DIR env var is set
# and PATH correctly prepared
# @noargs
# @set COMMAND_BIN_DIR string the directory where to find this command
# @set PATH string add directory where to find this command binary
Compiler::Facade::requireCommandBinDir() {
  COMMAND_BIN_DIR="${CURRENT_DIR}"
  Env::pathPrepend "${COMMAND_BIN_DIR}"
}

# @description create a new db instance
# Returns immediately if the instance is already initialized
#
# @arg $1 instanceNewInstance:&Map<String,String> (passed by reference) database instance to use
# @arg $2 dsn:String dsn profile - load the dsn.env profile deduced using rules defined in Conf::getAbsoluteFile
#
# @example
#   declare -Agx dbInstance
#   Database::newInstance dbInstance "default.local"
#
# @exitcode 1 if dns file not able to loaded
Database::newInstance() {
  local -n instanceNewInstance=$1
  local dsn="$2"
  local DSN_FILE

  if [[ -v instanceNewInstance['INITIALIZED'] && "${instanceNewInstance['INITIALIZED']:-0}" == "1" ]]; then
    return
  fi

  # final auth file generated from dns file
  instanceNewInstance['AUTH_FILE']=""
  instanceNewInstance['DSN_FILE']=""

  # check dsn file
  DSN_FILE="$(Conf::getAbsoluteFile "dsn" "${dsn}" "env")" || return 1
  Database::checkDsnFile "${DSN_FILE}" || return 1
  instanceNewInstance['DSN_FILE']="${DSN_FILE}"

  # shellcheck source=/src/Database/testsData/dsn_valid.env
  source "${instanceNewInstance['DSN_FILE']}"

  instanceNewInstance['USER']="${USER}"
  instanceNewInstance['PASSWORD']="${PASSWORD}"
  instanceNewInstance['HOSTNAME']="${HOSTNAME}"
  instanceNewInstance['PORT']="${PORT}"

  # generate authFile for easy authentication
  instanceNewInstance['AUTH_FILE']=$(mktemp -p "${TMPDIR:-/tmp}" -t "mysql.XXXXXXXXXXXX")
  (
    echo "[client]"
    echo "user = ${USER}"
    echo "password = ${PASSWORD}"
    echo "host = ${HOSTNAME}"
    echo "port = ${PORT}"
  ) >"${instanceNewInstance['AUTH_FILE']}"

  # some of those values can be overridden using the dsn file
  # SKIP_COLUMN_NAMES enabled by default
  instanceNewInstance['SKIP_COLUMN_NAMES']="${SKIP_COLUMN_NAMES:-1}"
  instanceNewInstance['SSL_OPTIONS']="${MYSQL_SSL_OPTIONS:---ssl-mode=DISABLED}"
  instanceNewInstance['QUERY_OPTIONS']="${MYSQL_QUERY_OPTIONS:---batch --raw --default-character-set=utf8}"
  instanceNewInstance['DUMP_OPTIONS']="${MYSQL_DUMP_OPTIONS:---default-character-set=utf8 --compress --hex-blob --routines --triggers --single-transaction --set-gtid-purged=OFF --column-statistics=0 ${instanceNewInstance['SSL_OPTIONS']}}"
  instanceNewInstance['DB_IMPORT_OPTIONS']="${DB_IMPORT_OPTIONS:---connect-timeout=5 --batch --raw --default-character-set=utf8}"

  instanceNewInstance['INITIALIZED']=1
}

# @description mysql query on a given db
# @warning could use QUERY_OPTIONS variable from dsn if defined
# @example
#   cat file.sql | Database::query ...
# @arg $1 instanceQuery:&Map<String,String> (passed by reference) database instance to use
# @arg $2 sqlQuery:String (optional) sql query or sql file to execute. if not provided or empty, the command can be piped
# @arg $3 dbName:String (optional) the db name
#
# @exitcode mysql command status code
Database::query() {
  local -n instanceQuery=$1
  local -a mysqlCommand=()
  local -a queryOptions

  mysqlCommand+=(mysql)
  mysqlCommand+=("--defaults-extra-file=${instanceQuery['AUTH_FILE']}")
  IFS=' ' read -r -a queryOptions <<<"${instanceQuery['QUERY_OPTIONS']}"
  mysqlCommand+=("${queryOptions[@]}")
  if [[ "${instanceQuery['SKIP_COLUMN_NAMES']}" = "1" ]]; then
    mysqlCommand+=("-s" "--skip-column-names")
  fi
  # add optional db name
  if [[ -n "${3+x}" ]]; then
    mysqlCommand+=("$3")
  fi
  # add optional sql query
  if [[ -n "${2+x}" && -n "$2" && ! -f "$2" ]]; then
    mysqlCommand+=("-e")
    mysqlCommand+=("$2")
  fi
  Log::displayDebug "$(printf "execute command: '%s'" "${mysqlCommand[*]}")"

  if [[ -f "$2" ]]; then
    "${mysqlCommand[@]}" <"$2"
  else
    "${mysqlCommand[@]}"
  fi
}

# @description set the general options to use on mysql command to query the database
# Differs than setOptions in the way that these options could change each time
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 optionsList:String query options list
Database::setQueryOptions() {
  local -n instanceSetQueryOptions=$1
  # shellcheck disable=SC2034
  instanceSetQueryOptions['QUERY_OPTIONS']="$2"
}

# @description by default we skip the column names
# but sometimes we need column names to display some results
# disable this option temporarily and then restore it to true
#
# @arg $1 instanceSetQueryOptions:&Map<String,String> (passed by reference) database instance to use
# @arg $2 skipColumnNames:Boolean 0 to disable, 1 to enable (hide column names)
Database::skipColumnNames() {
  local -n instanceSkipColumnNames=$1
  # shellcheck disable=SC2034
  instanceSkipColumnNames['SKIP_COLUMN_NAMES']="$2"
}

# @description prepend directories to the PATH environment variable
# @arg $@ args:String[] list of directories to prepend
# @set PATH update PATH with the directories prepended
Env::pathPrepend() {
  local arg
  for arg in "$@"; do
    if [[ -d "${arg}" && ":${PATH}:" != *":${arg}:"* ]]; then
      PATH="$(realpath "${arg}"):${PATH}"
    fi
  done
}

# @description Display message using error color (red) and exit immediately with error status 1
# @arg $1 message:String the message to display
Log::fatal() {
  echo -e "${__ERROR_COLOR}FATAL   - ${1}${__RESET_COLOR}" >&2
  Log::logFatal "$1"
  exit 1
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logDebug() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_DEBUG)); then
    Log::logMessage "${2:-DEBUG}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logInfo() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-INFO}" "$1"
  fi
}

# @description ensure running user is not root
# @exitcode 1 if current user is root
# @stderr diagnostics information is displayed
Linux::requireExecutedAsUser() {
  if [[ "$(id -u)" = "0" ]]; then
    Log::fatal "this script should be executed as normal user"
  fi
}

# @description get absolute conf file from specified conf folder deduced using these rules
#   * from absolute file (ignores <confFolder> and <extension>)
#   * relative to where script is executed (ignores <confFolder> and <extension>)
#   * from home/.bash-tools/<confFolder>
#   * from framework conf/<confFolder>
#
# @arg $1 confFolder:String the directory name (not the path) to list
# @arg $2 conf:String file to use without extension
# @arg $3 extension:String the extension (.sh by default)
#
# @stdout absolute conf filename
# @exitcode 1 if file is not found in any location
Conf::getAbsoluteFile() {
  local confFolder="$1"
  local conf="$2"
  local extension="${3-.sh}"
  if [[ -n "${extension}" && "${extension:0:1}" != "." ]]; then
    extension=".${extension}"
  fi

  testAbs() {
    local result
    result="$(realpath -e "$1" 2>/dev/null)"
    # shellcheck disable=SC2181
    if [[ "$?" = "0" && -f "${result}" ]]; then
      echo "${result}"
      return 0
    fi
    return 1
  }

  # conf is absolute file (including extension)
  testAbs "${confFolder}${extension}" && return 0
  # conf is absolute file
  testAbs "${confFolder}" && return 0
  # conf is absolute file (including extension)
  testAbs "${conf}${extension}" && return 0
  # conf is absolute file
  testAbs "${conf}" && return 0

  # relative to where script is executed (including extension)
  if [[ -n "${CURRENT_DIR+xxx}" ]]; then
    testAbs "$(File::concatenatePath "${CURRENT_DIR}" "${confFolder}")/${conf}${extension}" && return 0
  fi
  # from home/.bash-tools/<confFolder>
  testAbs "$(File::concatenatePath "${HOME}/.bash-tools" "${confFolder}")/${conf}${extension}" && return 0

  if [[ -n "${FRAMEWORK_ROOT_DIR+xxx}" ]]; then
    # from framework conf/<confFolder> (including extension)
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}${extension}" && return 0

    # from framework conf/<confFolder>
    testAbs "$(File::concatenatePath "${FRAMEWORK_ROOT_DIR}/conf" "${confFolder}")/${conf}" && return 0
  fi

  # file not found
  Log::displayError "conf file '${conf}' not found"

  return 1
}

# @description check if dsn file has all the mandatory variables set
# Mandatory variables are: HOSTNAME, USER, PASSWORD, PORT
#
# @arg $1 dsnFileName:String dsn absolute filename
# @set HOSTNAME loaded from dsn file
# @set PORT loaded from dsn file
# @set USER loaded from dsn file
# @set PASSWORD loaded from dsn file
# @exitcode 0 on valid file
# @exitcode 1 if one of the properties of the conf file is invalid or if file not found
# @stderr log output if error found in conf file
Database::checkDsnFile() {
  local dsnFileName="$1"
  if [[ ! -f "${dsnFileName}" ]]; then
    Log::displayError "dsn file ${dsnFileName} not found"
    return 1
  fi

  (
    unset HOSTNAME PORT PASSWORD USER
    # shellcheck source=/src/Database/testsData/dsn_valid.env
    source "${dsnFileName}"
    if [[ -z ${HOSTNAME+x} ]]; then
      Log::displayError "dsn file ${dsnFileName} : HOSTNAME not provided"
      return 1
    fi
    if [[ -z "${HOSTNAME}" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : HOSTNAME value not provided"
    fi
    if [[ "${HOSTNAME}" = "localhost" ]]; then
      Log::displayWarning "dsn file ${dsnFileName} : check that HOSTNAME should not be 127.0.0.1 instead of localhost"
    fi
    if [[ -z "${PORT+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT not provided"
      return 1
    fi
    if ! [[ ${PORT} =~ ^[0-9]+$ ]]; then
      Log::displayError "dsn file ${dsnFileName} : PORT invalid"
      return 1
    fi
    if [[ -z "${USER+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : USER not provided"
      return 1
    fi
    if [[ -z "${PASSWORD+x}" ]]; then
      Log::displayError "dsn file ${dsnFileName} : PASSWORD not provided"
      return 1
    fi
  )
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logFatal() {
  Log::logMessage "${2:-FATAL}" "$1"
}

# @description Internal: common log message
# @example text
#   [date]|[levelMsg]|message
#
# @example text
#   2020-01-19 19:20:21|ERROR  |log error
#   2020-01-19 19:20:21|SKIPPED|log skipped
#
# @arg $1 levelMsg:String message's level description (eg: STATUS, ERROR, ...)
# @arg $2 msg:String the message to display
# @env BASH_FRAMEWORK_LOG_FILE String log file to use, do nothing if empty
# @env BASH_FRAMEWORK_LOG_LEVEL int log level log only if > OFF or fatal messages
# @stderr diagnostics information is displayed
# @require Env::requireLoad
# @require Log::requireLoad
Log::logMessage() {
  local levelMsg="$1"
  local msg="$2"
  local date

  if [[ -n "${BASH_FRAMEWORK_LOG_FILE}" ]] && ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    date="$(date '+%Y-%m-%d %H:%M:%S')"
    touch "${BASH_FRAMEWORK_LOG_FILE}"
    printf "%s|%7s|%s\n" "${date}" "${levelMsg}" "${msg}" >>"${BASH_FRAMEWORK_LOG_FILE}"
  fi
}

# @description concatenate 2 paths and ensure the path is correct using realpath -m
# @arg $1 basePath:String
# @arg $2 subPath:String
# @require Linux::requireRealpathCommand
File::concatenatePath() {
  local basePath="$1"
  local subPath="$2"
  local fullPath="${basePath:+${basePath}/}${subPath}"

  realpath -m "${fullPath}" 2>/dev/null
}

# @description Display message using error color (red)
# @arg $1 message:String the message to display
Log::displayError() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_ERROR)); then
    echo -e "${__ERROR_COLOR}ERROR   - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logError "$1"
}

# @description Display message using warning color (yellow)
# @arg $1 message:String the message to display
Log::displayWarning() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_WARNING)); then
    echo -e "${__WARNING_COLOR}WARN    - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logWarning "$1"
}

# @description ensure env files are loaded
# @arg $@ list of default files to load at the end
# @exitcode 1 if one of env files fails to load
# @stderr diagnostics information is displayed
# shellcheck disable=SC2120
Env::requireLoad() {
  local -a defaultFiles=("$@")
  # get list of possible config files
  local -a configFiles=()
  if [[ -n "${BASH_FRAMEWORK_ENV_FILES[0]+1}" ]]; then
    # BASH_FRAMEWORK_ENV_FILES is an array
    configFiles+=("${BASH_FRAMEWORK_ENV_FILES[@]}")
  fi
  if [[ -f "$(pwd)/.framework-config" ]]; then
    configFiles+=("$(pwd)/.framework-config")
  fi
  if [[ -f "${FRAMEWORK_ROOT_DIR}/.framework-config" ]]; then
    configFiles+=("${FRAMEWORK_ROOT_DIR}/.framework-config")
  fi
  if [[ -n "${optionBashFrameworkConfig}" && -f "${optionBashFrameworkConfig}" ]]; then
    # shellcheck disable=SC2034
    configFiles+=("${optionBashFrameworkConfig}")
  fi
  configFiles+=("${optionEnvFiles[@]}")
  configFiles+=("${defaultFiles[@]}")

  for file in "${configFiles[@]}"; do
    # shellcheck source=/.framework-config
    CURRENT_LOADED_ENV_FILE="${file}" source "${file}" || {
      Log::displayError "while loading config file: ${file}"
      return 1
    }
  done
}

# @description activate or not Log::display* and Log::log* functions
# based on BASH_FRAMEWORK_DISPLAY_LEVEL and BASH_FRAMEWORK_LOG_LEVEL
# environment variables loaded by Env::requireLoad
# try to create log file and rotate it if necessary
# @noargs
# @set BASH_FRAMEWORK_LOG_LEVEL int to OFF level if BASH_FRAMEWORK_LOG_FILE is empty or not writable
# @env BASH_FRAMEWORK_DISPLAY_LEVEL int
# @env BASH_FRAMEWORK_LOG_LEVEL int
# @env BASH_FRAMEWORK_LOG_FILE String
# @env BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION int do log rotation if > 0
# @exitcode 0 always successful
# @stderr diagnostics information about log file is displayed
# @require Env::requireLoad
# @require UI::requireTheme
Log::requireLoad() {
  if [[ -z "${BASH_FRAMEWORK_LOG_FILE:-}" ]]; then
    BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
    export BASH_FRAMEWORK_LOG_LEVEL
  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    if [[ ! -f "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      if
        ! mkdir -p "$(dirname "${BASH_FRAMEWORK_LOG_FILE}")" 2>/dev/null ||
          ! touch --no-create "${BASH_FRAMEWORK_LOG_FILE}" 2>/dev/null
      then
        BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
        echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
      fi
    elif [[ ! -w "${BASH_FRAMEWORK_LOG_FILE}" ]]; then
      BASH_FRAMEWORK_LOG_LEVEL=${__LEVEL_OFF}
      echo -e "${__ERROR_COLOR}ERROR   - File ${BASH_FRAMEWORK_LOG_FILE} is not writable${__RESET_COLOR}" >&2
    fi

  fi

  if ((BASH_FRAMEWORK_LOG_LEVEL > __LEVEL_OFF)); then
    # will always be created even if not in info level
    Log::logMessage "INFO" "Logging to file ${BASH_FRAMEWORK_LOG_FILE} - Log level ${BASH_FRAMEWORK_LOG_LEVEL}"
    if ((BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION > 0)); then
      Log::rotate "${BASH_FRAMEWORK_LOG_FILE}" "${BASH_FRAMEWORK_LOG_FILE_MAX_ROTATION}"
    fi
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logError() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_ERROR)); then
    Log::logMessage "${2:-ERROR}" "$1"
  fi
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logWarning() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_WARNING)); then
    Log::logMessage "${2:-WARNING}" "$1"
  fi
}

# @description To be called before logging in the log file
# @arg $1 file:string log file name
# @arg $2 maxLogFilesCount:int maximum number of log files
Log::rotate() {
  local file="$1"
  local maxLogFilesCount="${2:-5}"

  if [[ ! -f "${file}" ]]; then
    Log::displaySkipped "Log file ${file} doesn't exist yet"
    return 0
  fi
  for i in $(seq $((maxLogFilesCount - 1)) -1 1); do
    Log::displayInfo "Log rotation ${file}.${i} to ${file}.$((i + 1))"
    mv "${file}."{"${i}","$((i + 1))"} &>/dev/null || true
  done
  if cp "${file}" "${file}.1" &>/dev/null; then
    echo >"${file}" # reset log file
    Log::displayInfo "Log rotation ${file} to ${file}.1"
  fi
}

# @description ensure command realpath is available
# @exitcode 1 if realpath command not available
# @stderr diagnostics information is displayed
Linux::requireRealpathCommand() {
  Assert::commandExists realpath
}

# @description load color theme
# @noargs
# @env BASH_FRAMEWORK_THEME String theme to use
# @exitcode 0 always successful
UI::requireTheme() {
  UI::theme "${BASH_FRAMEWORK_THEME-default}"
}

# @description check if command specified exists or return 1
# with error and message if not
#
# @arg $1 commandName:String on which existence must be checked
# @arg $2 helpIfNotExists:String a help command to display if the command does not exist
#
# @exitcode 1 if the command specified does not exist
# @stderr diagnostic information + help if second argument is provided
Assert::commandExists() {
  local commandName="$1"
  local helpIfNotExists="$2"

  "${BASH_FRAMEWORK_COMMAND:-command}" -v "${commandName}" >/dev/null 2>/dev/null || {
    Log::displayError "${commandName} is not installed, please install it"
    if [[ -n "${helpIfNotExists}" ]]; then
      Log::displayInfo "${helpIfNotExists}"
    fi
    return 1
  }
  return 0
}

# @description Display message using skip color (yellow)
# @arg $1 message:String the message to display
Log::displaySkipped() {
  if ((BASH_FRAMEWORK_DISPLAY_LEVEL >= __LEVEL_INFO)); then
    echo -e "${__SKIPPED_COLOR}SKIPPED - ${1}${__RESET_COLOR}" >&2
  fi
  Log::logSkipped "$1"
}

# @description load colors theme constants
# @warning if tty not opened, noColor theme will be chosen
# @arg $1 theme:String the theme to use (default, noColor)
# @arg $@ args:String[]
# @set __ERROR_COLOR String indicate error status
# @set __INFO_COLOR String indicate info status
# @set __SUCCESS_COLOR String indicate success status
# @set __WARNING_COLOR String indicate warning status
# @set __SKIPPED_COLOR String indicate skipped status
# @set __DEBUG_COLOR String indicate debug status
# @set __HELP_COLOR String indicate help status
# @set __TEST_COLOR String not used
# @set __TEST_ERROR_COLOR String not used
# @set __HELP_TITLE_COLOR String used to display help title in help strings
# @set __HELP_OPTION_COLOR String used to display highlight options in help strings
#
# @set __RESET_COLOR String reset default color
#
# @set __HELP_EXAMPLE String to remove
# @set __HELP_TITLE String to remove
# @set __HELP_NORMAL String to remove
# shellcheck disable=SC2034
UI::theme() {
  local theme="${1-default}"
  if [[ ! "${theme}" =~ -force$ ]] && ! Assert::tty; then
    theme="noColor"
  fi
  case "${theme}" in
    default | default-force)
      theme="default"
      ;;
    noColor) ;;
    *)
      Log::fatal "invalid theme provided"
      ;;
  esac
  if [[ "${theme}" = "default" ]]; then
    BASH_FRAMEWORK_THEME="default"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR='\e[31m'         # Red
    __INFO_COLOR='\e[44m'          # white on lightBlue
    __SUCCESS_COLOR='\e[32m'       # Green
    __WARNING_COLOR='\e[33m'       # Yellow
    __SKIPPED_COLOR='\e[33m'       # Yellow
    __DEBUG_COLOR='\e[37m'         # Grey
    __HELP_COLOR='\e[7;49;33m'     # Black on Gold
    __TEST_COLOR='\e[100m'         # Light magenta
    __TEST_ERROR_COLOR='\e[41m'    # white on red
    __HELP_TITLE_COLOR="\e[1;37m"  # Bold
    __HELP_OPTION_COLOR="\e[1;34m" # Blue
    # Internal: reset color
    __RESET_COLOR='\e[0m' # Reset Color
    # shellcheck disable=SC2155,SC2034
    __HELP_EXAMPLE="$(echo -e "\e[2;97m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_TITLE="$(echo -e "\e[1;37m")"
    # shellcheck disable=SC2155,SC2034
    __HELP_NORMAL="$(echo -e "\033[0m")"
  else
    BASH_FRAMEWORK_THEME="noColor"
    # check colors applicable https://misc.flogisoft.com/bash/tip_colors_and_formatting
    __ERROR_COLOR=''
    __INFO_COLOR=''
    __SUCCESS_COLOR=''
    __WARNING_COLOR=''
    __SKIPPED_COLOR=''
    __DEBUG_COLOR=''
    __HELP_COLOR=''
    __TEST_COLOR=''
    __TEST_ERROR_COLOR=''
    __HELP_TITLE_COLOR=''
    __HELP_OPTION_COLOR=''
    # Internal: reset color
    __RESET_COLOR=''
    __HELP_EXAMPLE=''
    __HELP_TITLE=''
    __HELP_NORMAL=''
  fi
}

# @description check if tty (interactive mode) is active
# @noargs
# @exitcode 1 if tty not active
# @env NON_INTERACTIVE if 1 consider as not interactive even if environment is interactive
# @env INTERACTIVE if 1 consider as interactive even if environment is not interactive
# @stderr diagnostic information + help if second argument is provided
Assert::tty() {
  if [[ "${NON_INTERACTIVE:-0}" = "1" ]]; then
    return 1
  fi
  if [[ "${INTERACTIVE:-0}" = "1" ]]; then
    return 0
  fi
  [[ -t 1 || -t 2 ]]
}

# @description log message to file
# @arg $1 message:String the message to display
Log::logSkipped() {
  if ((BASH_FRAMEWORK_LOG_LEVEL >= __LEVEL_INFO)); then
    Log::logMessage "${2:-SKIPPED}" "$1"
  fi
}

# FUNCTIONS

facade_main_embedFrameworkFunctionbinFiletpl() {
# REQUIRES
Linux::requireExecutedAsUser
Env::requireLoad
Log::requireLoad
Linux::requireRealpathCommand
UI::requireTheme
Compiler::Facade::requireCommandBinDir

# @require Compiler::Facade::requireCommandBinDir

# shellcheck disable=SC2154,SC2016
functionToCall='Db::queryOneDatabase'
"${functionToCall}" "$@"

}

facade_main_embedFrameworkFunctionbinFiletpl "$@"
" Compiler::Embed::extractFileFromBase64 \ "${embed_function_DbQueryOneDatabase}" \ diff --git a/bin/doc b/bin/doc index c14e887e..38ef42c7 100755 --- a/bin/doc +++ b/bin/doc @@ -224,7 +224,7 @@ Array::wrap() { # @env GROUP_ID # @env FRAMEWORK_ROOT_DIR # @env DOCKER_OPTION_IMAGE_TAG -# @env BASH_FRAMEWORK_ARGV_FILTERED +# @env RUN_CONTAINER_ARGV_FILTERED Docker::runBuildContainer() { local optionVendor="$1" local optionBashVersion="$2" @@ -293,7 +293,7 @@ Docker::runBuildContainer() { Log::displayDebug "Run container with localDockerRunCmd: ${localDockerRunCmd[*]}" Log::displayDebug "Run container with localDockerRunArgs: ${localDockerRunArgs[*]}" - Log::displayDebug "Run container with BASH_FRAMEWORK_ARGV_FILTERED: ${BASH_FRAMEWORK_ARGV_FILTERED[*]}" + Log::displayDebug "Run container with RUN_CONTAINER_ARGV_FILTERED: ${RUN_CONTAINER_ARGV_FILTERED[*]}" ( # shellcheck disable=SC2154 if [[ "${optionTraceVerbose}" = "1" ]]; then @@ -304,6 +304,7 @@ Docker::runBuildContainer() { --rm \ "${localDockerRunArgs[@]}" \ ${DOCKER_RUN_OPTIONS} \ + "${RUN_CONTAINER_ARGV_FILTERED[@]}" \ -w /bash \ -v "$(pwd):/bash" \ --user "${USER_ID:-$(id -u)}:${GROUP_ID:-$(id -g)}" \ diff --git a/bin/installRequirements b/bin/installRequirements index 6aaf59ca..161d9568 100755 --- a/bin/installRequirements +++ b/bin/installRequirements @@ -92,6 +92,22 @@ cleanOnExit() { } trap cleanOnExit EXIT HUP QUIT ABRT TERM +# @description concat each element of an array with a separator +# +# @arg $1 glue:String +# @arg $@ array:String[] +# @example +# declare -a array=(test1, test2) +# echo "Result= $(Array::join "," "${array[@]})" +# Result= test1,test2 +Array::join() { + local glue="${1-}" + shift || true + local first="${1-}" + shift || true + printf %s "${first}" "${@/#/${glue}}" +} + # @description concat each element of an array with a separator # but wrapping text when line length is more than provided argument # The algorithm will try not to cut the array element if can @@ -1342,10 +1358,10 @@ installRequirementsCommand() { helpArray=(set\ display\ level\ \(one\ of\ OFF\,\ ERROR\,\ WARNING\,\ INFO\,\ DEBUG\,\ TRACE\ value\)) echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo -e """ -INSTALLS REQUIREMENTS: +${__HELP_TITLE}INSTALLS REQUIREMENTS:${__HELP_NORMAL} - fchastanet/bash-tools-framework - and fchastanet/bash-tools-framework useful binaries: - bin/test""" + $(Array::join ", " "${externalBinaries[@]}")""" echo echo -n -e "${__HELP_TITLE_COLOR}VERSION: ${__RESET_COLOR}" echo '1.0' diff --git a/bin/mysql2puml b/bin/mysql2puml index 8cf97a04..b0ee2a1c 100755 --- a/bin/mysql2puml +++ b/bin/mysql2puml @@ -1499,12 +1499,19 @@ mysql2pumlCommand() { helpArray=(set\ display\ level\ \(one\ of\ OFF\,\ ERROR\,\ WARNING\,\ INFO\,\ DEBUG\,\ TRACE\ value\)) echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo -e """ -Examples -mysql2puml dump.dql - -mysqldump --skip-add-drop-table --skip-add-locks --skip-disable-keys --skip-set-charset --user=root --password=root --no-data skills | mysql2puml - -List of available skins: +${__HELP_TITLE}EXAMPLE 1:${__HELP_NORMAL} +${__HELP_EXAMPLE}mysql2puml dump.dql${__HELP_NORMAL} + +${__HELP_TITLE}EXAMPLE 2:${__HELP_NORMAL} +${__HELP_EXAMPLE}mysqldump --skip-add-drop-table \ + --skip-add-locks \ + --skip-disable-keys \ + --skip-set-charset \ + --user=root \ + --password=root \ + --no-data skills | mysql2puml +${__HELP_NORMAL} +${__HELP_TITLE}LIST OF AVAILABLE SKINS:${__HELP_NORMAL} @@@SKINS_LIST@@@""" echo echo -n -e "${__HELP_TITLE_COLOR}VERSION: ${__RESET_COLOR}" diff --git a/bin/upgradeGithubRelease b/bin/upgradeGithubRelease index fab8b450..ac8f142d 100755 --- a/bin/upgradeGithubRelease +++ b/bin/upgradeGithubRelease @@ -1623,23 +1623,23 @@ upgradeGithubReleaseCommand() { echo -e " ${__HELP_OPTION_COLOR}--version-arg ${__HELP_NORMAL} {single}" local -a helpArray # shellcheck disable=SC2054 - helpArray=($'The argument that will be provided to the currently installed binary to check the version of the software. \n This parameter is needed if \E[2;97m--minimal-version\E[0m argument is used and is different than default value (\E[2;97m--version\E[0m).') + helpArray=($'The argument that will be provided to the currently installed binary\nto check the version of the software. See options constraints below.') echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo ' Default value: --version' echo -e " ${__HELP_OPTION_COLOR}--current-version${__HELP_NORMAL}, ${__HELP_OPTION_COLOR}-c ${__HELP_NORMAL} {single}" local -a helpArray # shellcheck disable=SC2054 - helpArray=($'Sometimes the command to retrieve the version is complicated. \n Some command needs you to parse json or other commands provides multiple sub command versions. In this case you can provide the version you currently have, see examples below.') + helpArray=($'Sometimes the command to retrieve the version is complicated.\nSome command needs you to parse json or other commands provides\nmultiple sub command versions. In this case you can provide the\nversion you currently have, see examples below.\nSee options constraints below.') echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo -e " ${__HELP_OPTION_COLOR}--exact-version${__HELP_NORMAL}, ${__HELP_OPTION_COLOR}-e ${__HELP_NORMAL} {single}" local -a helpArray # shellcheck disable=SC2054 - helpArray=($'if provided and currently installed binary is not this \E[2;97mexactVersion\E[0m, \n This exact version of the binary will be installed.') + helpArray=($'if provided and currently installed binary is not this exactVersion,\n This exact version of the binary will be installed.\n See options constraints below.') echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo -e " ${__HELP_OPTION_COLOR}--minimal-version${__HELP_NORMAL}, ${__HELP_OPTION_COLOR}-m ${__HELP_NORMAL} {single}" local -a helpArray # shellcheck disable=SC2054 - helpArray=($'if provided and currently installed binary is below this \E[2;97mminimalVersion\E[0m, \n a new version of the binary will be installed. \n If this argument is not provided, the latest binary is unconditionally downloaded from github.') + helpArray=($'if provided and currently installed binary is below this minimalVersion,\na new version of the binary will be installed.\nIf this argument is not provided, the latest binary is unconditionally downloaded from github.\nSee options constraints below.') echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo echo -e "${__HELP_TITLE_COLOR}GLOBAL OPTIONS:${__RESET_COLOR}" @@ -1714,40 +1714,43 @@ upgradeGithubReleaseCommand() { helpArray=(set\ display\ level\ \(one\ of\ OFF\,\ ERROR\,\ WARNING\,\ INFO\,\ DEBUG\,\ TRACE\ value\)) echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo -e """ -OPTIONS EXCEPTIONS: +${__HELP_TITLE}OPTIONS CONSTRAINTS:${__HELP_NORMAL} ---current-version|-c and --version-arg are mutually exclusive, -you cannot use both argument at the same time. +${__HELP_OPTION_COLOR}--version-arg${__HELP_NORMAL} parameter is needed if ${__HELP_OPTION_COLOR}--minimal-version${__HELP_NORMAL} argument is used and is different than default value. ---exact-version|-e and --minimal-version|-m are mutually exclusive, -you cannot use both argument at the same time. +${__HELP_OPTION_COLOR}--current-version${__HELP_NORMAL}|${__HELP_OPTION_COLOR}-c${__HELP_NORMAL} and ${__HELP_OPTION_COLOR}--version-arg${__HELP_NORMAL} are mutually exclusive, you cannot use both argument at the same time. -GITHUB TEMPLATE URLS EXAMPLES: +${__HELP_OPTION_COLOR}--exact-version${__HELP_NORMAL}|${__HELP_OPTION_COLOR}-e${__HELP_NORMAL} and ${__HELP_OPTION_COLOR}--minimal-version${__HELP_NORMAL}|${__HELP_OPTION_COLOR}-m${__HELP_NORMAL} are mutually exclusive, you cannot use both argument at the same time. -Simple ones(Sometimes @version@ template variable has to be specified twice): -'https://github.com/hadolint/hadolint/releases/download/v@version@/hadolint-Linux-x86_64' -'https://github.com/koalaman/shellcheck/releases/download/v@version@/shellcheck-v@version@.linux.x86_64.tar.xz' -'https://github.com/sharkdp/fd/releases/download/v@version@/fd_@version@_amd64.deb' -'https://github.com/sharkdp/bat/releases/download/v@version@/bat_@version@_amd64.deb' -'https://github.com/kubernetes-sigs/kind/releases/download/v@version@/kind-linux-amd64' -'https://github.com/kubernetes/minikube/releases/download/v@version@/minikube-linux-amd64' -'https://github.com/plantuml/plantuml/releases/download/v@version@/plantuml-@version@.jar' -'https://github.com/Versent/saml2aws/releases/download/v@version@/saml2aws_@version@_linux_amd64.tar.gz' +${__HELP_TITLE}GITHUB TEMPLATE URLS EXAMPLES:${__HELP_NORMAL} -If you want to add a condition on architecture(linux, windows, x86, 64/32 bits): -\"https://github.com/docker/compose/releases/download/v@version@/docker-compose-\$(uname -s | tr '[:upper:]' '[:lower:]')-\$(uname -m)\" +Simple ones(Sometimes @version@ template variable has to be specified twice):${__HELP_EXAMPLE} +\"https://github.com/hadolint/hadolint/releases/download/v@version@/hadolint-Linux-x86_64\" +\"https://github.com/koalaman/shellcheck/releases/download/v@version@/shellcheck-v@version@.linux.x86_64.tar.xz\" +\"https://github.com/sharkdp/fd/releases/download/v@version@/fd_@version@_amd64.deb\" +\"https://github.com/sharkdp/bat/releases/download/v@version@/bat_@version@_amd64.deb\" +\"https://github.com/kubernetes-sigs/kind/releases/download/v@version@/kind-linux-amd64\" +\"https://github.com/kubernetes/minikube/releases/download/v@version@/minikube-linux-amd64\" +\"https://github.com/plantuml/plantuml/releases/download/v@version@/plantuml-@version@.jar\" +\"https://github.com/Versent/saml2aws/releases/download/v@version@/saml2aws_@version@_linux_amd64.tar.gz\" +${__HELP_NORMAL} +If you want to add a condition on architecture(linux, windows, x86, 64/32 bits):${__HELP_EXAMPLE} +\"https://github.com/docker/compose/releases/download/v@version@/docker-compose-\$(uname -s | tr \"[:upper:]\" \"[:lower:]\")-\$(uname -m)\" \"https://github.com/docker/docker-credential-helpers/releases/download/v@version@/docker-credential-wincred-v@version@.windows-\$(dpkg --print-architecture).exe\" \"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\" - -COMMAND EXAMPLES: +${__HELP_NORMAL} +${__HELP_TITLE}COMMAND EXAMPLES:${__HELP_NORMAL} Download docker-compose latest version -upgradeGithubRelease /usr/local/bin/docker-compose \"https://github.com/docker/compose/releases/download/v@version@/docker-compose-\$(uname -s | tr '[:upper:]' '[:lower:]')-\$(uname -m)\" +${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/docker-compose \\ + \"https://github.com/docker/compose/releases/download/v@version@/docker-compose-\$(uname -s | tr \"[:upper:]\" \"[:lower:]\")-\$(uname -m)\"${__HELP_NORMAL} Download oq specific version -upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 \"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\" +${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 \\ + \"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\"${__HELP_NORMAL} Download oq specific version correctly retrieving the oq version and not the jq one -upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 --version-arg '-V | grep oq:' \"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\"""" +${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 --version-arg '-V | grep oq:' \\ + \"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\"${__HELP_NORMAL}""" echo echo -n -e "${__HELP_TITLE_COLOR}VERSION: ${__RESET_COLOR}" echo '2.0' diff --git a/bin/waitForIt b/bin/waitForIt index e18e9666..2bc03784 100755 --- a/bin/waitForIt +++ b/bin/waitForIt @@ -1437,18 +1437,18 @@ waitForItCommand() { helpArray=(set\ display\ level\ \(one\ of\ OFF\,\ ERROR\,\ WARNING\,\ INFO\,\ DEBUG\,\ TRACE\ value\)) echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo -e """ -EXIT STATUS CODES: -\e[1;34m0: the host/port is available -\e[1;34m1: indicates host/port is not available or argument error -\e[1;34m2: timeout reached - -AVAILABLE ALGORITHMS: -\e[1;34mtimeoutV1WithNc: previous version of timeout command with --timeout option, base command nc -\e[1;34mtimeoutV2WithNc: newer version of timeout command using timeout as argument, base command nc -\e[1;34mwhileLoopWithNc: timeout command simulated using while loop, base command nc -\e[1;34mtimeoutV1WithTcp: previous version of timeout command with --timeout option -\e[1;34mtimeoutV2WithTcp: newer version of timeout command using timeout as argument -\e[1;34mwhileLoopWithTcp: timeout command simulated using while loop, base command tcp""" +${__HELP_TITLE}EXIT STATUS CODES:${__HELP_NORMAL} +${__HELP_OPTION_COLOR}0${__HELP_NORMAL}: the host/port is available +${__HELP_OPTION_COLOR}1${__HELP_NORMAL}: indicates host/port is not available or argument error +${__HELP_OPTION_COLOR}2${__HELP_NORMAL}: timeout reached + +${__HELP_TITLE}AVAILABLE ALGORITHMS:${__HELP_NORMAL} +${__HELP_OPTION_COLOR}timeoutV1WithNc${__HELP_NORMAL}: previous version of timeout command with --timeout option, base command nc +${__HELP_OPTION_COLOR}timeoutV2WithNc${__HELP_NORMAL}: newer version of timeout command using timeout as argument, base command nc +${__HELP_OPTION_COLOR}whileLoopWithNc${__HELP_NORMAL}: timeout command simulated using while loop, base command nc +${__HELP_OPTION_COLOR}timeoutV1WithTcp${__HELP_NORMAL}: previous version of timeout command with --timeout option +${__HELP_OPTION_COLOR}timeoutV2WithTcp${__HELP_NORMAL}: newer version of timeout command using timeout as argument +${__HELP_OPTION_COLOR}whileLoopWithTcp${__HELP_NORMAL}: timeout command simulated using while loop, base command tcp""" echo echo -n -e "${__HELP_TITLE_COLOR}VERSION: ${__RESET_COLOR}" echo '2.0' diff --git a/bin/waitForMysql b/bin/waitForMysql index 686d02c4..6ac9b60a 100755 --- a/bin/waitForMysql +++ b/bin/waitForMysql @@ -1393,10 +1393,10 @@ waitForMysqlCommand() { helpArray=(set\ display\ level\ \(one\ of\ OFF\,\ ERROR\,\ WARNING\,\ INFO\,\ DEBUG\,\ TRACE\ value\)) echo -e " $(Array::wrap " " 76 4 "${helpArray[@]}")" echo -e """ -EXIT STATUS CODES: -\e[1;34m0: mysql is available -\e[1;34m1: indicates mysql is not available or argument error -\e[1;34m2: timeout reached""" +${__HELP_TITLE}EXIT STATUS CODES:${__HELP_NORMAL} +${__HELP_OPTION_COLOR}0${__HELP_NORMAL}: mysql is available +${__HELP_OPTION_COLOR}1${__HELP_NORMAL}: indicates mysql is not available or argument error +${__HELP_OPTION_COLOR}2${__HELP_NORMAL}: timeout reached""" echo echo -n -e "${__HELP_TITLE_COLOR}VERSION: ${__RESET_COLOR}" echo '2.0' diff --git a/conf/mysql2pumlSkins/default.png b/conf/mysql2pumlSkins/default.png new file mode 100644 index 0000000000000000000000000000000000000000..d5494d9a3bc8a0d45544401420ccbfdbe4c23603 GIT binary patch literal 952 zcmV;p14sOcP)^?c_3(XbZ~PzFE4OxVQzGFZEP-MZ*6wY${zp#11xD&Safh~ zVQzGFZEOGm0001ZoTXK5QyMW4{(iq=IUR)&1<`ie8)UR79R-!D__Y)67RY#)Tyu#G z{q^1C4uo20t;{gVWp|%_ve}o@Of#iT5_`K~L@1L4g$6xAh`B%*Vl1b?M=+CSS0R{; zi!qQ|YBVaCay#6`*!OCU-)9M$VyX+-FnO92mT7-M-`ummd} zK#7cv65xk1%QEm`51fovADT@lKUB9moiqAXpw;rd5{hV!MV_XX6Y-RB1S6>+RXky8 z22W^tj1{6Fx-m(t)Cm5=APJa==p#avg_5piWkTxj!o=|sRWdY*$hlTwThCIvSfvx+ zr(OD#ucKnk;c4$KwjDDHADn>id-S~v=Xrb_HFtI@IH zwJ8ETq!*sY$(}kIH-ld96_H}IXVHgDtaZMux0yx$l&c(yGs|LdbNOv>v5^Ne5tsW} zilJ5}c?YGUtRPq9!d0i@bIJWGhok*y9x>DyvfNcZ`s|Dg-=2Iws(8CD8edC$qb7;;bdEE-ILQg(Men! zg)*|8vFy5SyIrwu95Emjod&fUrJ%5L;((fe&Gl-`4y^gsHFZ#L!XtzP^+ZNl{*lpu zKxuO+^IqnGvpmyU@gYr+ODeB>{u80@kvp0^Tys)CrMugaV*02kt!D=F+`^{yVTUlcwb?|$r;z{v01-( diff --git a/src/_binaries/Converters/mysql2puml.options.tpl b/src/_binaries/Converters/mysql2puml.options.tpl index beaa2f35..ee06be75 100644 --- a/src/_binaries/Converters/mysql2puml.options.tpl +++ b/src/_binaries/Converters/mysql2puml.options.tpl @@ -3,20 +3,22 @@ declare versionNumber="1.0" declare commandFunctionName="mysql2pumlCommand" declare optionSkinDefault="default" declare help="convert mysql dump sql schema to plantuml format" -declare longDescription=""" -${__HELP_TITLE}Examples${__HELP_NORMAL} -mysql2puml dump.dql +# shellcheck disable=SC2016 +declare longDescription=''' +${__HELP_TITLE}EXAMPLE 1:${__HELP_NORMAL} +${__HELP_EXAMPLE}mysql2puml dump.dql${__HELP_NORMAL} -mysqldump --skip-add-drop-table \ +${__HELP_TITLE}EXAMPLE 2:${__HELP_NORMAL} +${__HELP_EXAMPLE}mysqldump --skip-add-drop-table \ --skip-add-locks \ --skip-disable-keys \ --skip-set-charset \ --user=root \ --password=root \ --no-data skills | mysql2puml - -${__HELP_TITLE}List of available skins:${__HELP_NORMAL} -@@@SKINS_LIST@@@""" +${__HELP_NORMAL} +${__HELP_TITLE}LIST OF AVAILABLE SKINS:${__HELP_NORMAL} +@@@SKINS_LIST@@@''' % .INCLUDE "$(dynamicTemplateDir _binaries/options/options.base.tpl)" diff --git a/src/_binaries/Converters/testsData/mysql2puml.help.txt b/src/_binaries/Converters/testsData/mysql2puml.help.txt index 8495ecfa..570d3da5 100644 --- a/src/_binaries/Converters/testsData/mysql2puml.help.txt +++ b/src/_binaries/Converters/testsData/mysql2puml.help.txt @@ -47,12 +47,13 @@ --display-level  {single} set display level (one of OFF, ERROR, WARNING, INFO, DEBUG, TRACE value) -Examples -mysql2puml dump.dql +EXAMPLE 1: +mysql2puml dump.dql -mysqldump --skip-add-drop-table --skip-add-locks --skip-disable-keys --skip-set-charset --user=root --password=root --no-data skills | mysql2puml - -List of available skins: +EXAMPLE 2: +mysqldump --skip-add-drop-table --skip-add-locks --skip-disable-keys --skip-set-charset --user=root --password=root --no-data skills | mysql2puml + +LIST OF AVAILABLE SKINS: - default VERSION: 1.0 diff --git a/src/_binaries/Converters/testsData/mysql2puml.png b/src/_binaries/Converters/testsData/mysql2puml.png new file mode 100644 index 0000000000000000000000000000000000000000..fdbda6cf882dbe471c5978851ecd4d5ee2f09e19 GIT binary patch literal 47051 zcma&ObzD~4)&}|_BGMKjA|Ue89RiZlDWP;LEh*9BM@iU&!2(cu*{2d z!Vg*-QB@l~ODjh+14A2xxPgU%^+Ov2{hN;*ZyMX!SUu%tVzM%OXklY(ZpNr*X>Rwm znG}IQlQU6NwK@Gg0tLo#h#XNfe=s3&;qaqQry+xvhT`3k!FazxKCLX}wQ1#%>~DV9 z%towDZ8EFn>AzO`*d!%xoe{)rS5IdaPAW_OF_-Mj{XI}oB&BgD!~Ave{lsH7ZJIe{}{zA#u~}h|4uyNEYYZE*ynVdB@RW4$19~H?Yk;ovJHhC z)b1;%Wh4~cy)!8F#dU3i5=7pV?dY1BwIz*ByjFxXwQj7CR8eQWJ zxBRpsYLiu0M~U5f^VFr_8l9vin(2CMOE}BCL^w<$d3N zzG&CvW#Sz3=K3H?8sI$WJ>;G3HtZUSCiGx0J{sCL@IjTF%W$N**+#cZ#)( z&An`$S zFsl&FwUas7GCEx(dFk6YO0RM4<(H*R9WQQVlTSN0F;H3A8f1h%c6QP1HHhrG`ZncL zLD8!#Q~QzqbrV%ak8cN+ss9?eqbzUwMH7=>DZV;rjo=OXSseC|grF#Nv5ma@9$RZ? z_ukIgwjIXG7g^ombqsw({gJ3X+3T_-{;s0pcO4O0nih_yIkSU4>0-iojEt7mim$@S zE*x@3KNb`wB4MW8>Ox0dR(-<0V1xc1@)>iN-&iD;TP=w`a{^60PF#CK@j z-+2{ub6nxpt{Gxp^%IiFdOld>mguGh?(3)WF>ZP`ch)X#oo$-={+&pS_4$Rx{pDpQ zj>ScrYKwlqTe0b+%QG0`#X_~cN+p~uHY${6?coy7oN}Hk-E5dwyg9T$7&6mO8Hd9LbtS6H=bt_@|EWtz>cdxQ-}eLPgJUuf2J&~{+G z?e(*IRVl<5iCJ6wK`q5U_onYQm6^g;1nNTf6h-a4x$ePr-P(*)PQ*(owrHA*O$Hn&6kvhe(p^^rDCq4 z>h+JB4`s+06GPHp6K3^`S6<38aIQUbP=dWTHXAnkgKkps!Ven5%&Gg2TZE$vebq-5 z%lEV&=BY|qD~R+Bpx5iG@?c2m$Gi63X4#M-x+74Sv#l6Ax#trZ)x=~dQmH3GJi=T_ z-6hTL`Q%I2#)47i#|4?mFa_$N>sN(V*%UkG-dVSih1$GN$8YR2!_MB6{yeln;*;vP zPY_gZkvBR#X3kEhRWp9cHr&>Du?W}IoS39~sf}fJFHLFhR~q`I=XE2cGW82_&(mzB z>d#h+YFZ|vg^*1rQyIY_FB|ATck%~X;b4s8KP83$?CVK=@bu}^CB#gw)7Csbo${v;p5xb$ zwM;oJWES=BV(VfCQpp)IL1IGK3kNrO(O+(zCq3FlcP>GNw-M#aFzSctDmSvCAgZza z46OI0gVk)-CJJwx*5i?mrb~xxlacunaaxQewUKL;Rq{XjBEV@uPfPpA9?^2L1Z{Wv zz!s+5*7gvFg^Tz>Jvo#4vBFhR+_x=jJT&N30^0Q>^8L0G7`1ZyvW@IfP5*gFdYyh_ zLQbIKa4}D-wl-JWElNMQ9ItDLg4d;$E?cwQ!9VIu2IlduIH15R!}40a(a_u$M}DS$ z`7)6xT@XgGAz1I{FUPlb_R>B1#z2EOS_XH57%9eG%v_nQBIH-rBW|;6k~b_3^^KoO zjo`7arzRw@kc;PDeooQ!pZ}WCB(L>ey0R?>R-W6YKS#tB7r!+YfB%7jfkm6^91*_e ztTg*lnHvH4>-u3`S*(aa!64054E-=o>-ws=xHu9Pme#RHgS$PS8?_}zO7A@DD`|^< zz&O+7t%J3Mk2m?moQd#e%h^xY9hLc1VRDRjCdXhGW#;?+_wFQeXX-PPU)Fn6Xf{wQ zJKs1{)D)<-F@;lk)${YUtR)Im#|huabnI%EDYY$K8Zd?_AGhqP)!NNi;jm$a2#d#M zAKsgMe)XQ1?PXMtKewZLrHiAgs_N2Ufv2ZugD;VaynIal%1Bv}Y|KZN4v!#?&^P9_5k+NT9;-q&lIzqCg39EVe z3^;Ogj637(mIiw>H9~m9?mV68K<#9a@&4RnU%#sDZ#MOY(>jZ_NLWE*_0C@l{hX8I zoGjCs^!{9)Os?ho1f<=4adxA@e3Q$P<&8fM4i29E+@_$UtX!)nk|Hn}`}7diq`j?; znBQf0yvB2`a&2u59giddPgqEZm5psA>VUV|7Lp{y0l<$6NS-%x7pD4 zVy)NUrox{5eHkKw7UWN{7hXAm+;L40goJ7dbX)|7@QAs4;zY6b{kWg)+sMoN<=)#K zDKI5ix`k)IJS<5{!snDP=y|TWP}kbU2&rIug@Z*TAanT8fj zV~XtGX_$UXkepke9=x0ALQRw88*LEqEaJ9#v+Vq9N;w=NjtuSZADx#|l{2rKPz_1- zJx4_k2n-~;{W#&qyTZUFECNRAq2|xEwL<&yCJG#91K9#+FY%&mF)srXY>SkgRvM$}x8c0I%C)0N+*{5tK3o{cv$s^{XpkMljL zPp29$Hhhh)tE)>)N+RL5Nr{OWA1--X{zcj^4ui69IdOXM@;F~U;a674u2!Dlar`E+ zj}GKNXrE$TDL_kY%$u*d4*{i#@W_dOQ(oziabv7Id1toM^JM%-j~*q-MKAa7#b|Oq^({~B_A(_vnA&l`l>wHsQaLvmxDujz@j6jrZZmLr0*Ru zk3++y@>>Iqmo29>4U~S&#TAk~(x2PAv0{Px=&wapRc@;*jp`k~@9D|WYsiJO-C5pR z=tDnu?rRj!&X+fr8{QFXR5;nXxRiI{laPE24i1ivt^%X{mZ`C^{Bw|5SO52PF5I|L zZnvbqZ|XEdwle4MYuFZ^I`%8iu6|AkAJYX91i^jl0< z3brmpJWp(xtbbPbpi_H|nWS%<73D8K31-l^6dzwOM}D~}U#nSsXLnbsw*^TzX^@gX!P`Nn z*KO5ZlTRiq&n2^R`FtPLru@rW=xAxB=D+#w1S@F|-{=2UwITcHQCzmG%$aq+6MIT) zPZxwwkFTq~YH@KfbbHD6Xv%w(uRu#Q+T{{4{`6;oy)%w* z@CjN5O5da63Oz8h=i@%X+K~b+t*yLIXR!BV3g@D4W^0uN?+IUwcuxOxx;Y5an0C&i zy1DLT`=vqATrop;MDy^zA8$GdJ(?P2Nb8#AW{QFw|GEUlXl1Fjfz;7qy!d-Vs({fY zlk! z5L{xgRp{T}S_stM_cIH;Y7ntlD^n|7*TZ1D@Qu%LJwfk>`Jh(5{LHskr)dHC-VIKe z&&ft6S(b=Ww&z@0w19G^x`4U5jp7x;H&-rGLkyfsZ@oQA^VpQRrpqwQ206zXYLM3Q zC16DBE33j^V;$T&G%zx6Q+0&C{*EH7`pg6?G z$2T9yH2^@v=e!LzZ9H7e0tY9FWzxXYEGYfaVUj65<9_*ro?w;lK}}6v-QAMePRO=a z{4HYu;=C;dxnP*8v*=9PheNWkTLa!4tkZf0 ze@|S7@CdQUT1WICixs>YU*8&0dU^(@f0dWTDo0Qt8jKM{@h8d~eA`98DOb+2M!R9G zpwW~k6E2ya<5^vH`lQ5xMy`I724ZIY`zzAs%a)_8mcei03UA_{Mu^J|0-w0x1WQy1 z-wt~4o<7$~d{o^GnO9lWfch~OtDjM?XX4G4sa&B0R8z25RsEpY6o%c%QyUkZAXW9_ zT{{POg6DLI3rE!%FoLQ9V)UP!BzaI)myNhJ+od$HrmMXEg-BAF(0#7yPe{M>-p$KP zg@1o`u=oi@w5!w*{4qY~MuInXf1VNEP^`86I?vhE*cj;$|FuCDim)(F9{X>F-eq?U zVWc1F*oa}lKMv6%c|b>B?*BpLQbq(Zx8M5(axv<*_X3Ap8a}(YU83jcwMsuM$v@$G z!S+#NCI9KDk2hUYbJw4tB8udLu2yd(qy=CdJJ$lk!(g>smpe^a%|}1n7SYhA;tx2h zO7bm9O-Om{%x=6|k8jS%pf42m;`7lPv^UsZ%pD)sxNRC-VCHDBHqo49Z^Ju4-PBl2 zh_6I)LEd$xB9Vrsj!Kq#X&!InS;1MYn^ds>4nZjHWv99A&E!}C#$}7-N4E2tqvc^P ze!c+(rUQb@cb{^xxN0=D zoat**s+m*rSJovjuVF^Ma=WrmSW`&3^6#0f2rH&j^BdW1NC+)*^Qw5Fx7HN6$hA`v zVel<`!r$|>RTN@F0$7iq6?BQuy<=eEjGiO)v*C01yXc?-os=5B1ygfOi>|QaeJ>$?1 z!ueTigBh6s@1Ru!{V~{pRn{P<;pv?4D4fR zGe7+`8r2$JwPn*~%P;BJN+vXd1nw74_jqC#eY^@>X+r5`TK1U_c~X{00%ANd+qnX7otFwbK{^r*GyW9l}`PoD)FG)<0f(?iGvXP|JC_ z){H1NM#gvgtApEZ5u5;)tbl=(l$1=d4UCrB(y`TNo9N^UeRKe8kPq5k=C5T$O#Zvv zu@M*f&%$amqZQ6Sx0i^nUAuPSf?s5$%farGvQ?9QT1v9$F}I^%F)=Za7HIH-1{&+* zM7;+KOjU|3M#jg-|AV&B>s0d6(`Nvu(GPesS&x6^3fJPC1mDKuKwcB$ZPRaN1G&=^ zb>0Q&`0% z+joQgH2}#iKpYD3VpY3!OpWeAbSkVrFRfJUXajQ0Hxg#f)N)wI`KS${WtkQgQ55(m zf_M44jcrW-_%TH1O7_)mIQBp)3R{myv43)42}wQ-ENOs_lhYoeh$lLp@?ag!6~}9& zq;9L@f=MA}zljhX6VrPai>`#GQrm@4mJd!$wm*~ZMKtE!if+ogRigOl(FBoYc`QkF zOxZC^LMqM2o8qNe4a#x|olvbN#aDQwBwSYG?mTtpqn4#d?8lz{q)l_7Yvgd0N;`}; zv1earzjfgBS*a$hRdA4m=A@b`zH+(e!dGT{Sq+#6hARKqC>)C0zPMN-2ecii(Pv*^f{-b?1H&nD8ejFX!cwWWcfWMv30bvhV6{XgSNX zY(1d0aoIS#GH`#;&OBJH%+6fts6C(Oy5sfK)YK^vzF(W&8#8S@)>E(T?*7`}ay&MN z@hKvK3h>?k$heZ1jwU81Br2_EJ7PUNJf8mex@Jw|iD&*YPbOe`^_^0(EV1q2)Cd3a z=9{Ar?iU%CT^Y3NbJb(yVv}jf(ki2rjqK0X5m>M7?&=CfX&tyZB$k99=`xwD0y(FN z7L}RrG}1^;=u|jut*@_tSOU1*RURwmd!0auVkh*Kj8m+vPN+^=eSJOc5YBaWuC)D~ zXFPU`xyPh^r6kBh85ZwGd=_E5lhGex?gI6gv{rb0;aL+Cs+L^pw0#feUhtiIrhn~>MMp*5OQMKwD)cu&qZ-?t z3!)mG&B~?cS4^C~xX3u$WuRYfhn?0XC40&QI1e4iAhME!1L1@taULYe#M-l4=TSOJ z{^4#++=G8{H&eoYxSK@2d=;Tr*s!)gy5CfiHXPSN-^yqO4+gUh3By((2s26d%aTRC zuX^0)ksT^PJ=^|mW_Fn$-z)KiX0?0b@i%(Ad9ZzMO|l@H(*>O)+jWaBpq!G5YGte{ zn(%IGC`-IacT)2}D4#ROvlV|`^|I9|BHm-898pTzSI^;9Wb%1MXlA8zqEH#UpfddS z^-WrSz+bToK_cYA(quEB+zt!@cA{)A=H;tg8ORawljf17nSTN&y+)8S$7u#Eg~aMB zp*vLJZ13uN2=rU>KI@YS5xW;gz>I8E2sK2N(UeRaXP4_+lDN%_))or6M?$QZ`0VDd z)^z)o&}N$bn{2mfIf(&Rez-QXb@O_%K`NH*?o2$A-(<5*Vo6X}PlcWux!wo3|Z7w@x4rf@GpC zEkD=)-(2)`?*q3BvhN|!a%0+VpPl}-q1alIb{5}pe9Ui|G?|MnioSNSm@I5>7`Fm5 z9yLAU{Fi=Dbaz^-`rdBIp+!Fwi2kMpsVUWZBA zbW)j=>*sXa)#TZhGEEQu)aYgKNd8`hA3J@r%L0$OKjWSWD&bF)q9gh@W|88Mc?i`! zmifr*u_{~~WPEUJ3Mio;|2_EkNf+UjS-l^Wi_RZwF9yhL*4H~z zy$pklUWFqCW1$h1xAI}x0ZQj|olY$rY#?0hJSN)4V<|S8*Bs<5tR;3#4BScc5H2&5*DyUC zHS~`uQVV|1l|_sr^n6tX`P55m(p?|x`$Xxe1R3qEPy74(+s^lpjR`WS=f5rtTzMSM zX(>BH7TqKrvowg&D<|{ok)x9CQY~wi`aHREPGfraQ`I%wGHH9A=G@yh(|;6kn@Q5U ziH&L()lafncM|3N^&AhUd>c=dUp$8#%-ozKv8 zOl$Hz0xb_VoB!}(@Z5wyhIwE4MevD_hqmCEG*51c0ya1A5^Joxsb3*G?8QbP%%1K(s*Tp!I7 zw4|S*qn=Fj{;IQeD_iUtk9?y8tA>A%8y)Gu z$-1&S+{wq8r}#ToCY_;sO2`GTs4&ad@?h~OO)Hi7_H(U)G%pjsisfi3P;U0KK}&Gw zSg1p{RiW>~DC4|XHeE0Q9h;k%- z@I0slJMvq6uQtc&^3~MTpiGjkoXHI^7gX4vTMNng$;ru_CS4-G#4d!pUCTayy2G-j zN&JWZc#H|oRY%+3!9cigZZ7EGaK6}1qQtwCCo?kWz|lZ!-^@JX z@wl}2aC!6@-D{&yM2t;I%&sDy4&t1yH%CH}h$R~WeE|{BSmIgsWsS_VMf_-wmU|~l z0>nv)*vZz2a@1kcw}Hgj2RHET$v&z@^4coZbeHcH1pj#{#M-sTlLI%>hcPhI?qqH! zUue}WM@H0+UnDHouIa=fkyz~t^`EB?)DIkU*}%CoOP5`~zMyl&&A}1Ozu21|!Yaee zW^%Nc*Z#r$Sn~%%<)<>zQd&K$^DOf;5I|5Y|Ggp)kH^Ogy5d3TbM(9FcCc6LoX z7B14k1f-&=56y+^h4;3E18iuAJi-=wQu7?vCIE2+;&gFY3>Qbc?!S4r$?!W4|FBs| z8{GWlynp@Y0WDw((H+wzv{U1Qh^}qU8=)7(BPe(~`S%M$^dDT~jT7{UC*t)RPh=sV z6V6poR7|iiBB3Sn2s8bb5f&P{+pD4z#bf`@g>r9JnyEs>X!ZBou&X!!itw-)87Cxl z%1r)Xv=FoBT7Vg*r#QQWm5nF*rE+$`;MAe7yjNO>6C^KhxuK8^RqeG|D*mbj@#cTB zl?u`OCg-zgy$-#Hp_orS2(b^phO;_|c%BvKbhud~J&7+hl^E12T+@nr4*PEK+y`X3 zjO>KcjLAoy(jSKB{;5+)PLO7EkUUMkdPQ+k>8BoTD~2JncEG)dtFN&~BmXRT4U=NM zOKK)ocLtEx*5bg^_K$o&zDAKpU%qrn+u^%c*@N8=Cq|MJM4-s4(o`etpi*%0FQ=Gb zAT9DM{0okO$RRiTt-gCS)$wEn`S>#qZ2dUL`z#O_ZV~TcZ!?KLQNgYqEAm8BQDCag zEIS3SBTI{C-HTlA5O$i+?T~kA{dk9$Y4g?q(mlvpN}RSKNk*lfB&U;}`A@8apai8B zgr8F<0Sr$(visadC)^H6Y{_P;q&{$p*+7~?Tn2>u8`S+d7sCYZ7WOB9{VT{1`bh^? z9yPdU_I{ggij?W>HmwhX*#>DzV>@L?djP^w&(m zqfm;YP9O$A$v>Nqkt;J|2YYWAmi`||>xX))pANoGh_1aL0re?j#lJB!{`@RcTey;m z0r|h8-OT#4qhCAQZ%aAM8i+yEz4^Hx7k}F!oF|)+TyMBet08TI*JA`tE9L~+v#tm$ zssC}{47LA2mw-(_OSv+x%$~6)PJg>`-j2ZL`EOyzMFUS5 zl;B`xWrfl@)T)*%c1AyZxUwEq(UleTTt)k_zl@9+ZXb^%;*7Lh=hO;5@7P9H7uT3??)B4_it>3u;TeQ z2}W~gV`5;CjeYqsJq;yjhwJ{l3VZ5qYvgwX7hP9GS>(Q8hkF6pDYDT zP~Y$v9b5eku*oq8bPwZnMiMOuK7`~EW*vouhf6s@e4B&vM{3LK;;Y}!_U_L2Wy_JI zl}UK#X7UB^Q?OkQ5N6gpoBeg-x260CVqUv1X^YiOLCs|3g3K}P%Ys&c?S;Pg3C}?L zl8WCpxki>!pWMb;uovfn90+P=t;_y;T%h=G;C(!d_gbxOE7HUN@z0$Vyz}Sf3rDnl znYg+41LgP?>>>Me8h4D(cE;zMLW%Zxxe~a7Wgl=nv%h-$9&j?hrQ=50Zt2-FtkUX; zzv8A?uFRy@La5|f^2vz_D1zA@?5>rUmqQ9GupHAiv3I^*xw&bxE4>yCVSC@dlIdf$xsa+X@&OFJ5(KgR~dm-c4My1bJ5q=QOvRrmT;4>R*>e~zB>&hpYw z5z_$W7^}bK5NH`$*q@%vkJC1i-6AK4OxT^KM7M4pRI0TzNBC;LK>4r0aPkJwi@=V^ zrJquchJyHz+Fj#?MQ~gI()Yw31znObG9rSxAwd3x%ya>0F-2p}5!^;`di2%9MO5am;$N(ee_dbY*={7ZAeJyHvBaE6U4x4V;0y zfJFy{K6V?jARrmMxn|j_Q1$J@|DPc*;PI~BRad{hC!)N(Pty)=c{lU;E0G%Swn8cl9!`r;R+HmC6$;Tv5zwtV|P z=(Jngwp=QG-oKpX%kJ7FfE!8v?qEPRVj?0vX-eMuy2r}ahB02I1=*eG`}?nuN!|oZ zNlPBW=_XXkurZHMR{=@hw;f9@scag?+hU}(&3*fE*(cj9nC8&;PTImA@o#{sMO&6jTNfY5GhGtzY+)$>w>+WosdzB5 zkUv_Ncct*Fskkj);IVj>+dS-5R$qxT#071mfmKvuraVV=~!f|T}Iry)hc=tIm}#0(g!xIle$MpLyg%Ip&7D9e*Fti z=^E->CHs;D_eV3C2#!oZk5h_)mn$Jr?QQ%Bj1PPT%zdQFt%}u$Gp}L-ubb3)k%b$( z=YL|>Txx_Qo;X&L5xV*t_w% zwBImTPb^LDb`xdQ-VBj-hl;l2bYIn>t(h79v;K4yCWBC2!>+>tqiC9;>c51O6SN36 zVG_t-JO4R-iPk|Sau6t)r-#P}b3^wS>WrEuTa0&&<6GBxOULhegitoJO3J31(RtDL z;7N9+nqe7cJxKlvWhU^-dmIvz#ZM+7JyUUaO`NXmFGy(efcp3?r4%XT&HzrPrlx@Q z4bZMi^*YBFwZv3$02yOC?)dTl-^f#gj>~ zL2c+sf}lV(9-I)A z?LSnl;AGC??h|Z`R;YOc@BZnw{2_A#E`tfMSOSdOoT?` z116BAjw{>kFgrU};(>pIkls5y3sHDCz$ zpQQ!iB;z@#(R~NK5`4`c1st1k=n486v$qjYto|dvfq4$zOqP8n&oo%Ubh4Xff8diOIRmo?jbsgapS*YSw7i| z!hZG@*F?7g8VB!`a8uDB9N8>sE0J^AedC>I$K2L1VP7#KRr~)^P|YzDWuG|&9q_6v zs-5`nKZMv2`OLWc%Ioa~r_TQaX@{1hZ^ixN=<9~#d{5P=+UjMI8dLVk+Q9=%^;c-QQR92wc$*S21WryJG4|&NCv-g>cswIvh?@i!0Gc+ zQeGp&EvtTQ>!)~dj=2Pydq{<|n_L>wzXdfj-98d`6=>55K(>ff7&DA^`jWoh>H7WT z<+OJ$WxcV&ui&sh5$j&N<2<$eRuQ{;33@3d0}L?FuQMZ1^ur9-*ISt6KJtc{dr9r@ zFJub~3kw__JS{{;q=Bmt4zmfSskxgU0sDTd=9a^AgZ;QE9(oP$Y#002;GgUBAY#^GhGZ>g^TN4pX`M?vt7z!xq-A7UzkW63iD|aB zwvLOB2YlONhqy}t?diAFlJ<|v5TT!e`4G^nR%reASRIaYBE)tj38h_{vCuR*3aC0>= zp>dA&tO{e%tAE^3(6NUWMjEGgDKah{sVv7`1?1je(kVUs<^xo@Ik)#U&*r%j}i_e1Elb zXM@v$ZtVro@&<4boMdB%_d=PUo1?uiv7VNKUTm1dtD+55#jCk89mgHmM$ylL&C&EI zat~3N>K4HCjMN(*64F$D0Qm?F*E5tF88sfp9CqKA@$grNM`= zyUcziF78$#9)jJ^z{3;lhYE?jc0fdVfya5<46IJz*XDyl)Qlx)!j9caXcU72E%8s{ zgoK3F$U6`A43^2?^R6HMTrqVE!%}CA)?W`Z^Ojp5J38Efc8Ku0GYGs~8LPX?g>=dp zx*9b~kW1k@2ecy)453_AP9@Ew`Eb@4NRAo0Rk2lo<=WV<_^tPD2jtKq<3iPBhj4$} ziI1iXyZ0P`d;H@f=VyDUVszSkGYSM6VX`~)q_pm~39Ac+a(v1eRaYM+lz>|6qwrK6(*=3AAI6`8gu zY1bA&AK=&;z&0`Y`a(d7Aav$XrS7&$qMAW=X+xLJ{x(zFY!Vf)9Z4&3-v+ql_3D+|&WODky8AR)3ww~%FPeZ- z5lz@JFd-iS=10XY{I=4|K|w({V6R_ZUp(hViFp^Bh+`3SBRvg4)(8&sTVsiCzqa~d zh=P+LDl+eD-C{%{ku)@KRBnCE)#Q&Z4{+|w(pnfQT1k)$47EdOAx-CcQZJX7_2c@r z!_Gr|wO{P7u|ud{%awWXq(nqhMC1!VwJ#JC^o`RSG}I+3s;ba}Q)S$Fs}QwX!O_tX zR@j%J_Sw!oV|#Hx_);5C{ybuYvKM`~BJEZl=UaVIIliqcLzqfj(Pn}1!^6Yy8Y2UP z9AX45vI?n2d01InwFp!l8Xwr$0+$eOFZ7S$36>u zHa0dEI&~lNAZRr!oC+Xa?eYk?*??UD4FFaN!+!IGS8GyV+}ZmPEpV{TtU>jNe4AcidJ^cJ7 zsJ;eE8_p2anizE+YS-QGuReWZcA0#L3$6|u{WHR{5}ZX9HCJYV+i_hVqASGCe%#fp z+}vD~pD5QfwWsVnt7dmgvi&lnxIfITR6l|h3l@$^kTwmzH1R1gd z)_9px2IhHuFXs{|>3e}kEMd@t1H$8B)zQvTW6=jQQukD{mVD~g*{RP{eFQ5#00%qTh(7YMB&&vt5$ZjlQ{I2@U_f~_6|^bH zViOEU!3FwF0U&l3;js5*)iy9oSukW57v96fgjTqJ1Bg00 zBBI64U2=MAD&Kr)8;%#=c(DZI{q@`PISnMj6|~HJ`eDHvu-`k21A*pfO~=}+3!A*E zYNMSyAzWuMtM?%^qYE8;fpOVsb9Sv;P5?}k(u2O+8s1z5H!KSAr#5CHETJD|a-~RS zWg)w289cGF~)HhYULT?4555uhP=h7RXX0TSDgV%YJrT(>2~N+xP=>m)90xvB`y8n{(az4b#~X> zvy*gGfh&MXIUeDk(-EOlEq7qqn>hk;!|WAGvCv)X;=2q}aO(~Xy~1Yh(n|doQ*_c> zI@uscfW8&ARP4Eeqx?Ck7R zRr>*uezsfvj)~Ir{Y=4IxG-|W8FSX#W}RfGHLpuYCB^R1uhRXlN)T`i`qEw|^-BMnWfbxl20Xef}}1 zn>dhNi=U92*WjOV#Ux1C3knH=gl;xg8CBRp^Z-zcF@tgLbE04!2goXzl zwgx1Oe{U*KD%>MG$&E~>;1!9JF?96Ji@97BTxcM5gSS3&a@uFmBpWZXdLBLoVH%ik zrbR4g5}dohdLwx<-R5j3Dvb36o;%h|Eq~OibXU1RfU7$CwGwtbQXgpS0C&r+z6-%X z$uQ83J;NgCi%d*RoELM_D}~e9XcriZ5%j#upxzqAL%>NdU=1*Z|Ji;*V&eDoIq^k1 z2=QFM%D6FgM8?Sm^dZ;%S(!Dtm`^C15$+IXk`>%d>F@79j*rAQ)8P)C?~OYF=4cn- z-I}0}0^)47LrCDMC51&nli9rpj${nS8%*f#xFy1L5>icB<%-nk)6U7rz)mG0#B^z2IY6R_Nfsg`8o zuW=tzIDi_+q;qgrgq)s!5!8A!bcxC1&;Y;46hs~OfHJp{VTV>%hi4%-z>Z&I*1an!i7|wJ^Rj-}%!dyj zAeeH%&SYg|m^q-83*04v7U9vncK(*aGm1EBljP#>WMpOQvzhK1HnQF`h8D@80}fq z0K0SpJcNaX1*yF#oJCIz%t@gL7x{v|+f3VOE)n!(NGN;|>oC9>bM(-MP)1onIs_>% zClf*PNw>x$C58IH{9NNXwWQQYXfs42&$?mbzRj-Or)6i~gqxpc=nkXDA)%+?=dT)5 zxcb9mGrKx=bQrRPSS1Fw%4*VuEMG$HfutlkUX$Hbo&iY|0@d-gPaXuX30VKdix*Qq zV6VfvNq~hth87VE3r0u>h46ZdkY6Ix4@Z#Aj5JUzM#7mN3PCL=Y;5%H2J*t?NIvV2@o{k=ZnoJW9O|Hd8De48 z{yZJn{z5UQ)G8BT9XR=J=$&o=Y?b=$aQJC^s#_^#V_-E+%|HZXZ(w8n$_S=?p!1S( zdvydlpNJ8obrlL8#}`Q2F3a)O6rLG=0==t;zkVJqS-QnDc<^FGPDE9}jn7LXYq;2} zC6Hve!6}XoSC0B|5lmfG3Lax~o$(DY9~e3a@I5S-LG{yJ$Htbx>hq%m5zG&3p|Ccf zjL_+?a&rUlmmKZd3`_7n^u2V@0(lic%&Ib~)jZT#0af<{1Y>ahcvfuoV+GtLg_y5h zZ1o&Y!XJEBTuh8nr!o@$4>O90Viy>}l>=!>=6@k+XIo(PP3vvYSHkLlM7y~{{+A(l zwavP5gfi}Up3U_=5(kn@L)C|~lZBRJBqSv7=<{eB2jF&QLFx36WfcY8 z8W8+>F$7^GNDR<*47eIF{VTFoi6uLQN=&m?%~(w3?#}3nm=#(1Dk_44&-clU*S>1Q z?a5VVNxyG!IdgJy5}48PS_7z`p-3`2x*v^So1FeN=i5#={dqjCqsrk|1DRp~^%gk(9SZ3`)u^O(oa6_G?TU zg^PG@yQo8$C?l(?P`7#W12cjrO@g@}lVY%UFjB!t3c%-zJ2i@tR1rr&(@e?XqU zH3W&EL5`(HXBdbYxUih0q(Zah+_~%Sw6$~KNEYkSMloO+knZ{g5tryd>$-Pu z3E9=?FTX1|ij$2Zupc%||F+byj*FsqL~Rx+T1x`2z?|k_C#@ z0CaxC4gWs4wite#i@%4=$kP0v<>K0HcROU;u+u^a)c$-@560kjuqNJn*Ii0Dc#agr zOJ!Bn6tknBV@L1ay%SSJEz-z0Rsiz!cJ6A{4LZ${gLDP*YbA&*ih3?EvM9XB)M+4Kz`3FO7o7UOM64BVcO|Ja?XP{1S3t!Q(zruM(;Bf8z zJ7EMZidvG}O*O+n%6ou~;F>3O0KWf}HC!}u+x<)m7hE{Z2fw^K_c=*6Dm)^>6de(k z0bB`WibZR*Y}FEL1AYA|Jb{C|g-u2Gk((U>Mu;Gw?E=&*Yz`no0aA<#2(eb%_rfAx7XYFc zr)OCjSw~(cgu>TEzC3vIrcOHKF`M*^rwl!xBC?=wuvLG=QtjNT%7&uJ58<( z=XEygsRxphoNTQ5cM_M;2_-MJRpAoV%bwNsrQZPNpIxziy<{$jNgJ@LBYdp`(8scB z!Q-IqBbr&GFw4q4Lj{G4JSgree$LAtXjuK;U2L#D(m?NI^b>x?zt0~?829v9xpcMA zq?gu?yZzIES?f887EHAn_=3YPin_B_Z>M|*S&R17D214IzX6{efFZ0>%g{caEKAn20bqkMrhn?^d~)K?U?i@RWF1CqWuN|Y@L*tmMdg#^X*rkp6GLcti6p7a~r zcv=!7H+T$NKfih79~%p$1GGNBRvujbxA*|z&Y49*H)08vA*X6@}kGsH9poR?B7;$iM zKf*ckT_FCP&n5HBs1l7Ro6%`fg z=XdS$#`33!gRHJ^6cpY(c`}f7D1$cKXo^yw5mFkmB_TD)WAK*aSpq5hoo+jSyxbM| z{K;a%I|;F3pz-jr6ClE1-H=jMO_DK4S01{!9Dx0YY3FvreWHvE0I|IP_4Sft`Lg}3 z3uXIb;F53Nys<1_d+CHw^y;%X!>>O;e>tZ=BO}5h)`u)Kr4CDoK}Sn4n8Yshr3QuPCiz`LdYVS6s&*J1I18k!`jIf*uod(?BCanH3K{ zjgaUn!3o`W#y@inT0rp%Wx2xCBJVZ@mJIl(->gwKPdwCx&1X=UgW?~9lCgbC+PL+D(xXXTkSwQEA)eb z<_6z%QIwarf-<=FjL~Xrn^mwH$WuJZ02rCL+l$?I?<-P}-%bO^ZrJTU%tbP*+PNQmH7~d!Xnl($)^8JyaT6zvC6|@qT>1 z|NQR1ZauE+dY!NHe4fwqIgaBvcQZytZAzSbar;sWE6R@lEJx{2L@kh zpD?R}cyU3@J=c+?`nHH{oJVMm6NMZ_FZM>M|0xa?>|e@cSpaiiZqlik>pxGjR33-; z4CG8EKkT?J_%DQ8zH#ZBHxMRxAWl8C^my(NQx{=I*VV_|Vo&o{KyyiMu-*OjHJVBv zdE+QX7P~xu!wb)9opPHl(ztjvF84R*b?DfN?xKXMTE_Zgd7!gpaYFc{vC+VIpToxg zkv6Gy*u11?(u_2s?MCGoffYc$Q8%*i|A#^+S$}zmt@C(8Ie)=leqwJlef}~Gai1r5 zrxG)l>sT*+Xwp{m6uo?Zoq5H#_t+2@8uI+}i(!=q!*Xrz`ZS1Pw|z|KQfiSBhYCvh zT71NDxRq)B`cp}oJVEP;Kp;79Vq#);q^JmjF>9w};+-}HZY$dZxexM~?> zc!-mJ=gw$w{Fs=S@{QN;JpbADrG5G7_yvvC-!+;V zm9=>*wqfq_`0}F*QZvG`GY3Ld%SJ-9KFP8q@a-}9F50H*Nhwq~AhDqa`P91?D9j15 zvieYq#zSx?{Oa%N&z-;O`{vD$k^C6_6H1$P8U|AKIShPD+M({1p6|#ox@*8BqWxB> z_wH;3@_nSuDETZQrh<8eg9x%+(*ygA3r)5t!wA-A#r2<6pr!fviy~uQpSbDrR=Jes zwl;NEx=1Zz7x?BG*Rh9ZI8$&ZM2bk+K7bb~#8~50-yCq*PD-eSs=#G7_k>kMV zk2WzXd{8i22lo({Q)jv#g<$f+yp2V}`jM|@(q+N7MfqLo*m36awNtyj6V{G%GI|-k zI$2l_hdLpN@{2j+2xyJ~4c&M9tB-lmS3pFxivW(L0% z-Q{(sQaupU{N~iK9A3h8#*$)Vs);+ah zvO>JP!(VSp z#OZHTJKMNs>8;$Y{(fwq06i#q%tH5Oj3&Ow4k)YljCtz)1JD$02sNVTKHMuU%U z7Te}`*OXHHSo_-$zsJ>;cm495`&5SJ`YJpq}|a6P96f87JY0 z>Z<*#et#*B<>jYAgbkdjX=x0o^%xtqvj`5hB&dxua_`g4_z(!(2M*DdSnBAx&sNw8!n%|eOgGU*`sdB&oZH=^aW zOyA1Ci{vYbeCsW@zLomlpogwqBFCzRbo^0;C8A1(xvM*iv%|*a3to&;&x@p z9t=&A+TuU&Y8Pcx_w8ic53bcZ7U69vM+F&q_1*=l0L&4AoEor^a{lsjsbc6_INrGp z!N1^y6QQ?udv|iRbB9cY9>7T4-bJ{uO)Cq!ypz}#m9BK~7 zc*0lSY72SC-?WLoQ_7q4)!>VKfys<*kPmsWYVi~8ns+B>Y&`7DJH%_m9S1)hUe|px z1gtj#*S6)YUJqrk$+V;-%c6nXvT2O+r8GqGYOizZsi3=;1UM5#cSfU4g$|mp@_m)& z`W?Bms@d9j|;jM!LIbdIgh8sx508-=!Y~ zQ=wg9kwj;g5=&~KEB^p>fNYR4oa-h)-Jt# znN?fcRPo+u&Cd8ClNj#3PxcA~D`>b)U+gQs5=*smzwwsl$<*0lwGEaln%IlX!v z0;QwM-ru~LWK*DVKUmG}TV?m)AhWD&W#QhDC+DuZ@me<5y-N=hvdV2rW|`5u|Ikz9 zuA)NzWEr!B^7-ir?tP@b=`l8_TB>jrm3eM_${T zsf;{itFQ5!-IOjeJguwZ=U{H1r|LZWj=w}=^>TmL@4OCHzS;&U?IAw2O_!{X**zF5 zF8)FU=$Dj~Olx;KY&YZM?sDv_&P0HdVVU&%!IyXrWx#d^lqK9v+w;HdIhjsH8EEWz zfVDRHpj)5Rv5?&prCXnP*D-b8PAf#2&pDuzO(mhIg3JW`8q=T2u;+7NE6tx5X$WBU zQ;srun{%7cxws)(3F#q_?Y|3s^YQUEPSE8YX?Ae<@}|aP{vB=6z0k6?XR44zNXHdu z#0LtW(=gumY_4xb3jD@5pwL`z=lon1x?y27=n6N3LRnR+f+XoL`@Y0MXPV37tj^=7 zbBT4pqwg8D-}K89bR4XA>M%W-%`Em=V=*N8k?6C3=@)%+T2zR7Haq-qY$aWtr~Jjs zZ`bWnK0Z{lFy9Tii^;aMlDRUs(lvW(+x>6l2)pMR_f#c%{4#8GuKz*K44Ce&un#!1 zYc-*Olz%OMW<&mEZoZ?T9FJM9?)EO+y?Xy}tZPC??zmc|rAr2n*p;Z!p!y`bLa|cw zJV%lh2kpATc|o?f9fwaK}Er$^LY6p_Z(3EAOPILJ5iQ+__+LI22 z3=bb)$)~T=kXS#|Gv0Ys>u{EHP*upft@e3rr;d_nHdVIRZ+qKrwX3f);M%n@!+GCl z(KTIN^0QL{R5z0Z%vwDxb8H38s^Uh(HYmv75e+g4?f%gp(wO2ICB8Hy-7rWnqeuYQ-658uGt8q1jXWZ>B83aQq*nl zagwque+2Q?(Yaz*iaaG@LDwILX9G||pamqb5 zKr6?t*~8D!tP0$9Kbu?oCl9Ke_&8ij+EZ9p((|rhwr04k>v2K816Ph$iqidefu!K2 zjPt%(L>4XErwf!0rr;_eu7&vHK(#Q7Ym9Mu^rjIF%CCVVMT=2Kd|9d+UR5^~v<91o zqW}He*GAHMqE}M+5|x2DMhW^#l5j+P5Ks>FYRGp$7obDbz*VvM*iLFZNKnZyH1`HIo+FvZ5&J z@^!bu@9*{u?i6|?U+jGNB3^RG?fb*7Su3g=QnGhdlgk zR9wN|6jWf<+$y8QJ2NQYcz^cdSNZPOR~|V(>BCR1x0;s^Nmck3AKsOFj&Mb@8jHKq z9&u4gQFCQqbZJv!J|lW!N_7=aWDg&W%WA%D^78+c1XHqE&dSPa==Qy|t2`M0;gI<8 z7A12u!-ZWZxkZ$Wa<$_ob`hp@Ah5IoRFmmN>U9?&>PNDIq{bi zwOEz8*QL#E@@?O3x>=Ao`!nUIEU!J?B$QizJ8aF(1FpCBB^ZVFH5-sYbNVGqf=(^k zozJZHi7!llMXR6@^dL8-o{hn_d_;7WZ>-VJcC^eBoi)CqIa_3~sCNMvd~~ror_w%6 zVZ&LQwp*DO9=>f2*m(W*m0ukD^8*tTKRG<#^ABB5YCW>#L9oCR6E2Fe%M~=>Z3GKr z6L)YDa*wFLO{wo>uGQ$s*UUU0HmB#>Txqa!-+?8WQ)y=-v!VMaL3fG#Wi^WyeR(~K zOo^?ndZ=34)cd6_$j=6CN^YY@l^qyJSXs&)|G9{BQIM~s6*RQ7a>IlbS7n?Jm3{RI0Lc~0b(GPtSdGSPwu1JuPjLex6|8R+KcaBtB)nEcN6i%GF)w+y?olr_9xI zl`FqXrID9mQ+ueWsNj{!Hz*eb7wqDU!x?WRj1b&Xo*$JVE<-xdMg)%Vrmyer_->$* z6lGE_v6o|Ov}1G6n7_(w|<6m-fK@^ zjyH&Q$%K4b3TjNvX}iK3ctvMcD%)&YGE0-o$ZB3g?-~8kJx%*WjxEpCX1n#`U~{T_ zr&^qU=CDRAH$&IipS!&^*6uIsGwAOa=g8ZDnh z3EHxlM%`Q0J4fYH%TY0BgC5$G#G-{CDaOXeeXmiP<9IFeCFAVtmHd~jt%pZH6Cfi6 zCmTppYicqwDT@=`11y449{m3aw!II_ukCG-QBZLEs&py~b^o9@#|k#{ZBkhs748x~ zxvQLn?%=zLHBo7k=1-vtMr-hZH#hHl<1nCMnFAO)?T+;HoM9GkUaIF$hAodnHU)c>M zz)ekzbQs>JjACYNw%+^Jbn;8=a-B*BH7D~OH46HdWrUoov}X_2xhAx%NKx9{);4YF1R*){ zi10>KWvwp8KaQ$(Pe2wPrJ-TFt0iNie}x4hALlVsVYs~}X|v1}YscI(m4ewT_nG$8 zu2CxdUOUhpSq!RD$o>0sy)n0g_Pw5*30w>3lzE$e#1pSp)UB+|b~?h9%HPW}?B~OU ziFou`nuf!Tf^K-?S7kPfG?O-*_w)6orVj~#HuD{sreA7qP8Kij4yh&fZ`peQY&84k zdSDy+Hx1|XL}9}x?AvP`Uf`VIb!_xa-RpGvka6i9HFWKE4dQe^4Eh~Ql4_-#QU)y> zRV8ANy`2&ojpB*5YBY<;`0@LNP+Km)LayL0hVz%{QL&cMx%jv4Tf*0Z zojhM15G9;^aQZ2YEv>%yzPRmXqmMd|2;|-2zTw3E_aMLguO1Z~h~<|zw}2(t!zVhV zRB*KYA0@cP<3h`V;v~>jBv4IIoNf|N!RQu?3S5_^^igJ4dFVZUv`6t{f^0%dHtX(7 zje9w1%rmHC$e)Kk@<)aK3{Eh}m(t~{w$RrJhz`FLplg3~^l7H=I#sDQU(MEIyu&BW zxn9jI-V@VyY-o3V5E5+HHsi5fIjW#h$MtzyRnxhY5m}Q`lRNw+LfPlNt8E8W<0A^O zB8vA8o;q0xwl-&7vc=x3k>>*(lOXUH92|22J5^S!!%o7--`6))xBjK^$sZ%7N#%>D z)y_^7b802KX=HG2&$6_?=lxa>J%->!jqgZq&mIiz9JGJwA?G@*)6c-6ZC7;7HQj&m zui-3Dbb}LTTO_>CNw>sjUfU*Y&mQeuaJ0c|_SO-r3VSZ+vF?WkjcwE*%}NJuYXZT* z&|}6Y#g6X@l9eY4HfQaPGu9;8hh!EgUu>g(eQ8=1-p|En%_hk2WdoXo)>Faw2a$~j z67JaSyWzS%z)?5zLIkj1VPRR|MgmZm*yB1Z#0mK1pr+NQ7rWTm*;!e;u_=*@17kL% zp8u5DN`Arj`m5e6^(ls)a883giLJ@i=4-aw;k4w~b|2Ui$U=fJjIOf4R{4vLxu+$@ zdaSebT8ewC`J0auR2A&Qniye7Vz?jDDVG_oJU?r~3iJdj(MKHmH$E5yE?H+&%I0@l zRh~W5N@>Swn4tSpu7$sCO_bYAd}FN86)+|W$0%H2i|jT$OE0EV_;l?Z{?HoF2`GXoqUvCp)9yFsknrhAd`ijid$p2S#B_EiLyw%<4) z@tM>>Rqce~bDfOh;$k2d?du;~0}89zkYfJn#iKJhOg`0Am}4e7odi|Z*lR6^gcVDS z`TTjqArdjCEJ2=cB&#QG=5WIz^k?l0O8EYQ8mB%;M z3ta(T+G(I+2(X!bhNs>b-C+x$u*5|2o9lF)`)C9(9`bJQ60N7_wO*<;+xa9LPk6id zc79)-XkVV*n7Ljd!JBi3MjYAvKpgk(PkBx@g^#yrB;-BLq5zctR7J==*SploKuSwg z-RfcWO8KLHNv&n|3~OUt6T&FnyWJ98X$-g}Hyt%cD3Nh1uYuP7wPGjQ*3jAl9%iNC z*~%|J$+ERy=5x}Xe3SD0bQwY|Za!=3Q}(IVx*1>z!z!nrZ|TvjF9MwctYIW+!T z4tSd}7S@HA{@@5^JK?dC2Pyk$%W8^>n~$%HIp@8z=24~`!7dFR@xdh*EH_))9H_o9 zpoh0H4GRg0?KcPD;xPd@L=cnx1dn93mn zVju5&xvbI_?^xf}-J$#9&ntYrYZ&v%I;Yh6u1Vfo3!22%Vlf8)_oiXFk;GbrP;t9V zOScDjPDo8lM}txIxXTORqP?uF=8Jp@e%U>2N2f-6qFe*{G-AtPJ8B!ALnER)2q@MU zw(%boBa|f7coehsC{GeJ=Y?$R_qQZA@nnUc&vf9Wk5^!1=dtAo7H97*WKHLz;d+_( z?!{x|QG~u#-h^Q9r{dsYuB-m0>>yNIJrWSBS= z^kPGv-&(HaR8)Pt&GOO}St*%PX*)BAe}3{dy}`rUc(0-KCoxqwf94A5>}`6g9AlgG zfgAtUSEi({^B%sjIf(z#AMp8n>0)~c(KU2u1H z_6m(P|HlK5QXMj{xrVt{$gNNN(PDlzM8s!6l}$0@;OC_`<)>CljFvmAZoNr!W*a8F z?6F+LpoFD`)X9^45Gv=}lq~Tq&cGyGmnsMI-fwsWcd_LBbe(>t_kwu-RLRBD%rhgO znb+&JK0Dz-b6#4dd*yJ%nG4B9b*z^sn;JGqY?piTyxRW#PoRnza}VCH`%IK zt}D#Tj9SCGGm56n>|%nhe?k$%3y@+!z&Xfwj5$52KZZIlELZAFQ>gh@?k_K?GrT$V z`G+#BsQoHw5{t74TOR3!?D2Ql&ylmQuEj^W^t%CSl$UB7f6;+52ZqOaox9rQtJ9v} zYqPbY()?nV_T28WJVhPZn*NLHcfEO4Oy|9EDgu6_!m;t0#D(;CFC6JieqN}HmZbXm z>5;zf6)Qg{fwiG5p*co%R(l)Se~mmn-iD)Z;lL}-tV>nY#sb-OIp>ZBU`_1_2{#ny zU98pA)QDI=uX#XQdvB99g?#qXSIf_%r`PRZj~-Hc@$P=~8aF>z>*el0Cz^0kjbWl( z1em-n5b9FLog}#uY9G&bD}C-KC#YzOe~~}5zlGniB7^Sqt;q=<);0<0)7>%oT&Byn z{C>QeKS$F0`RT8>4-QmD2;5*91In^MdVOMU$Ej+?Yx6yK;7vIy+RR_h`o$iscp;m- z>s;NwCUjEakD(&))c4yh;ACHJC)4To>pYWK#rx%Y5?*q`Xcia zg;6@|@G~0&_4{k%mE%R4ZLjAW zwmxGVsJb%nu9cd5U2G*lS)!=IV|y0Z^{g}OF_4Kk!~d^mbl}7XbbN6#t0-a5HypDN zpn59TR-^iptesl+LT>485G(w~k~;i}P#azk(yq+<*01z5sy8O`PgyB>3XknHU+ReOPtp7u3_p z1KH!MsDx8BHwa2~R5ody9c>GaFpL#n$P{gW?p+RIV8{=5W|deCQj*IRcK z765+dedAHtuUV^B>;%_)B!Bz^%05QH@)0XmtN@JI6Xpg3mk$nHzN#v%JP9ff#q+)3+R%1j~u- zL@*&mMekdCZ~P1KDx32bi(gyzaRCj0cjp?OX#5bUj)G)spdC@lJS*rCl3vDfI&JUH9WbF`$y|h2_dTo5fE!rznIp&ZH z%BDI1?x2Qga_(HMR`UXg1UZ7@imsFf{ zkI7fL1s~b&+mUHHfsVP{5^2x9GlX33BnB@$7=Bp^arezX1|rGi38+FQ_Akog9DKP& zbgeD8(f|ZQerN!o^Cv68$@vz@3Z#3ru~f(M&L}#`EX}Wt)tplkp&X{dccq54cKd5m zLrb1rKNU>sxFO^<-b%XV39Uz%S(4KyZmn2>qEgx8T{A#+KfL^nDQWanLX}^#Xf8*J zPDVc{ka)+(Li>psNp#hW$&)Ccz7VDZB(mo-)mS;ek9w`*7Pd!4`(7o}sC;-CNwQib zD5Sk?$FtmXIXHYmgW50mu;kvV?m9U&Lx@FK8-X{Hy(m7VnF~jlO_o)A{?n!_kx4PE z`&?#5B4x>URuU8@q$RI8($f7_uhFD_5+B0r?!w#q7^!2P>bnPNofrLXbF<4RD=CYzw9)1 zq4L{axZcZ>UFeD@Q0B;=9`yxSZ^khPwD@0bbCBQ*h6E;PSJgZP2(Ssx7QsY-Qe*Y0 zIg!@99K<(QRK-o##8uexx9Dhed#^H|I$c&(r996}o34*^P-EWHoSuAn3jycul{M2? zD+0kl0^j{iZ$4gf#qU>rs~UGk>ZoP)L+RLKKSnlP>ft`z`ehI88lWZbemIsBjtHKM zUU&3qU5^HwENuCOe%Z@$jj2k72f`uZ!%vG6K0Km7I`Q%rAJ6Wm$0*e7J-um`P~|!w zl%)Rza5H#Cc0~siaytkuiF=19M>tUYnRwkHX)N{M0V#&pybl{C4V@&kjEQ*Nkz18NIm#b{G^nP&XDq_ z=l9I|H^jozF?$YxTW*BTOwU(?W>a!whe!CAu#DctJ+*B& zqD+&_^u=OcKfiZQ`}f?-EPxVPYaE^O>;z{0W=Tm2DkzV*vt6gGe}0TnnP z2H0mNToAKEZ=rJ7mHT+w?w$JHP$C$deckZbCeg>o=TwfPzSz)bxg%49=O1!we)$fx zm(-%ft#w+9>BkmMRogv&CU?|EXRAI(ogmlHOwGQ1^0M5QYJ#_I-aPg3I6bzs{N;Tw zVsN@t#VHKe)$I+t9&3g&g+vrri0NTMfQFqXZ~l{2@w+VU=W}yzxkdC${MXpN0u5L_ z2tkG_q2)Ku+boxBbz7L}>9aNq968_oVA+FX+A}x#>OU%lbz3c&O!_`+B59CfkVNsU z@B2aXnm6Y)94U5Chm1aQ*Q_3ti%UguYN8+@-qUIP`<_|bcJ?nIyPbfAJT3inT$ zI8kP33JxyDqXM+GC{QyezA;ag&1?PdQ*p82HIY_x8Puc3He7#B?9-}7OHM% zIb^YMU>W6=mC!PJc>G{V3Ux8kYdL?bKV74b@y{lPQZMc7L zr)htvU7mLoSuAfDZHDEiN)=stwP*W19F)Rxe>yJpguaOShCUen3Prl*mG*7YP3Nf3OOdfG@aRC7V zVphuDyz$?5WXxl;%1Yvm?pRYqA-*Ib!YJY~clc1Y+YCRVwYjP@7UfzSYxR3RIrz7a z@oy7pco~yEIBA@<%-G)Mk}v;<%nwVo%>px$gJYkBNFNH9&Rk`t=&xlk^_wpl{|gFwsz9{5`&H zLe}?7y~Y~DLo^x!RGw$_-j*HPRQkqqZD}8Ona$eNp!^SuJh8d!y=t#A3!KFDbis z-?!5zRQ_05Vv6hSKkv1Qbla{)vG}UJTHHwwqrfK3UmqI(_Uqei^nR=50(rM!1-u8^ zp@ooZ<^4Sfd>8GB(E!r@_k=0dC`N3*(xho?U-H|A{We!-e&{ylU_dDMXZ12ItDkM{ zT>#c(Y5T1sZ6kKgJNN`M-9J0M+>z&AU;R8vEi% z=b;#2KueUnwf#Ia0#j5zzpWK5Pd0Yi857pBM^r@EIrM+W_U-+zcS<)}FZs2)dlf%! zpf>nz_tpo#J(kL|r`0bRKI+I!%D(aY%eB5u4bJv6SNxUUN1oH|87m;ubO*PvZ2_*q zsB#mBnyw{Bj`V|J3oE%a+}j0CaukIi)Psp#yH7v19|{3Lay->YYQW_(GIYIyZ`Pd> zw4beW-z(=zXk`(lZl3VMn%BnN>qOVeUa*&xSSQLkO0#67TCoaVsmK5EE)L;pjv@&S zPZ^#yAWIbZsS*j9Y49Qei2gCuqLuJix!v9ZQ0{_@pI;%~&a>}(weDq0d}_&1&ACf* z1qT@&WDLzC=XbEJ+P?AzGx=<{^!(w;r^WlSLClc+Rpn3`pUrYPh^h)Z%-X;I z*siS(7OfUmgp7>FKIN!q;Had|-;kJ-oHu;M)Rv_FV)?d~p^uMVgCM1Sq%;o^W2#`R z`<88OCrvd%n16iz6tnzcXJ(|=s$HfO_NX)Roy=F9j{fsj!*S-s6rRZt9QMpk^Vq<^ zfO(mDMau`33atX_m6khugAZwrtX#Pg=<(2yTEUPP#Lou}PX7CsiIS7I&2P7PDpO4+ zxuGnC=w{YDkwtp-xD)a^Zw}oVRJ+5Ef?2kpf7^{+<<=7GBsfPs{_(+V(<^_yH}mtj zxcxfM6`3Q`S-U1U^CnEwq>$WK;}jt;l2zdl zlb3vMic5{+R=GuyRCfj>C^xACiH}#-`4hXsZhIczqqddH16c+>oziifec9smS%|563|gpJe#f)IeEy46>2;;m)cpxP=Nyn{_4%4 z{rzgAGG-s{H$hJXe0$5rwMH#^x2j)vo_AGwH}SRj&x-fODR6e3dus&POx+oT1Vryh zm3iq9V5!p{EUXw5{OjUBN733w)rF%>u@9^sBq?yzVt@Iq7QWl|Vdy^}@^`DKp;T4b z)F;+M7y*b1XC$$ND8Spd;{kHEE!1dkT@}iPG9CiM8C7P$kH+L8B`J#6N{to@lzh61zO%AAIreBgusLO_Q#dtkj8OH>*_M$ zoERUstb2ObWrb&X$Wxk9&+e3+DiWY8$J10<_vCh+B%Azmq|`$CKmhFH-h{Y)ZcwVg zXk)6)LAFz!*Jo{uA~>Ze)ql8G4pU!x(P%CnRFn98Y+wIA1VC$=8$5jhIe6Vp+;yI! z@<_+xI1f?>CMnMqVXv*Hn>Wy!>Bj#)p5FZGa1FnWa9s{;OC@uK*zD|V?Wz*=3Tjqvs#%qSmRDM6?yqR@&nc)y zoPse+ap(IaGu zJjVAE{nzmiHxW~4(JIaxZPA~?ZFJI`Z*A@ybIvBmo}!n=NzD@e>%2wMtP~|$ z?g$aPM;-^VN6bz_K)uD=#$G=8L>ubd1RzEKkYrEp-jn3Lzs__fp0`%^kBH+Qax=Qk z1MR=o_rvbOt55lg3Gdocfj7Te#U zcFOP8rPx)ZdN|89A;XV)Uhh?(pQUFkx$2U%Mu__eb{vKnWUe^idRqlAJT>q-YRhV2 zS*^2SBDMNt=r8mEKq|4V7OgqF|A|od8q zKjDTH!i{%w+^41AB>W0L-8`Ar3tS@N#-(;=J^xmHkDW1UC+%2>hKLxBqxnIC6$*eNWWA>VlRpvlTbPZ~YE?)QWo**F^guKP>sR zr09dOxWDkfS>5Z6D347hqVVsz`V~1O8&$s+T5kT!_!>9a`)E!Xunfc0%@O`Gpo+xndd2CAfb?JDsFQz9dpNKwD zIQCG1P{?YdGX3}PZBWsJ_P-H3gYuz`-i}c{=Lql#xm}KKkrrAzt7eahv0cwvQDk{DX=+Sd9 z6pQRK?Weqd?+(Gf-Y8iorNVW^vj~!U=AolWh}g);yhCvZ5=}D}TE{5dJVZtIXv8j4 zTcSf@(=M8;T)4O}YhTrsv@CyvDx0$($mc*FB%^H7;W5i&*u&rckbfCv-xGxlz_GKl zvx%VBJt&20lxWH6FF*n+%c7q1z=7|uYPScpJ5856G=6F9H-``my72fM0Vi)wl~+L@{ZrCUa( z7xIp%h|UQ2l+?T+8L;#4ytnfE<`NIoY9XXJ0EZPv9*U_Jfz2ev#>HLt@hSMxpsV?w zQ%?!XNe*l75n@{Eq|vRzdIuX@J}UM>re`%hJ+3-Egs)lRYc17cQyGm0em8H*$jg5n zAdwVIP;ceY%_K5OKXEOpY$jE<>Fe{eQxed7Ltl6X_!TS=X~z`QDJBM+#sLOCg6cMY zFAcwUZsU?*4*S7__P7ESJ(@2`%Sdh?F%NUVQsnhau`Fv{%fX=MV;u(dCKr{vDEq68 z4V%CGl*7hnkbfBWf#CeS(42lNg^Dz~e9TGWN3)gVhzCi0RpY^I3VKO+bN9s6R&D?r zy3vMUbvyxzLhsD}VQfme7zn?GcPRkMAh5@|UX0o{7K5~%)o#kz^Tuv*@j`Vc3DORj zSMnG-(`hzBHMrbZz5M3}H0TtkOmkam+(Qd%1Vcsx~a^}x9=RH zS9@hbx_lZ_r~FszJj69?fC&KNzN@>NgLPfUJSl$%N=$OlVnK78Y}Nc!JwX-2f;OZC zJn*Ezo@U28u$-K4wT*V7L~7obuOe+7DEp2B zC9a1~16J_jf$rh3h=?Ot2`IsgLNsnwlI;&XE2(qCDy%!S(&h&a;&X^G*#ef@r`TBKg zsO4?rGEz1H5x8*S0s?d82g0R|%g6%o3MyLc{e*jlkvLN5|;!u`uv^d6ur+zJS|P5C(K&Q#{dr-T>oA z*VGL@*^Py?)AZPkJpsT%XB78K^Y8><0`D9x4;o{QRiNC%CpJn_u8mouYXz`)6~b9% ziTO8p<1L3h=A03uqFFbIHsiPhDH`_Ot#kG)3W~H4tczEOumzR@Q+c!-DKuWf+K-V3 zp}yPHus;4Ohl1bqJUv|zu#IR|nR;$qNAe1eio$Iy15n8`EOd*&P{eRLEdu|Yyf4bx z223gZ;h{41E^?ds_=0MuHjDz9m4k?8- z_cjV~*y9gp2yBJtXP?cuz6YnohsI@I2cIaAj^qEM06ztf0?(I}TxLi|iaS0s0j5E1 zo(D*W&W%*$^(arXVEnjT_#>3&h)xiUT%ik!MaoEAqdXU85M<*aDlQnFs-R7KD>fc+ zF$Q86EW~s+;vwwabj!xT_CEaKFs$Kd1FFLOrW7(@&S*nIIc%(+)OoeHApcCsau-7w zV@Uf~w?icIGF7&teS}gL*6;#^P*ClJ@r-hG;2K8=3L@xq9qW?CfGF6*#p{1rE))X$ zG5N#?T_!%nPVp7^HA0FXZyk&y=x{HTHlW+PnwD0#&}{}s!?XoyRBpn0=>+bZmme|0 zI^SP~HkbmGK7#Jt`G}TMbLYS|qnFTR?c|&gk9FcIILF%Y!dYTDc}2Sf$ z6PV{3I=TmLs0Pvo4vP4mFM!Cb92~N?S9J4tEYn*yvV#ey|E&-1H0*Elbd zvOoTFZXgV|)3`86JPtb`WC+?d#`u;W%wnNxagMN(1!x+NI+TriP+we;?@7`dfX)N_ zCP)J_&?6>np3*efJuSCJYXCAc^7d6z#^VMU* zz!T!&;J~Byw&mE}Xy>1>{@HnzzSsSYR@h3{4q}c@V2+%aL2P^Is>8>6 z5w)+;Et#L>K%B$=T?u7G01J9Scfy6C@JOACcleiy-s0I-fX$Fcdy78=m@H}qhk1wtdi2Yf2>`L%DDiP zE?@(0CVvJtyjqZOy~IoBS*C7Uccp+rY7Csd-UqnE3n9FHGYD+MPvwYzu|YU5>F8PANQXe{(Akg zqn|&q61tE8e|3Wx15wm3n3w!*Iff*!MtBr8w5$y;cZWb(cFZ9VkBCbT`-qMx0|Ns= zDID=!jKun+akb4aC*^niZz$uSVZLWM>EyzOT*LzqCxrUocLc>?CR7o}0#zz8E}q{3 z4H54k>P|a0bCVP;Keho=@ll{kv=$BsrT8l;R9?2n`#qMC#5s9*cy{kLLQn(~OOriG zP1@tgw=1b$7%3by$&z(4e2EX2eZZL9Sl<7%L5eUkur2YT6~e|nX@6}XpZg*&^AZM* z3sZz}p)G1XIMK)wKb_W)_D5h3VAF~1+VvU2sc!mr;dxsNT*LTQuuF%XbaWIn)ENX1 z51VDU;du)bwW}JJ9leYcTg9LizLg!A6Qn(7 zu*EaaR~sP_nvPyhvcQ3h5_FQ*B49-4wL)`nQxafaa5J&I)G8l+s&VP-(7i=s_q65y zz?k?93oA92A$nR)K8aD(CkG)3@S2`>b`x21*j^SE0f}KveHksHdka!g;ryho!x0jR zz$7WXESeT_=vVLNTX?RYmx*3CT%em8dq=M@&AN4Q^t&j$`aDRt#PyG$WSM8zqg0+r zB28hRkS(EaMesFoTBD9=`?ZX24FkMUY1R8Hr#v*<5j`VZt{#T&tCCg)0JLPt#|y0> zu_MSNT|jaI?#@;Oi-W%eziOXq9et6~z^VVvaQY6ddDLev{Su`ykKMiHmD` z;UBy@Hf`KkdGAmXew+x!KvUWG(Ct;0*Vs8=_JKdJm&JJvrxuj_*AO2Gu_3<1-pGCs z>?(T9Svaa{fRHk8*r1xXdWGU#YySNh+D@ourrC;#0yB$^h1*jm9!vQVCFt2ntHMJh zua$^bE}!^326^hO2aMhr-xiB|b5mlzPnoiE{0)P0XV158#)1h1qxN8S)P+&!$@Ct7 z2fqeXP}Po=OTnm0avP!?$Q$FOTyPlSl};l$eDUH1f`EJ=Q_>-`q_99@-vPhX2xc0R zz;v4q@q-7+yeo6}!g&ZnxZaJAfwUKsA5KJLs5yvAeZZv^(n!1EACZBjBV_=+k-MSi};D&SDnmEGIDZ1F%i!-xjc6*KRN>wIAezJ3MWOTa6fh=5z@++ z4E9RJheh#)gg$s6W?Z&*L5JFF43SfDC7g(u_;OPAc75l$jMb!WdN@{;7Q9cw_`DG4 z7q=oC+=GLz7zfE2Yw-vC;7Tpj$0^zbZ27KkVv+>eE8HWUsGVkgTSENo^r)4&c_Yp( zdQ!?2G7U)(;j7(v8#(9l>+8I?CE8;ZBbkoh7+&nWdLQ>oBxwQU7`K6Qq`7dury^|p z#!|nD#EdcI%otJfv4JCv%S78#P0Ms`PNg3Fc{1bn4W9yB#93bvHp5$7`_H(-_&JQ$ z0oQ!x(j}o#?rJvq;T;)|LKnv;YPC}IK8q~BjeOwu59?9f#_P3KIrgb$+r|p2^)JMP zZalb%Gpgr5AJe4Z=(Br!bM?TN(&mF4(ppzZQlF^aa6%*^5s~sk2Rfwtp zKFTcREqc=8rO{v^T4*sF!+(=-QuK0yGM*eHvS>t)xV4G6BLd{)3t0#U zYQCS(A0zb9U3VshzxpyvvCN~k!>OaJ}{M+Cjk(stLhR*iIH&3%i@b`VXdFQXf z+8_wq7vWZ{LUjhFdR78$hz_V`>X=jOF3@35C+qBvI(80s1cg{x$VR9(#idh*RD0Dk zaYt|A!cR-n$dA!W4UE3OC~uxo_Wiv-+}KUUHM6WGEfNLA<>C~CCtnIXOe@JJ0#1rT z{Isf~iFz0)pje4mT+@h7OG45;C^TJma_P z+RiwkI^*R$hrx`0?==+)if*kp zZrxgX(7AOiKZ{Zd%A9mmVQ&{Nj-p8eM#u}CaRi0C8~G4qmpd>&0H^&8_f^^hjD%Ebi@v3I=NkPg6< zH~sY&aR>RDoBgAk85q>ir^d+H_U?V*bK~hlcqxrU^;;RZx5^Bs1=y<3^viF8&cYF; zn)(dA;xlK?pm^irlA9Tjg24Ijsmb@4chS>py*|~^$R?A=A@KEiR<8Z<;D@4lDimh_ z@dgc#i;UYJxz7%8X`Z)xveQ&&GvDy1#7!&}POGBe?|<9;bFwTVoqz?;8Tm(SMqB5( z^m4{ha4S*SK*~7Fm6O=Azx=ryuPG)Qmwe1~tx!z5IHb_s5x^?H@N=TplV$(W`GNLM zx_=BMjQ_cml0a)mdx1Do8bnliPIm${r1g|L+vHD z_34_N@$^Q+4iS_bSmoI-8B8}870N3u>^yKlQ1~9_ch3U_jDP!2C$+eY-mDLVYXrR% zS@ew?HxTqi67@=zBOWoWk^c-_*wlOEZ#Vw`KBG|6UjO&>-5Vrs%2Qf)F$O$)!@vKG zV^?(fpMm3K+y3`q1=}UEn_r9c|9%MiPF9SxhUy9`u}SGeCG&qz8Fpk33b+sWyBq1n zv+st)l1)ra0|Y`f>WEISo778xfBy|s8`qyWE*ZibG1)AbRZ~mbl2IG#msEV<@A2hv zj5l1T%S_Z55t}|EdF)l&+wHS6#mhKb)6U&4-BPa_iI`%1Qz`rTvDd3}cDI|)a{C7s zhTMI`vsvqk@!w-{R5LqU5lT+>cpw;%*=H%axR8Endi3*oV|95e09xK?ZIqXl{Ve@5 z)Ze{m@4k-bh8^E}oU(8aJ0mZ*Rlf0%`PT+Yh|f?<2kq+YDcmvDX>(uvIXP*uk6;*j z*ZjQ}O^OkjtF}kmYkW-U2zco6IK^k^|EuiE!=c{y@U0MXTIA`ZA(aMWDa&z4*Qrnn zVa6EQ9gLz7;b_%W(V`rg(Lwg6Y$@64&}mVoL>Xk6lNOSqdn{2?x$ln*^_=Co{nPXG zWc=p$`~E)5`+48b+xmyb*~83I$5&1K{jc+}J5Mh#(2wcae$nQ(%I_^27fx2xCh*Oy zF68;it+9-*O7(Zm`{s6LyK3%~k3DA7VWVUKB`Ht18-8 zM!j0#Xi3ro*`-s@GWn`qhFEii2chR%=Pf)kA`}~v7G;#LAC~O@V!8Sa{w&GzfId03 zs(`mUyq_f*FdZ&A>*PNC`p2SZO5bXQk@Why@|>OAcjXBvI-2$Il!E2!*w??h#+T>s zx&H8JOVY}hkL%*&_bG1mkhT1z+_gc3+JC^dliQSIXU!}I7HiCu}%+9%IT`C`T>VC_EWoyd(Y_ zp_IE0TEwWxDyhi-1^=#pt{GtlP;n%2Mb7%p5)xn|Seee1^I^3AeWyYlm{)P_D z!VloHcH^)~%|L^hA%>Jqa7qH@ReQ^fPAyp_k?pxNvVf1q3{m2RQ<~LIZpLOSEC1%a zq~e@E)hgLC7)|KeRT78|}shqM4sK}VQY+iC_EkyStdz8ARS#dG33hWX)haq z3B_6kBUCCTt`sKiSWi7o7#zwBm^3?diE*3ad&IyNMjbdjMj&|rh`P~M<{&!t#i1S3 zd^8Vy7=c(#rIY7{K@|FtIpX4>*zZo@BJT&iIZm4?Pq_AJ{H4S;9c+C8W8rf3^v?{g z_p2)kWYer%F2;E!pV^|HDMAC|vu;}0JP8{oN)b;(EZm>@iIJjAQOk;NzT5Fgv*)l2w$Porio}6o zzqRg4QDJKL;|3jvqJz5OIn4__?iqFa>v|g3pIXxCJaC}w2|k#;El39Nu&m8S4cK(~ zM`LDU>+ANiSX;_tQ%?v_e$7eLzGZC9^RSiUmu^rdkw|w#vIelBF}o+sR6<){e@jbO z#5U;P`Wndk_PXopqWW%l3Dq=d#i&x^+zT&$a!s7P;k%r<^y!=#6de_nqk??(9P~_H zoMnKcbFI^+vm1(O>)Vj|JWMI%_J~xcz@r%7<{NtwQzwISnLZklxrG-8cRs%pgZdpC z4=4e(+m2@2<|MD$716659?O0mPhBH%7OS@L0P{yR*Sds05ml|hz_+gMLNm)~0Bf-_ z4bmsy7if<$I^q}mCgPGbHS1NF?*)Ps{eW=WEbj(swI|s@cjZY&Vx5-(z$FS*DVhcb z23lG%fyzvMvmNDgY8+%rPtwj)k9pQbQQu*ZkE2r7iQ(aN*3H~hUsY=3nd!n@A55|N zjbqVyyL(^8GW9<31Ma_nCab9G`Z~CiLCdV%Gn8HIq{oc&5tl{5kHwK%zV*$(Bxn?( zkg~Kqbp?t;C4Qu*#__1ul*^8~wLJ1^L!I(YOkaG_hXPtF?I+Y8=J8=4o+;Q4afD65 zu3+xDPjF3OWIxt&tq8gJz<+edSBp7#S8!h2pGc`?p~uCb=uz}9!H3Rx7-vfO5T0Sm zWby+$#=|R2bJd!=cL}RStal1lkWOnLT&dwtCt3-lak!_^yd=Kd@SFE>CZNbkZw- zwI@#as}PK!)p*9R@J!J2_tS70eJI}OaN^T1%b{s~{~|JoY%VL!o?!fe zre>3c1)Mo5tE$2f2z`819~;e>xStU$O4k(C&AT`bJ0;~YZsk(r2x6v*-Ud+u(Sl=3<-n#ab8{tNDz;PC_P!YcuCjgBMm$!O z1#626FVf|O>hic{xo2l>311APpQSLY#^T)yDVn6t1!$m2hmEMS^Zi~`Qh4&m4!QWW%(R!NWD3r}Btz>C2W zHb8yOo|R(~vFPHB%8m_-s~Dpvp!KVn+neOWVv%Cg97+_hw9yeHEMu zRvieU)w9p}K_zF0g+L5<-i&x`-Cu9GW=$2K)mG=4jR#D0`9?>G*Ge{N?E5$Pv=f_KFNay$6j9=#(2HwyFS#UvzfOHhR#Tt+;_^NHHhl?`FjMo8??)d@e@u>V&J-@YHoh57K=0|x+)qY1bm3>C!=Z!~9AdB;W@Rx(i9Nvb*7m#)+rad1A{Mvg+2_s3}4Eyy@lC z42`st$kExOgHH($EjmV1_q#7?(>AtZ?}Lkr3r2k7djRhR=RCq>t?1k(UO!|Wpt!SQ zS*m07*r}my$Y!&5;6Ko!g~h}Gn?+cPSmV1D|42Xv9{mv!qNcA7CG+=WfY2IwIK<7k)o@)Bh)z`;YLf?)K$g4e3oV zc)yTy@7lGs87d3p<)K-HlXyOw8SAIi;p$e$6P3duPj5;DODJ|botdI}`^;D-M06i+ zJBf}np5KoO5d*}sTxv!&VQ<-o3Y_;KQqU4Wr?akTjN}KR`p1zUTauCAKOWI+Ta-W} z0K%r!W;;J9&s?b2`!cYt1^w}0JP{~^9wHfGNC&xfl=L zg>gc3b&IqJA-`2?@ZXYVh?--RkTC{u4VFy9(VQsl1gqBoPOsu-P8kT%&os4Jq zgKMHQ&pT#njx&p&Ib^5!FmLqb;RQlZHRx_gG|e4AxA*?>bUovi@Ld8QSyDW3;fTs# zlx_{v78veRoGW~A?@YKN1Hv=%1wMvV+yY|0Kkr}H*mjHb-l`NXt;O%CzjHm$cb J$un{b{~u1VDvkgE literal 0 HcmV?d00001 diff --git a/src/_binaries/Converters/testsData/mysql2puml.svg b/src/_binaries/Converters/testsData/mysql2puml.svg new file mode 100644 index 00000000..35dbbd03 --- /dev/null +++ b/src/_binaries/Converters/testsData/mysql2puml.svg @@ -0,0 +1 @@ +customer id : int11identifier : varchar128created_at : datetime6updated_at : datetime6learner id : int10 unsignedcustomer_id : int11external_id : varchar255created_at : datetime6updated_at : datetime6learner_attribute id : int11attribute_id : int10 unsignedlearner_id : int10 unsignedcreated_at : datetime6interest : doublelevel : doubleupdated_at : datetime6attribute id : int10 unsignedmapped_attribute_id : int10 unsignedinternal_id : int11created_at : datetime6translations : jsonupdated_at : datetime6product id : int10 unsignedcustomer_id : int11external_id : int10 unsignedcreated_at : datetime6updated_at : datetime6product_attribute id : int11attribute_id : int10 unsignedtraining_course_id : int10 unsignedcreated_at : datetime6relevance : doubleupdated_at : datetime6id0..*1id0..*1id0..*1id0..*1id0..*1id0..*1id0..*1 diff --git a/src/_binaries/Converters/testsData/mysql2pumlSkins/default.png b/src/_binaries/Converters/testsData/mysql2pumlSkins/default.png new file mode 100644 index 0000000000000000000000000000000000000000..d5494d9a3bc8a0d45544401420ccbfdbe4c23603 GIT binary patch literal 952 zcmV;p14sOcP)^?c_3(XbZ~PzFE4OxVQzGFZEP-MZ*6wY${zp#11xD&Safh~ zVQzGFZEOGm0001ZoTXK5QyMW4{(iq=IUR)&1<`ie8)UR79R-!D__Y)67RY#)Tyu#G z{q^1C4uo20t;{gVWp|%_ve}o@Of#iT5_`K~L@1L4g$6xAh`B%*Vl1b?M=+CSS0R{; zi!qQ|YBVaCay#6`*!OCU-)9M$VyX+-FnO92mT7-M-`ummd} zK#7cv65xk1%QEm`51fovADT@lKUB9moiqAXpw;rd5{hV!MV_XX6Y-RB1S6>+RXky8 z22W^tj1{6Fx-m(t)Cm5=APJa==p#avg_5piWkTxj!o=|sRWdY*$hlTwThCIvSfvx+ zr(OD#ucKnk;c4$KwjDDHADn>id-S~v=Xrb_HFtI@IH zwJ8ETq!*sY$(}kIH-ld96_H}IXVHgDtaZMux0yx$l&c(yGs|LdbNOv>v5^Ne5tsW} zilJ5}c?YGUtRPq9!d0i@bIJWGhok*y9x>DyvfNcZ`s|Dg-=2Iws(8CD8edC$qb7;;bdEE-ILQg(Men! zg)*|8vFy5SyIrwu95Emjod&fUrJ%5L;((fe&Gl-`4y^gsHFZ#L!XtzP^+ZNl{*lpu zKxuO+^IqnGvpmyU@gYr+ODeB>{u80@kvp0^Tys)CrMugaV*02kt!D=F+`^{yVTUlcwb?|$r;z{v01-( diff --git a/src/_binaries/DbImport/dbImport.bats b/src/_binaries/DbImport/dbImport.bats index 87539ada..c8b72c00 100755 --- a/src/_binaries/DbImport/dbImport.bats +++ b/src/_binaries/DbImport/dbImport.bats @@ -173,7 +173,7 @@ function Database::dbImport::remote_db_fully_functional_from_mysql { #@test export BASH_FRAMEWORK_ENV_FILEPATH="${BATS_TEST_DIRNAME}/testsData/.env" run "${binDir}/dbImport" --verbose -f default.local fromDb toDb 2>&1 - unstub zcat + unstub_all assert_output --partial "Import database duration : " assert_output --partial "begin insert emptyTable" assert_output --partial "begin insert dataTable" diff --git a/src/_binaries/Git/testsData/upgradeGithubRelease.help.txt b/src/_binaries/Git/testsData/upgradeGithubRelease.help.txt index e40168a9..926ec014 100644 --- a/src/_binaries/Git/testsData/upgradeGithubRelease.help.txt +++ b/src/_binaries/Git/testsData/upgradeGithubRelease.help.txt @@ -19,23 +19,24 @@ VERSION MANAGEMENT: --version-arg  {single} - The argument that will be provided to the currently installed binary to che - ck the version of the software. This parameter is needed if --minim - al-version argument is used and is different than default value ([ - 2;97m--version). + The argument that will be provided to the currently installed binary + to check the version of the software. See options constraints below. Default value: --version --current-version, -c  {single} - Sometimes the command to retrieve the version is complicated. Some comman - d needs you to parse json or other commands provides multiple sub comma - nd versions. In this case you can provide the version you currently hav - e, see examples below. + Sometimes the command to retrieve the version is complicated. + Some command needs you to parse json or other commands provides + multiple sub command versions. In this case you can provide the + version you currently have, see examples below. + See options constraints below. --exact-version, -e  {single} if provided and currently installed binary is not this exactVersion, - This exact version of the binary will be installed. + This exact version of the binary will be installed. + See options constraints below. --minimal-version, -m  {single} if provided and currently installed binary is below this minimalVersion, - a new version of the binary will be installed. If this argument is not pr - ovided, the latest binary is unconditionally downloaded from github. + a new version of the binary will be installed. If this argument is not provi + ded, the latest binary is unconditionally downloaded from github. + See options constraints below. GLOBAL OPTIONS: --bash-framework-config  {single} @@ -69,40 +70,43 @@ --display-level  {single} set display level (one of OFF, ERROR, WARNING, INFO, DEBUG, TRACE value) -OPTIONS EXCEPTIONS: +OPTIONS CONSTRAINTS: ---current-version|-c and --version-arg are mutually exclusive, -you cannot use both argument at the same time. +--version-arg parameter is needed if --minimal-version argument is used and is different than default value. ---exact-version|-e and --minimal-version|-m are mutually exclusive, -you cannot use both argument at the same time. +--current-version|-c and --version-arg are mutually exclusive, you cannot use both argument at the same time. + +--exact-version|-e and --minimal-version|-m are mutually exclusive, you cannot use both argument at the same time. GITHUB TEMPLATE URLS EXAMPLES: -Simple ones(Sometimes @version@ template variable has to be specified twice): -'https://github.com/hadolint/hadolint/releases/download/v@version@/hadolint-Linux-x86_64' -'https://github.com/koalaman/shellcheck/releases/download/v@version@/shellcheck-v@version@.linux.x86_64.tar.xz' -'https://github.com/sharkdp/fd/releases/download/v@version@/fd_@version@_amd64.deb' -'https://github.com/sharkdp/bat/releases/download/v@version@/bat_@version@_amd64.deb' -'https://github.com/kubernetes-sigs/kind/releases/download/v@version@/kind-linux-amd64' -'https://github.com/kubernetes/minikube/releases/download/v@version@/minikube-linux-amd64' -'https://github.com/plantuml/plantuml/releases/download/v@version@/plantuml-@version@.jar' -'https://github.com/Versent/saml2aws/releases/download/v@version@/saml2aws_@version@_linux_amd64.tar.gz' - -If you want to add a condition on architecture(linux, windows, x86, 64/32 bits): -"https://github.com/docker/compose/releases/download/v@version@/docker-compose-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m)" +Simple ones(Sometimes @version@ template variable has to be specified twice): +"https://github.com/hadolint/hadolint/releases/download/v@version@/hadolint-Linux-x86_64" +"https://github.com/koalaman/shellcheck/releases/download/v@version@/shellcheck-v@version@.linux.x86_64.tar.xz" +"https://github.com/sharkdp/fd/releases/download/v@version@/fd_@version@_amd64.deb" +"https://github.com/sharkdp/bat/releases/download/v@version@/bat_@version@_amd64.deb" +"https://github.com/kubernetes-sigs/kind/releases/download/v@version@/kind-linux-amd64" +"https://github.com/kubernetes/minikube/releases/download/v@version@/minikube-linux-amd64" +"https://github.com/plantuml/plantuml/releases/download/v@version@/plantuml-@version@.jar" +"https://github.com/Versent/saml2aws/releases/download/v@version@/saml2aws_@version@_linux_amd64.tar.gz" + +If you want to add a condition on architecture(linux, windows, x86, 64/32 bits): +"https://github.com/docker/compose/releases/download/v@version@/docker-compose-$(uname -s | tr "[:upper:]" "[:lower:]")-$(uname -m)" "https://github.com/docker/docker-credential-helpers/releases/download/v@version@/docker-credential-wincred-v@version@.windows-$(dpkg --print-architecture).exe" "https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-$(uname -s)-$(uname -m)" - + COMMAND EXAMPLES: Download docker-compose latest version -upgradeGithubRelease /usr/local/bin/docker-compose "https://github.com/docker/compose/releases/download/v@version@/docker-compose-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m)" +upgradeGithubRelease /usr/local/bin/docker-compose \ + "https://github.com/docker/compose/releases/download/v@version@/docker-compose-$(uname -s | tr "[:upper:]" "[:lower:]")-$(uname -m)" Download oq specific version -upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 "https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-$(uname -s)-$(uname -m)" +upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 \ + "https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-$(uname -s)-$(uname -m)" Download oq specific version correctly retrieving the oq version and not the jq one -upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 --version-arg '-V | grep oq:' "https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-$(uname -s)-$(uname -m)" +upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 --version-arg '-V | grep oq:' \ + "https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-$(uname -s)-$(uname -m)" VERSION: 2.0 diff --git a/src/_binaries/Git/upgradeGithubRelease.bats b/src/_binaries/Git/upgradeGithubRelease.bats index 4e6184e2..5834ca31 100755 --- a/src/_binaries/Git/upgradeGithubRelease.bats +++ b/src/_binaries/Git/upgradeGithubRelease.bats @@ -29,7 +29,7 @@ function Git::upgradeGithubRelease::noArg { #@test function Git::upgradeGithubRelease::1Arg { #@test run "${binDir}/upgradeGithubRelease" arg1 2>&1 assert_failure 1 - assert_output --partial "FATAL - File /bash/arg1 is not writable" + assert_output --partial "ERROR - Command upgradeGithubRelease - Argument 'githubUrlPattern' should be provided at least 1 time(s)" } function Git::upgradeGithubRelease::githubArgInvalid { #@test diff --git a/src/_binaries/Git/upgradeGithubRelease.help.txt b/src/_binaries/Git/upgradeGithubRelease.help.txt new file mode 100644 index 00000000..529554b4 --- /dev/null +++ b/src/_binaries/Git/upgradeGithubRelease.help.txt @@ -0,0 +1,38 @@ + +${__HELP_TITLE}OPTIONS CONSTRAINTS:${__HELP_NORMAL} + +${__HELP_OPTION_COLOR}--version-arg${__HELP_NORMAL} parameter is needed if ${__HELP_OPTION_COLOR}--minimal-version${__HELP_NORMAL} argument is used and is different than default value. + +${__HELP_OPTION_COLOR}--current-version${__HELP_NORMAL}|${__HELP_OPTION_COLOR}-c${__HELP_NORMAL} and ${__HELP_OPTION_COLOR}--version-arg${__HELP_NORMAL} are mutually exclusive, you cannot use both argument at the same time. + +${__HELP_OPTION_COLOR}--exact-version${__HELP_NORMAL}|${__HELP_OPTION_COLOR}-e${__HELP_NORMAL} and ${__HELP_OPTION_COLOR}--minimal-version${__HELP_NORMAL}|${__HELP_OPTION_COLOR}-m${__HELP_NORMAL} are mutually exclusive, you cannot use both argument at the same time. + +${__HELP_TITLE}GITHUB TEMPLATE URLS EXAMPLES:${__HELP_NORMAL} + +Simple ones(Sometimes @version@ template variable has to be specified twice):${__HELP_EXAMPLE} +\"https://github.com/hadolint/hadolint/releases/download/v@version@/hadolint-Linux-x86_64\" +\"https://github.com/koalaman/shellcheck/releases/download/v@version@/shellcheck-v@version@.linux.x86_64.tar.xz\" +\"https://github.com/sharkdp/fd/releases/download/v@version@/fd_@version@_amd64.deb\" +\"https://github.com/sharkdp/bat/releases/download/v@version@/bat_@version@_amd64.deb\" +\"https://github.com/kubernetes-sigs/kind/releases/download/v@version@/kind-linux-amd64\" +\"https://github.com/kubernetes/minikube/releases/download/v@version@/minikube-linux-amd64\" +\"https://github.com/plantuml/plantuml/releases/download/v@version@/plantuml-@version@.jar\" +\"https://github.com/Versent/saml2aws/releases/download/v@version@/saml2aws_@version@_linux_amd64.tar.gz\" +${__HELP_NORMAL} +If you want to add a condition on architecture(linux, windows, x86, 64/32 bits):${__HELP_EXAMPLE} +\"https://github.com/docker/compose/releases/download/v@version@/docker-compose-\$(uname -s | tr \"[:upper:]\" \"[:lower:]\")-\$(uname -m)\" +\"https://github.com/docker/docker-credential-helpers/releases/download/v@version@/docker-credential-wincred-v@version@.windows-\$(dpkg --print-architecture).exe\" +\"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\" +${__HELP_NORMAL} +${__HELP_TITLE}COMMAND EXAMPLES:${__HELP_NORMAL} +Download docker-compose latest version +${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/docker-compose \\ + \"https://github.com/docker/compose/releases/download/v@version@/docker-compose-\$(uname -s | tr \"[:upper:]\" \"[:lower:]\")-\$(uname -m)\"${__HELP_NORMAL} + +Download oq specific version +${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 \\ + \"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\"${__HELP_NORMAL} + +Download oq specific version correctly retrieving the oq version and not the jq one +${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 --version-arg '-V | grep oq:' \\ + \"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\"${__HELP_NORMAL} diff --git a/src/_binaries/Git/upgradeGithubRelease.options.tpl b/src/_binaries/Git/upgradeGithubRelease.options.tpl index 00474c73..d279efce 100644 --- a/src/_binaries/Git/upgradeGithubRelease.options.tpl +++ b/src/_binaries/Git/upgradeGithubRelease.options.tpl @@ -2,45 +2,14 @@ declare versionNumber="2.0" declare commandFunctionName="upgradeGithubReleaseCommand" declare help="retrieve latest binary release from github and install it" -declare example1=$'\\"https://github.com/docker/compose/releases/download/v@version@/docker-compose-\$(uname -s | tr \'[:upper:]\' \'[:lower:]\')-\$(uname -m)\\"' -declare example2=$'\\"https://github.com/docker/docker-credential-helpers/releases/download/v@version@/docker-credential-wincred-v@version@.windows-\$(dpkg --print-architecture).exe\\"' -declare example3=$'\\"https://github.com/Blacksmoke16/oq/releases/download/v@version@/oq-v@version@-\$(uname -s)-\$(uname -m)\\"' -declare longDescription=""" -${__HELP_TITLE}OPTIONS EXCEPTIONS:${__HELP_NORMAL} - -${__HELP_EXAMPLE}--current-version${__HELP_NORMAL}|${__HELP_EXAMPLE}-c${__HELP_NORMAL} and ${__HELP_EXAMPLE}--version-arg${__HELP_NORMAL} are mutually exclusive, -you cannot use both argument at the same time. - -${__HELP_EXAMPLE}--exact-version${__HELP_NORMAL}|${__HELP_EXAMPLE}-e${__HELP_NORMAL} and ${__HELP_EXAMPLE}--minimal-version${__HELP_NORMAL}|${__HELP_EXAMPLE}-m${__HELP_NORMAL} are mutually exclusive, -you cannot use both argument at the same time. - -${__HELP_TITLE}GITHUB TEMPLATE URLS EXAMPLES:${__HELP_NORMAL} - -Simple ones(Sometimes @version@ template variable has to be specified twice): -'https://github.com/hadolint/hadolint/releases/download/v@version@/hadolint-Linux-x86_64' -'https://github.com/koalaman/shellcheck/releases/download/v@version@/shellcheck-v@version@.linux.x86_64.tar.xz' -'https://github.com/sharkdp/fd/releases/download/v@version@/fd_@version@_amd64.deb' -'https://github.com/sharkdp/bat/releases/download/v@version@/bat_@version@_amd64.deb' -'https://github.com/kubernetes-sigs/kind/releases/download/v@version@/kind-linux-amd64' -'https://github.com/kubernetes/minikube/releases/download/v@version@/minikube-linux-amd64' -'https://github.com/plantuml/plantuml/releases/download/v@version@/plantuml-@version@.jar' -'https://github.com/Versent/saml2aws/releases/download/v@version@/saml2aws_@version@_linux_amd64.tar.gz' - -If you want to add a condition on architecture(linux, windows, x86, 64/32 bits): -${example1} -${example2} -${example3} - -${__HELP_TITLE}COMMAND EXAMPLES:${__HELP_NORMAL} -Download docker-compose latest version -${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/docker-compose ${example1}${__HELP_NORMAL} - -Download oq specific version -${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 ${example3}${__HELP_NORMAL} +# shellcheck disable=SC2016 +declare longDescription +longDescription="$( +% +.INCLUDE "$(dynamicSrcFile "_binaries/Git/upgradeGithubRelease.help.txt")" +% +)" -Download oq specific version correctly retrieving the oq version and not the jq one -${__HELP_EXAMPLE}upgradeGithubRelease /usr/local/bin/oq --exact-version 1.3.4 --version-arg '-V | grep oq:' ${example3}${__HELP_NORMAL} -""" # TODO find a way to not duplicate this info declare defaultVersionArg="--version" % @@ -79,16 +48,12 @@ source <( --title "VERSION MANAGEMENT:" \ --function-name groupVersionManagementFunction - # shellcheck disable=SC2116 + # shellcheck disable=SC2116,SC2016 Options::generateOption \ --help-value-name "versionArg" \ --default-value "${defaultVersionArg}" \ - --help "$(echo \ - "The argument that will be provided to the currently installed binary " \ - "to check the version of the software." $'\n' \ - "This parameter is needed if ${__HELP_EXAMPLE}--minimal-version${__HELP_NORMAL} argument is used and is " \ - "different than default value (${__HELP_EXAMPLE}${defaultVersionArg}${__HELP_NORMAL})." \ - )" \ + --help "The argument that will be provided to the currently installed binary +to check the version of the software. See options constraints below." \ --group groupVersionManagementFunction \ --alt "--version-arg" \ --variable-type "String" \ @@ -98,12 +63,11 @@ source <( # shellcheck disable=SC2116 Options::generateOption \ --help-value-name "currentVersion" \ - --help "$(echo \ - "Sometimes the command to retrieve the version is complicated. " $'\n' \ - "Some command needs you to parse json or other commands provides " \ - "multiple sub command versions. In this case you can provide the " \ - "version you currently have, see examples below." - )" \ + --help "Sometimes the command to retrieve the version is complicated. +Some command needs you to parse json or other commands provides +multiple sub command versions. In this case you can provide the +version you currently have, see examples below. +See options constraints below." \ --group groupVersionManagementFunction \ --alt "--current-version" \ --alt "-c" \ @@ -111,14 +75,13 @@ source <( --variable-name "optionCurrentVersion" \ --function-name optionCurrentVersionFunction - # shellcheck disable=SC2116 + # shellcheck disable=SC2116,SC2016 Options::generateOption \ --help-value-name "minimalVersion" \ - --help "$(echo \ - "if provided and currently installed binary is below this ${__HELP_EXAMPLE}minimalVersion${__HELP_NORMAL}," $'\n' \ - "a new version of the binary will be installed." $'\n' \ - "If this argument is not provided, the latest binary is unconditionally downloaded from github." \ - )" \ + --help 'if provided and currently installed binary is below this ${__HELP_EXAMPLE}minimalVersion${__HELP_NORMAL}, +a new version of the binary will be installed. +If this argument is not provided, the latest binary is unconditionally downloaded from github. +See options constraints below.' \ --group groupVersionManagementFunction \ --alt "--minimal-version" \ --alt "-m" \ @@ -126,13 +89,12 @@ source <( --variable-name "optionMinimalVersion" \ --function-name optionMinimalVersionFunction - # shellcheck disable=SC2116 + # shellcheck disable=SC2116,SC2016 Options::generateOption \ --help-value-name "exactVersion" \ - --help "$(echo \ - "if provided and currently installed binary is not this ${__HELP_EXAMPLE}exactVersion${__HELP_NORMAL}," $'\n' \ - "This exact version of the binary will be installed." \ - )" \ + --help 'if provided and currently installed binary is not this ${__HELP_EXAMPLE}exactVersion${__HELP_NORMAL}, + This exact version of the binary will be installed. + See options constraints below.' \ --group groupVersionManagementFunction \ --alt "--exact-version" \ --alt "-e" \ diff --git a/src/_binaries/Utils/waitForIt.options.tpl b/src/_binaries/Utils/waitForIt.options.tpl index 2565a51f..f33fcee4 100644 --- a/src/_binaries/Utils/waitForIt.options.tpl +++ b/src/_binaries/Utils/waitForIt.options.tpl @@ -3,7 +3,7 @@ declare versionNumber="2.0" declare commandFunctionName="waitForItCommand" declare help="wait for host:port to be available" # shellcheck disable=SC2016 -declare longDescription=""" +declare longDescription=''' ${__HELP_TITLE}EXIT STATUS CODES:${__HELP_NORMAL} ${__HELP_OPTION_COLOR}0${__HELP_NORMAL}: the host/port is available ${__HELP_OPTION_COLOR}1${__HELP_NORMAL}: indicates host/port is not available or argument error @@ -16,7 +16,7 @@ ${__HELP_OPTION_COLOR}whileLoopWithNc${__HELP_NORMAL}: timeout command simulated ${__HELP_OPTION_COLOR}timeoutV1WithTcp${__HELP_NORMAL}: previous version of timeout command with --timeout option ${__HELP_OPTION_COLOR}timeoutV2WithTcp${__HELP_NORMAL}: newer version of timeout command using timeout as argument ${__HELP_OPTION_COLOR}whileLoopWithTcp${__HELP_NORMAL}: timeout command simulated using while loop, base command tcp -""" +''' % .INCLUDE "$(dynamicTemplateDir _binaries/options/options.base.tpl)" .INCLUDE "$(dynamicTemplateDir _binaries/options/options.timeout.tpl)" diff --git a/src/_binaries/Utils/waitForMysql.options.tpl b/src/_binaries/Utils/waitForMysql.options.tpl index 7abd4e9f..889d34f8 100644 --- a/src/_binaries/Utils/waitForMysql.options.tpl +++ b/src/_binaries/Utils/waitForMysql.options.tpl @@ -3,12 +3,12 @@ declare versionNumber="2.0" declare commandFunctionName="waitForMysqlCommand" declare help="wait for mysql to be ready" # shellcheck disable=SC2016 -declare longDescription=""" +declare longDescription=''' ${__HELP_TITLE}EXIT STATUS CODES:${__HELP_NORMAL} ${__HELP_OPTION_COLOR}0${__HELP_NORMAL}: mysql is available ${__HELP_OPTION_COLOR}1${__HELP_NORMAL}: indicates mysql is not available or argument error ${__HELP_OPTION_COLOR}2${__HELP_NORMAL}: timeout reached -""" +''' % .INCLUDE "$(dynamicTemplateDir _binaries/options/options.base.tpl)" .INCLUDE "$(dynamicTemplateDir _binaries/options/options.timeout.tpl)" diff --git a/src/_binaries/build/installRequirements.options.tpl b/src/_binaries/build/installRequirements.options.tpl index 61532f84..a8694a86 100644 --- a/src/_binaries/build/installRequirements.options.tpl +++ b/src/_binaries/build/installRequirements.options.tpl @@ -5,12 +5,13 @@ declare -a externalBinaries=( declare versionNumber="1.0" declare commandFunctionName="installRequirementsCommand" declare help="installs requirements" -declare longDescription=""" +# shellcheck disable=SC2016 +declare longDescription=''' ${__HELP_TITLE}INSTALLS REQUIREMENTS:${__HELP_NORMAL} - fchastanet/bash-tools-framework - and fchastanet/bash-tools-framework useful binaries: - $(Array::join ', ' "${externalBinaries[@]}") -""" + $(Array::join ", " "${externalBinaries[@]}") +''' % .INCLUDE "$(dynamicTemplateDir _binaries/options/options.base.tpl)"