check_tablespace_size

#! /usr/bin/env bash

###############################################################################
# Monitor DB2 with Nagios
# Copyright 2013,2014,2015,2016 Andres Gomez Casanova
# https://github.com/angoca/monitor-db2-with-nagios
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################

# This script analyzes the allocated and used space in a tablespace.
#
# This script was based on the plugins written by Felipe Alkain de Souza.
# http://www.dbatodba.com/db2/scripts-db2/nagios-plugins
#
# In order to be used in Nagios, you have to configure the following.
#
# # 'check_tablespace_size' command definition
# define command {
#         command_name    check_tablespace_size
#         command_line    $USER1$/check_by_ssh -H $HOSTADDRESS$ -l nagios -C "scripts/check_tablespace_size -i '$ARG1$' -d '$ARG2$' -n '$ARG3$'"
# }
# define service{
#         host_name               db2server
#         service_description     Tablespace usage
#         check_command           check_tablespace_size!/home/db2inst1!sample!USERSPACE1
#         use                     generic-service
# }
#
# Parameters:
# -c | --critical : Critical threshold in milliseconds.
# -d | --database : Database name.
# -h | --help : Show the help of this script.
# -E | --exist : Returns OK if the tablespace does not exist.
# -i | --instance : Home directory of the instance. Usually it is
#   /home/db2inst1.
# -K | --mk : Change the output for Check_MK.
# -n | --name : Tablespace name.
# -T | --trace : Trace mode. Writes output in /tmp.
# -v | --verbose : Execute the program in verbose mode.
# -V | --version : Show the current version of this script.
# -w | --warning : Warning threshold in milliseconds.
# --id : Tablespace ID (instead of name).
#
# The exit codes are the standard for Nagios.
#
# 0 The plugin was able to check the service and it appeared to be functioning
#   properly.
# 1 The plugin was able to check the service, but it appeared to be above some
#   "warning" threshold or did not appear to be working properly.
# 2 The plugin detected that either the service was not running or it was above
#   some "critical" threshold.
# 3 Invalid command line arguments were supplied to the plugin or low-level
#   failures internal to the plugin (such as unable to fork, or open a tcp
#   socket) that prevent it from performing the specified operation.
#   Higher-level errors (such as name resolution errors, socket timeouts, etc)
#   are outside of the control of plugins and should generally NOT be reported
#   as UNKNOWN states.
#
# Author: Andres Gomez Casanova
# Version: v1.1 2015-10-15

# Flag for debugging.
#set -xv

# Locale to print messages in English. Prevent language problems.
export LANG=en_US

# Version of this script.
function print_revision {
  echo Andres Gomez Casanova - AngocA
  echo v1.1 2015-10-15
}
# Function to show the help
function print_usage {

  /bin/cat <<__EOT
Usage: ${1} { -i instanceHomeDirectory -d databaseName
[-n tablespaceName | -I tablespaceId] [-E][-c][-w][-K] | -h | -V } [-T][-v]
__EOT
}

function print_help {
  print_revision
  print_usage ${1}
  # Max 80 chars width.
  /bin/cat <<__EOT
-------------------------------------------------------------------------------
This script check the usage of a tablespace.
-c | --critical INTEGER
   Critical percentage of usage.
   Default 90.
-d | --database STRING
   Database name.
-E | --exist
   Returns OK if the given tablespace does not exist.
-h | --help
   Shows the current documentation.
-i | --instance STRING
   Instance home directory. It is usually /home/db2inst1.
-I | --id
   ID of the tablespace. This should be usage when the name is unknown.
-K | --mk
   Changes the output to be compatible with Check_MK.
-n | --name STRING
   Tablespace name to check.
-T | --trace
   Trace mode: writes date and output in /tmp.
-v | --verbose
   Executes the script in verbose mode (multiple times).
-V | --version
   Shows the current version of this script.
-w | --warning INTEGER
   Warning level of usage.
   Default 80.

In AIX, the long name options are not supported.
__EOT
}

# Variable to control the flow execution. Prevent Spaghetti code.
CONTINUE=true

# Nagios return codes
OK=0
WARNING=1
CRITICAL=2
UNKNOWN=3
# This is the returned code.
RETURN=${UNKNOWN}

# Nagios Output
# Text output 80 chars | Optional Perf Data Line 1
# Long text Line 1
# Long text Line 2 | Optional Perf Data Line 2
# Optional Perf Data Line 3
OUTPUT=
PERFORMANCE=
LONG_OUTPUT=
LONG_PERFORMANCE=
PERF_MK="-"

APPL_NAME=$(basename ${0})

echo "$(date +"%Y-%m-%d-%H.%M.%S") $$ Started ${APPL_NAME} $@" >> /tmp/${APPL_NAME}.log

# Checks the lock file does not exist.
# The lock file is the way the command was called with its parameters
# without spaces.
COPY_ARGS=("${@}") 
LOCK_FILE=
for VALUE in "${COPY_ARGS[@]}" ; do
  LOCK_FILE="${LOCK_FILE}${VALUE}"
done
LOCK_FILE=${LOCK_FILE//\//}
LOCK_FILE=${LOCK_FILE//\\/}
LOCK_FILE=${LOCK_FILE//\:/}
LOCK_FILE=${LOCK_FILE//\*/}
LOCK_FILE=${LOCK_FILE//\|/}
LOCK_FILE="/tmp/${APPL_NAME}${LOCK_FILE}.lock"
if [[ ! -r ${LOCK_FILE} ]] ; then
  echo $$ > ${LOCK_FILE}
  LOCKED=true
else
  # If it exist, then check if the process is running.
  EXIST=$(ps -ef | grep $(cat ${LOCK_FILE}) | grep ${APPL_NAME})
  # If process is not running, delete it.
  if [[ ${EXIST} == "" ]] ; then
    rm ${LOCK_FILE}
    if [[ ! -r ${LOCK_FILE} ]] ; then
      echo $$ > ${LOCK_FILE}
      LOCKED=true
    else
      OUTPUT="The lock file cannot be replaced: ${LOCK_FILE}"
      CONTINUE=false
      RETURN=${UNKNOWN}
    fi
  else
    OUTPUT="An instance of the script with the same parameters is already running."
    CONTINUE=false
    RETURN=${UNKNOWN}
  fi
fi

if [[ ${#} -eq 0 ]] ; then
  print_usage ${APPL_NAME}
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

# Checks the operating system. geopt works different in AIX than in Linux.
OS=$(uname)

if [[ "${OS:0:5}" == "Linux" ]] ; then
  # The following requires GNU getopt. See the following discussion.
  # http://stackoverflow.com/questions/402377

  TEMP=$(getopt -o c:d:Ehi:I:Kn:TvVw: --long critical:,database:,exist,help,id:,instance:,mk,name:,trace,verbose,version,warning: \
               -n ${APPL_NAME} -- "${@}")
elif [[ "${OS:0:3}" == "AIX" ]] ; then
  set -- $(getopt c:d:Ehi:I:Kn:TvVw: ${*})
elif [[ "${OS:0:6}" == "Darwin" || "${OS:0:5}" == "SunOS" || "${OS:0:5}" == "HP-UX" ]] ; then
  echo "This plugin is not yet supported in your platform."
  echo "Please create a ticket in GitHub if you want to enable your current platform."
  echo "https://github.com/angoca/monitor-db2-with-nagios/issues"
  RETURN=${UNKNOWN}
  CONTINUE=false
elif [[ "${OS:0:6}" == "CYGWIN" ]] ; then
  echo "This plugin is not supported in Cygwin"
  RETURN=${UNKNOWN}
  CONTINUE=false
else
  echo "The platform is unknown: ${OS}"
  echo "Please create a ticket in GitHub: https://github.com/angoca/monitor-db2-with-nagios/issues"
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${?} -ne 0 ]] ; then
  print_usage ${APPL_NAME}
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${CONTINUE} == true ]] ; then
  if [[ "${OS}" == "Linux" ]] ; then
    # Note the quotes around ${TEMP}: they are essential!
    eval set -- "${TEMP}"
  fi
  HELP=false
  VERSION=false
  CHECK_MK=false
  # Verbosity level
  VERBOSE=0
  # Trace activated
  TRACE=false
  LOG=/tmp/${APPL_NAME}.log
  TMP_FILE=/tmp/${APPL_NAME}.tmp
  INSTANCE_HOME=
  DATABASE_NAME=
  WARNING_THRES=80
  CRITICAL_THRES=90
  TABLESPACE_NAME=
  TABLESPACE_ID=
  IGNORE_INEXISTANT=false
  if [[ "${OS:0:5}" == "Linux" ]] ; then
    while true; do
      case "${1}" in
        -c | --critical ) CRITICAL_THRES=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -d | --database ) DATABASE_NAME=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -E | --exist ) IGNORE_INEXISTANT=true ; shift ;;
        -h | --help ) HELP=true ; shift ;;
        -i | --instance ) INSTANCE_HOME=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -I | --id ) TABLESPACE_ID=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -K | --mk ) CHECK_MK=true ; shift ;;
        -n | --name ) TABLESPACE_NAME=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -T | --trace ) TRACE=true ; shift ;;
        -v | --verbose ) VERBOSE=$(( ${VERBOSE} + 1 )) ; shift ;;
        -V | --version ) VERSION=true ; shift ;;
        -w | --warning ) WARNING_THRES=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -- ) shift ; break ;;
        * ) break ;;
      esac
    done
  elif [[ "${OS:0:3}" = "AIX" ]] ; then
    while [[ $1 != -- ]] ; do
      case "${1}" in
        -c) CRITICAL_THRES=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -d) DATABASE_NAME=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -E) IGNORE_INEXISTANT=true ; shift ;;
        -h) HELP=true ; shift ;;
        -i) INSTANCE_HOME=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -I) TABLESPACE_ID=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -K) CHECK_MK=true ; shift ;;
        -n) TABLESPACE_NAME=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        -T) TRACE=true ; shift ;;
        -v) VERBOSE=$(( ${VERBOSE} + 1 )) ; shift ;;
        -V) VERSION=true ; shift ;;
        -w) WARNING_THRES=$(echo ${2} | cut -d' ' -f1) ; shift 2 ;;
        * ) break ;;
      esac
    done
  fi
fi

if [[ ${TRACE} == true ]] ; then
  echo ">>>>>" >> ${LOG}
  date >> ${LOG}
  echo "Instance at ${INSTANCE_HOME}" >> ${LOG}
  echo "PID ${$}" >> ${LOG}
fi

ECHO="help:${HELP}, version:${VERSION}, verbose:${VERBOSE}"
ECHO="${ECHO}, directory:${INSTANCE_HOME}, database:${DATABASE_NAME}"
ECHO="${ECHO}, warning:${WARNING_THRES}, critical:${CRITICAL_THRES}"
ECHO="${ECHO}, check_mk:${CHECK_MK}, exist:${IGNORE_INEXISTANT}"
ECHO="${ECHO}, ts_name:${TABLESPACE_NAME}, ts_id:${TABLESPACE_ID}"

if [[ ${VERBOSE} -ge 2 ]] ; then
  echo ${ECHO}
fi

if [[ ${TRACE} == true ]] ; then
  echo "PARAMS:${ECHO}" >> ${LOG}
fi

if [[ ${CONTINUE} == true && ${HELP} == true ]] ; then
  print_help ${APPL_NAME}
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${CONTINUE} == true && ${VERSION} == true ]] ; then
  print_revision ${APPL_NAME}
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${CONTINUE} == true && ${INSTANCE_HOME} == "" ]] ; then
  print_usage ${APPL_NAME}
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${CONTINUE} == true && ${DATABASE_NAME} == "" ]] ; then
  print_usage ${APPL_NAME}
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${CONTINUE} == true
    && ( ${WARNING_THRES} == "" || ${CRITICAL_THRES} == ""
    || ! ${WARNING_THRES} =~ ^[0-9]+$ || ! ${CRITICAL_THRES} =~ ^[0-9]+$
    || ${WARNING_THRES} -le 0 || ${CRITICAL_THRES} -le 0
    || ${WARNING_THRES} -gt 100 || ${CRITICAL_THRES} -gt 100
    || ${WARNING_THRES} -ge ${CRITICAL_THRES} ) ]] ; then
  print_usage ${APPL_NAME}
  echo "Warning threshold should be less than critical threshold."
  echo "Threshold should be greater than 0 and less than 100."
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${CONTINUE} == true && ${TABLESPACE_NAME} == ""
    && ${TABLESPACE_ID} == "" ]] ; then
  print_usage ${APPL_NAME}
  echo "Tablespace name or id should be provided."
  RETURN=${UNKNOWN}
  CONTINUE=false
fi

if [[ ${CONTINUE} == true ]] ; then
  if [[ -d ${INSTANCE_HOME} && -e ${INSTANCE_HOME}/sqllib/db2profile ]] ; then
    # Load the DB2 profile.
    . ${INSTANCE_HOME}/sqllib/db2profile
    INSTANCE_NAME=$(db2 get instance | awk '/instance/ {print $7}')
  else
    OUTPUT="Instance directory is invalid."
    RETURN=${UNKNOWN}
    CONTINUE=false
  fi
fi

if [[ ${CONTINUE} == true ]] ; then
  COMMAND_DATABASE="db2 list db directory"
  if [[ ${VERBOSE} -ge 2 ]] ; then
    echo "COMMAND: ${COMMAND_DATABASE}"
  fi
  DATABASE=$(${COMMAND_DATABASE})
  if [[ ${TRACE} == true ]] ; then
    echo "RESULT:'${DATABASE}'" >> ${LOG}
  fi
  DATABASE=$(printf '%s\n' "${DATABASE}" | awk '/Database alias/ {print $4}' | grep -iw ${DATABASE_NAME})
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${DATABASE}'"
  fi

  if [[ ${DATABASE} == "" ]] ; then
    OUTPUT="The database ${DATABASE_NAME} is not catalogued."
    RETURN=${UNKNOWN}
    CONTINUE=false
  fi
fi
# Checks if the tablespace exist.
if [[ ${CONTINUE} == true ]] ; then
  if [[ ${TABLESPACE_NAME} != "" ]] ; then
    COMMAND_EXIST="db2 -x select trim(TBSP_NAME) from sysibmadm.TBSP_UTILIZATION where TBSP_NAME = '${TABLESPACE_NAME}'"
    TMP_FILE="${TMP_FILE}.${TABLESPACE_NAME}"
  else
    COMMAND_EXIST="db2 -x select trim(TBSP_ID) from sysibmadm.TBSP_UTILIZATION where TBSP_ID = '${TABLESPACE_ID}'"
    TMP_FILE="${TMP_FILE}.${TABLESPACE_ID}"
  fi
  if [[ ${VERBOSE} -ge 2 ]] ; then
    echo "COMMAND: ${COMMAND_EXIST}"
  fi
  db2 connect to ${DATABASE_NAME} > /dev/null 2>&1
  if [[ ${?} -ne 0 ]] ; then
    CONN_ERROR="error"
  fi
  ${COMMAND_EXIST} > ${TMP_FILE}
  EXIST=$(cat ${TMP_FILE} | tr -d ' ')
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${EXIST}'"
  fi

  # Substring to check any error.
  EXIST_ERROR=$(echo ${EXIST} | cut -c 1-5)
  if [[ ${EXIST_ERROR} == "error" ]] ; then
    OUTPUT="Connection problem"
    RETURN=${UNKNOWN}
    CONTINUE=false
  elif [[ ${EXIST_ERROR:0:3} == "SQL" ]] ; then
    OUTPUT="The user cannot access the tablespace information"
    RETURN=${UNKNOWN}
    CONTINUE=false
  elif [[ ( ${TABLESPACE_ID} == "" && ${EXIST} != ${TABLESPACE_NAME} ) || ( ${TABLESPACE_NAME} == "" && ${EXIST} != ${TABLESPACE_ID} ) ]] ; then
    OUTPUT="Tablespace ${TABLESPACE_NAME}${TABLESPACE_ID} does not exist."
    if [[ ${IGNORE_INEXISTANT} == true ]] ; then
      RETURN=${OK}
    else
      RETURN=${UNKNOWN}
    fi
    CONTINUE=false
  fi
fi
if [[ ${CONTINUE} == true ]] ; then
  COMMAND_TS="db2 -x select integer(TBSP_UTILIZATION_PERCENT), TBSP_TYPE, TBSP_CONTENT_TYPE, TBSP_USING_AUTO_STORAGE, TBSP_AUTO_RESIZE_ENABLED, TBSP_STATE, TBSP_TOTAL_SIZE_KB / 1024, TBSP_USED_SIZE_KB / 1024, TBSP_PAGE_TOP * TBSP_PAGE_SIZE / 1024 / 1024 from sysibmadm.TBSP_UTILIZATION "
  if [[ ${TABLESPACE_NAME} != "" ]] ; then
    COMMAND_TS="${COMMAND_TS} where TBSP_NAME = '${TABLESPACE_NAME}'"
  else
    COMMAND_TS="${COMMAND_TS} where TBSP_ID = ${TABLESPACE_ID}"
  fi
  if [[ ${VERBOSE} -ge 2 ]] ; then
    echo "COMMAND: ${COMMAND_TS}"
  fi
  set -f
  TS="${CONN_ERROR}$(${COMMAND_TS})"
  set +f
  TS_ERROR=$(echo ${TS} | cut -c 1-5)
  if [[ ${TS_ERROR} == "error" ]] ; then
    OUTPUT="Connection problem"
    RETURN=${UNKNOWN}
    CONTINUE=false
  fi
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${TS}'"
  fi
fi

if [[ ${CONTINUE} == true ]] ; then
  SIZE=$(printf '%s\n' "${TS}" | awk '{print $1}')
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${SIZE}'"
  fi

  TYPE=$(printf '%s\n' "${TS}" | awk '{print $2}')
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${TYPE}'"
  fi

  if [[ ${TYPE} == "SMS" ]] ; then
    if [[ ${SIZE} -lt ${WARNING_THRES} ]] ; then
      OUTPUT="OK tablespace size (SMS)."
      RETURN=${OK}
    else
      CONTENT=$(printf '%s\n' "${TS}" | awk '{print $3}')
      if [[ ${VERBOSE} -ge 3 ]] ; then
        echo "RESULT:'${CONTENT}'"
      fi
      if [[ ${CONTENT} == "SYSTEMP" || ${CONTENT} == "USRTEMP" ]] ; then
        OUTPUT="Temporary tablespace is being used. - ${SIZE}"
        RETURN=${OK}
      elif [[ ${CONTENT} == "ANY" ]] ; then
        OUTPUT="Please check the file system, the tablespace is SMS"
        RETURN=${OK}
      else
        OUTPUT="Script error for SMS tablespace. - ${SIZE}"
        RETURN=${CRITICAL}
      fi
    fi
  elif [[ ${TYPE} == "DMS" ]] ; then
    # Tablespace should be DMS
    AUTO=$(printf '%s\n' "${TS}" | awk '{print $4}')
    if [[ ${VERBOSE} -ge 3 ]] ; then
      echo "RESULT:'${AUTO}'"
    fi

    RESIZE=$(printf '%s\n' "${TS}" | awk '{print $5}')
    if [[ ${VERBOSE} -ge 3 ]] ; then
      echo "RESULT:'${RESIZE}'"
    fi

    if [[ ! ${AUTO} =~ ^[0-9]+$ || ! ${RESIZE} =~ ^[0-9]+$ ]] ; then
      OUTPUT="Problem determining if auto or resize"
      RETURN=${UNKNOWN}
    elif [[ ${AUTO} -eq "1" || ${RESIZE} -eq "1" ]] ; then
      if [[ ${SIZE} -lt ${WARNING_THRES} ]] ; then
        OUTPUT="OK tablespace size (${SIZE}% - Auto resize)."
        RETURN=${OK}
      elif [[ ${SIZE} -lt ${CRITICAL_THRES} ]] ; then
        OUTPUT="Tablespace size is getting bigger (${SIZE}% - Auto resize)."
        RETURN=${OK}
      else
        OUTPUT="Tablespace size is critical. It should be resized automatically (${SIZE}% - Auto resize)."
        RETURN=${OK}
      fi
    else
      if [[ ${SIZE} -lt ${WARNING_THRES} ]] ; then
        OUTPUT="OK tablespace size (${SIZE}%)."
        RETURN=${OK}
      elif [[ ${SIZE} -lt ${CRITICAL_THRES} ]] ; then
        OUTPUT="Tablespace size is getting bigger (${SIZE}%)."
        RETURN=${WARNING}
      else
        OUTPUT="Tablespace size is critical (${SIZE}%)."
        RETURN=${CRITICAL}
      fi
    fi
  else
    OUTPUT="Problem retrieving the type"
    RETURN=${UNKNOWN}
  fi
  
  #Availability
  STATUS=$(printf '%s\n' "${TS}" | awk '{print $6}')
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${STATUS}'"
  fi

  # Substring to check if an error occurred.
  STATUS_ERROR=$(echo ${STATUS} | cut -c 1-5)
  if [[ ${STATUS_ERROR} == "error" ]] ; then
    OUTPUT="Connection problem"
    RETURN=${UNKNOWN}
    CONTINUE=false
  elif [[ ${STATUS} == "BACKUP_IN_PROGRESS" ]] ; then
    OUTPUT="Backup in progress. ${OUTPUT}"
  elif [[ ${STATUS} != "NORMAL" ]] ; then
    OUTPUT="State not normal (${STATUS}). ${OUTPUT}"
    if [[ ${RETURN} == ${OK} ]] ; then
      RETURN=${WARNING}
    fi
  fi
fi

if [[ ${CONTINUE} == true ]] ; then
  # Performance data
  ## Allocated size
  TB_ALLOCATED=$(printf '%s\n' "${TS}" | awk '{print $7}')
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${TB_ALLOCATED}'"
  fi
  LONG_OUTPUT="Tablespace ${TABLESPACE_NAME}${TABLESPACE_ID} has allocated ${TB_ALLOCATED} MB"
  ALLOC_PERF="'Allocated'=$((${TB_ALLOCATED}*1024*1024))B"

  ## Used size
  TB_SIZE=$(printf '%s\n' "${TS}" | awk '{print $8}')
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${TB_SIZE}'"
  fi
  PERFORMANCE="'Tablespace'=$((${TB_SIZE}*1024*1024))B"

  ## High water mark
  TB_HWM=$(printf '%s\n' "${TS}" | awk '{print $9}')
  if [[ ${VERBOSE} -ge 3 ]] ; then
    echo "RESULT:'${TB_HWM}'"
  fi
  LONG_OUTPUT="${LONG_OUTPUT} and its watermark is at ${TB_HWM}"
  WATER_PERF="'Watermark'=$((${TB_HWM}*1024*1024))B"
  LONG_PERFORMANCE="${ALLOC_PERF}\n${WATER_PERF}"
  PERF_MK="${PERFORMANCE}|${ALLOC_PERF}|${WATER_PERF}"
  # TODO As part of the performance, display the status (backup pending, restore pending, etc.
fi

# Prints the output.
if [[ ${OUTPUT} == "" ]] ; then
  OUTPUT="Note: The test was not executed."
fi
# Builds the output.
if [[ ${CHECK_MK} == true ]] ; then
  echo "${RETURN} tablespaceSize-${INSTANCE_NAME}-${DATABASE_NAME}-${TABLESPACE_NAME} ${PERF_MK} ${OUTPUT}"
else
  echo -e "${OUTPUT}|${PERFORMANCE}\n${LONG_OUTPUT}|${LONG_PERFORMANCE}"
fi
# Returns the error code.
if [[ ${VERBOSE} -ge 2 ]] ; then
  echo "Return code: ${RETURN}"
fi
if [[ ${TRACE} == true ]] ; then
  echo -e "OUTPUT:${OUTPUT}\nPERF:${PERFORMANCE}\nLONG_OUT:${LONG_OUTPUT}\nLONGPERF:${LONG_PERFORMANCE}\nRET_CODE:${RETURN}" >> ${LOG}
  date >> ${LOG}
  echo -e "<<<<<\n" >> ${LOG}
fi

if [[ ${LOCKED} == true && -r ${LOCK_FILE} ]] ; then
  rm ${LOCK_FILE}
fi

echo "$(date +"%Y-%m-%d-%H.%M.%S") $$ Ended ${APPL_NAME} ${COPY_ARGS[@]}" >> /tmp/${APPL_NAME}.log

exit ${RETURN}