2022-05-11 15:46:16 +00:00
#!/bin/bash
#
# dodger@ciberterminal.net
# 06/05/2013: Complete rewrite of this f*****shit
#
# This Nagios plugin was created to check Oracle status on a remote site through SSH
#
2022-05-12 09:55:38 +00:00
# GRANTS for nagios user
# CREATE USER NAGIOS IDENTIFIED BY SOMEPASSWORD;
# GRANT CONNECT, RESOURCE TO NAGIOS ;
# GRANT SELECT ON V_$ARCHIVED_LOG to nagios ;
# GRANT SELECT ON V_$ASM_DISKGROUP to nagios ;
# GRANT SELECT ON V_$DATAGUARD_STATS to nagios ;
# GRANT SELECT ON V_$LOCK to nagios ;
# GRANT SELECT ON V_$LOG_HISTORY to nagios ;
# GRANT SELECT ON V_$PROCESS to nagios ;
# GRANT SELECT ON V_$SESSION to nagios ;
# GRANT SELECT ON V_$SESSION_WAIT to nagios ;
# GRANT SELECT ON V_$SQLAREA to nagios ;
# GRANT SELECT ON V_$SYSSTAT to nagios ;
# GRANT SELECT ON V_$controlfile to nagios ;
# GRANT SELECT ON V_$librarycache to nagios ;
# GRANT SELECT ON V_$lock to nagios ;
# GRANT SELECT ON V_$log to nagios ;
# GRANT SELECT ON V_$log_history to nagios ;
# GRANT SELECT ON V_$parameter to nagios ;
# GRANT SELECT ON V_$recovery_file_dest to nagios ;
# GRANT SELECT ON V_$session to nagios ;
# GRANT SELECT ON V_$sysstat to nagios ;
# GRANT SELECT ON DBA_DATA_FILES TO NAGIOS ;
# GRANT SELECT ON DBA_EXTENTS TO NAGIOS ;
# GRANT SELECT ON DBA_UNDO_EXTENTS TO NAGIOS ;
# GRANT SELECT ON dba_data_files TO NAGIOS ;
# GRANT SELECT ON dba_free_space TO NAGIOS ;
# GRANT SELECT ON dba_objects TO NAGIOS ;
# GRANT SELECT ON dba_source TO NAGIOS ;
# GRANT SELECT ON dba_temp_files TO NAGIOS ;
2022-05-11 15:46:16 +00:00
########################################################################
#
# CONSTANTS
#
########################################################################
# EXIT STATUS
STATE_OK=0
STATE_WARNING=1
STATE_CRITICAL=2
STATE_UNKNOWN=3
STATE_DEPENDENT=4
# /EXIT STATUS
REVISION="6.6.6"
# colors
2022-05-11 16:14:55 +00:00
BOLD="\e[1m"
GREEN="\e[32m"
LIGHTGREEN="${BOLD}${GREEN}"
RED="\033[1;31m"
2022-05-11 15:46:16 +00:00
LIGHTRED="\033[1;31m"
2022-05-11 16:14:55 +00:00
BLUE="\e[34m"
LIGHTBLUE="${BOLD}${BLUE}"
YELLOW="\e[33m"
LIGHTYELLOW="${BOLD}${YELLOW}"
2022-05-11 15:46:16 +00:00
WHITE="\033[0;37m"
RESET="\033[0;00m"
2022-05-11 16:14:55 +00:00
DEBUG=0
2022-05-23 15:56:04 +00:00
DEBUG=1
2022-05-11 16:14:55 +00:00
2022-05-11 15:46:16 +00:00
NOHEAD="SET HEAD OFF
SET PAGES 0
2022-05-23 15:56:04 +00:00
SET FEED OFF
SET TIMING OFF"
2022-05-11 15:46:16 +00:00
########################################################################
#
# / CONSTANTS
#
########################################################################
########################################################################
#
# FUNCTIONS
#
########################################################################
# printf "%s${LIGHTRED}USAGE:${RESET}
# $0 ORACLE_SID BACKUP_METHOD
#
# Where ORACLE_SID allowed: ${LIGHTGREEN}${KNOWNSIDS[*]}${RESET}
# And BACKUP_METHOD allowed: ${LIGHTGREEN}${KNOWNTYPE[*]}${RESET}\n"
# # VERY INITIAL CHECKS
print_revision() {
echo "$1 v$2 (nagios-plugins 2.0)"
printf "%sThe nagios plugins come with ABSOLUTELY NO WARRANTY. You may redistribute\ncopies of the plugins under the terms of the GNU General Public License.\nFor more information about these matters, see the file named COPYING.\n" | sed -e 's/\n/ /g'
}
2022-05-11 16:14:55 +00:00
# H host
# U oracle user
# S sid
# W warning
# C critical
# t tns
# d db
# l login
2022-05-12 09:55:38 +00:00
# o ospassword <- NOT NECESSARY
2022-05-11 16:14:55 +00:00
# s sessions
# c cache
# p parsing
# b tablespace
# u undo
# g diskgroup
# f FRA
# r redogen
2022-05-12 09:55:38 +00:00
# k locks
# a dgstats
# o totalspace
2022-05-11 16:14:55 +00:00
usage()
{
echo -e "${LIGHTBLUE}USAGE${RESET}
2022-05-12 09:55:38 +00:00
Mandatory options:
-H destination_hostname
-U oracle_linux_user
-S ORACLE_SID
Optional arguments (required for some checks):
-W warning
-C critical
Checks:
-t
Check remote TNS server
-d
Check remote database (search /bin/ps for PMON process)
-s
Check remote database concurrent active sessions
-l
Attempt a dummy login and alert if not ORA-01017: invalid username/password
-c
Check remote database for library and buffer cache hit ratios
-p
Check remote database for Soft/Hard parse ratios
-b
2022-05-12 10:24:40 +00:00
Check remote database for ALL tablespaces capacity
2022-05-12 09:55:38 +00:00
-u
2022-05-12 10:24:40 +00:00
Check remote database for UNDO tablespace capacity
2022-05-12 09:55:38 +00:00
-f
2022-05-12 10:24:40 +00:00
Check remote database for FLASH_RECOVERY_AREA capacity
2022-05-12 09:55:38 +00:00
-d
Check remote database for diskgroup capacity in ORACLE_ASM_SID (Tipically +ASM1/2...)
-a
Dataguard statistics (Apply & Transport Lag). This check is done ON THE STANDBY (the master does not have information on V\$DATAGUARD_STATS. So ORACLE_SID and HOSTNAME must be the STANDBY ones.
-r
Daily check for yesterday's redo generation
-k
Watch for session locks (any lock with return CRITICAL)
-o
Total Space taken by the database Excluding sytem tablespaces.
2022-05-11 16:14:55 +00:00
"
exit 0
}
2022-05-11 15:46:16 +00:00
print_usage()
{
echo "Usage:
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --tns <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --db <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --login <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --userslocked <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --ospassword CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --sessions <ORACLE_SID> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --asessions <ORACLE_SID> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --cache <ORACLE_SID> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --parsing <ORACLE_SID> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --tablespace <ORACLE_SID> <TABLESPACE> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --undo <ORACLE_SID> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --diskgroup <ORACLE_SID> <DISKGROUP> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --asmfs <ASMFS_PATH> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --dgstats <ORACLE_SID> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --fra <ORACLE_SID> CRITICAL_THRESHOLD WARNING_THRESHOLD
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --redogen <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --sessionlock <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --totalspace <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --totalspacedelta <ORACLE_SID>
${PROGPATH}/${PROGNAME} -H <Hostname/IP address> [-U Oracle OS User] --plsqllines <ORACLE_SID>
${PROGPATH}/${PROGNAME} --help
${PROGPATH}/${PROGNAME} --version
"
}
print_help()
{
print_revision $PROGNAME $REVISION
echo ""
print_usage
echo "
Check Oracle status
--tns SID/IP Address
Check remote TNS server
--db SID
Check remote database (search /bin/ps for PMON process)
--sessions SID
Check remote database concurrent active sessions
--asessions SID
Count sessions on the database (either active or not) per database user
--login SID
Attempt a dummy login and alert if not ORA-01017: invalid username/password
--userslocked SID
Check if there's any user account is locked
--cache
Check remote database for library and buffer cache hit ratios
--parsing
Check remote database for Soft/Hard parse ratios
--tablespace
Check remote database for tablespace capacity in ORACLE_SID
--undo
Check remote database for UNDO tablespace capacity in ORACLE_SID
--fra
Check remote database for FLASH_RECOVERY_AREA capacity in ORACLE_SID
--diskgroup
Check remote database for diskgroup capacity in ORACLE_ASM_SID (Tipically +ASM1/2...)
--dgstats
Dataguard statistics (Apply & Transport Lag). This check is done ON THE STANDBY (the master does not have information on V\$DATAGUARD_STATS. So ORACLE_SID and HOSTNAME must be the STANDBY ones.
--redogen
Daily check for yesterday's redo generation
--sessionlock
Watch for session locks (any lock with return CRITICAL)
--totalspace
Total Space taken by the database Excluding sytem tablespaces.
--totalspacedelta
Delta of the Total Space (Yesterday-thedaybeforeyesterday)
--developers
Number of sessions of the developers.
--help
Print this help screen
--version
Print version and license information
If the plugin doesn't work, check that the ORACLE_HOME environment
variable is set, that ORACLE_HOME/bin is in your PATH, and the
tnsnames.ora file is locatable and is properly configured on your Oracle server.
If you want to use a default Oracle home, add in your oratab file:
*:/opt/app/oracle/product/7.3.4:N
"
}
2022-05-11 16:14:55 +00:00
## getops ### usage()
## getops ### {
## getops ### # Information options
## getops ### case "${1^^}" in
## getops ### "--HELP"|"-H")
## getops ### print_help
## getops ### exit $STATE_OK
## getops ### ;;
## getops ### "--VERSION"|"-V")
## getops ### print_revision $PROGNAME $REVISION
## getops ### exit $STATE_OK
## getops ### ;;
## getops ### *)
## getops ### print_usage
## getops ### exit $STATE_OK
## getops ### ;;
## getops ### esac
## getops ### }
2022-05-11 15:46:16 +00:00
oraerror_check()
{
local CHECKTHIS="$*"
if [[ "${CHECKTHIS}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting sessions: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
return ${STATE_OK}
}
return_values()
{
local let VALUE=$1
if [[ ${VALUE} -gt ${CRITICAL} ]] ; then
MSG="CRITICAL"
RETURNCODE=${STATE_CRITICAL}
elif [[ ${VALUE} -gt ${WARNING} ]] ; then
MSG="WARNING"
RETURNCODE=${STATE_WARNING}
elif [[ ${VALUE} -le ${WARNING} ]] ; then
MSG="OK"
RETURNCODE=${STATE_OK}
else
MSG="UNKNOWN"
RETURNCODE=${STATE_UNKNOWN}
fi
echo ${MSG}
return ${RETURNCODE}
}
reverse_return_values()
{
local let VALUE=$1
if [[ ${VALUE} -lt ${CRITICAL} ]] ; then
MSG="CRITICAL"
RETURNCODE=${STATE_CRITICAL}
elif [[ ${VALUE} -lt ${WARNING} ]] ; then
MSG="WARNING"
RETURNCODE=${STATE_WARNING}
elif [[ ${VALUE} -ge ${WARNING} ]] ; then
MSG="OK"
RETURNCODE=${STATE_OK}
else
MSG="UNKNOWN"
RETURNCODE=${STATE_UNKNOWN}
fi
echo ${MSG}
return ${RETURNCODE}
}
2022-05-12 09:55:38 +00:00
# get_remote_oraclehome look for ORACLE_SID on oratab
# so if you don't have ORACLE_SID in the oratab file, it will avoid
# you can add a pseudo dummy line there...
2022-05-11 15:46:16 +00:00
get_remote_oraclehome()
{
#set -x
# Hunt down a reasonable ORACLE_HOME
ORATABLIST="$(${SSH} "locate oratab" | egrep "/oratab$" | tr '\n' ' ')"
for ORATAB in ${ORATABLIST} ; do
ORACLE_HOME=$(${SSH} "cat ${ORATAB}" | egrep "^(${ORACLE_SID}|\*):" | awk -F\: '{print $2}')
if [[ "${ORACLE_HOME}" ]] && [ $($SSH "ls -d ${ORACLE_HOME}" |wc -l) -eq 1 ] ; then
return 0
fi
done
return 1
}
check_tns()
{
local AUX="${ORAENV} tnsping ${ORACLE_SID}"
local TNSCHECK="$(${SSH} ${AUX})"
# echo ${TNSCHECK}
if [[ "${TNSCHECK}" =~ .*OK.*\(([0-9]{1,})\ .* ]] ; then
return ${STATE_OK}
else
return ${STATE_CRITICAL}
fi
}
check_db()
{
local PMONCHECK="$(${SSH} "ps -ef" | egrep -v grep | grep -c "ora_pmon_${ORACLE_SID}")"
if [ ${PMONCHECK} -ge 1 ] ; then
# echo "${ORACLE_SID} OK - ${PMONCHECK} PMON process(es) running"
return ${STATE_OK}
else
# echo "${ORACLE_SID} Database is DOWN"
return ${STATE_CRITICAL}
fi
}
check_login()
{
local AUX="${ORAENV} echo 'select 1+1 from dual ;' | ${SQLPLUS}"
local LOGINCHECK="$(${SSH} ${AUX} | egrep -c '^[[:space:]]{0,}2$')"
if [ ${LOGINCHECK} -ge 1 ] ; then
# echo "${ORACLE_SID} OK - dummy login connected"
return ${STATE_OK}
else
# echo "${ORACLE_SID} - dummy login fail"
return ${STATE_CRITICAL}
fi
}
check_total_sessions()
{
local let RETURNCODE=${STATE_UNKNOWN}
local let TOTALSESSIONS=0
local QUERY="${NOHEAD}
set numf 99999
SELECT count(*)
FROM V\\\$SESSION
where username is not null
and not username in ('SYS', 'PUBLIC', 'NAGIOS' )
/
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}")"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting sessions: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
TOTALSESSIONS=$( echo ${RESSULT} | awk '{print $1}')
MSG="$(return_values ${TOTALSESSIONS})"
RETURNCODE=$?
echo "${MSG} - ${ORACLE_SID} Total Sessions Count: ${TOTALSESSIONS} | Sessions=${TOTALSESSIONS};${WARNING};${CRITICAL}"
return ${RETURNCODE}
}
check_asessions_v3()
{
local let RETURNCODE=${STATE_UNKNOWN}
local let MAXINDEX=0
local let i=0
local let x=0
local let TOTALSESSIONS=0
declare -a RESSULTARRAY
declare -a RESSULTUSERS
local QUERY="${NOHEAD}
set numf 99999
SELECT username || ';' || count(username)
FROM V\\\$SESSION
where username is not null
and not username in ('SYS', 'PUBLIC', 'NAGIOS')
group by username
order by 1
/
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}")"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting sessions: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
for i in ${RESSULT} ; do
RESSULTARRAY[$x]=$(echo ${i} | awk -F\; '{print $2}')
RESSULTUSERS[$x]=$(echo ${i} | awk -F\; '{print $1}')
[[ ${RESSULTARRAY[$x]} -gt ${RESSULTARRAY[$MAXINDEX]} ]] && MAXINDEX=$x
let x++
done
MSG="$(return_values ${RESSULTARRAY[$MAXINDEX]})"
RETURNCODE=$?
#echo "${MSG} - ${ORACLE_SID} All Oracle Opened Sessions Count: ${TOTALSESSIONS} | Sessions=${TOTALSESSIONS} $(for ((x=0; x<${#RESSULTARRAY[@]}; x++)) ; do printf "%s${RESSULTUSERS[${x}]}=${RESSULTARRAY[${x}]} " ; done)"
if [[ ${RETURNCODE} -eq ${STATE_CRITICAL} || ${RETURNCODE} -eq ${STATE_WARNING} ]] ; then
RETURNMSG="All Oracle Opened Sessions, User ${RESSULTUSERS[${MAXINDEX}]} has ${RESSULTARRAY[${MAXINDEX}]} Sessions"
else
RETURNMSG="All Oracle Opened Sessions"
fi
echo "${MSG} - ${ORACLE_SID} ${RETURNMSG} | $(for ((x=0; x<${#RESSULTARRAY[@]}; x++)) ; do printf "%s${RESSULTUSERS[${x}]}=${RESSULTARRAY[${x}]} " ; done)"
return ${RETURNCODE}
}
check_sharedpool()
{
local let RETURNCODE=${STATE_UNKNOWN}
local let SHAREDFREE=0
local let SHAREDTOTAL=0
local let SHAREDPERCENT=100
local QUERY="${NOHEAD}
SELECT 'shared_pool_total=' || ROUND(SUM(BYTES)/1024/1024) FROM sys.V_\\\$SGASTAT WHERE POOL='shared pool' GROUP BY POOL;
SELECT CONCAT(REPLACE(POOL,' ','_'),'_free') || '=' || ROUND(BYTES/1024/1024) FROM SYS.V_\\\$SGASTAT WHERE NAME LIKE 'free memory' ;
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting sessions: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
SHAREDFREE=$(echo -e "${RESSULT}" | egrep "shared_pool_free" | awk -F\= '{print $2}')
SHAREDTOTAL=$(echo -e "${RESSULT}" | egrep "shared_pool_total" | awk -F\= '{print $2}')
SHAREDPERCENT=$(echo "100-${SHAREDFREE}*100/${SHAREDTOTAL}" | bc)
MSG="$(return_values ${SHAREDPERCENT})"
RETURNCODE=$?
echo "${MSG} - ${ORACLE_SID} Shared Pool Percent ${SHAREDPERCENT}%|$(for i in ${RESSULT}; do printf "%s${i} "; done)"
exit ${RETURNCODE}
}
check_developers()
{
local RESSULT=""
local RETURNTHIS=""
local QUERY=""
WHERESTATEMENT="UPPER(program) IN('WEBDEV.WEBSERVER40.EXE','TOAD.EXE','SQL DEVELOPER','SQLPLUS.EXE')"
RESSULTMSG=" Developers Opened Sessions Count"
QUERY="${NOHEAD}
set numf 999999
SELECT COUNT(*) FROM V\\\$SESSION WHERE ${WHERESTATEMENT} ;
"
# local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
# ${SSH} "${AUX}"
# read
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
oraerror_check "${RESSULT}"
RES=$?
[ ${RES} -ne ${STATE_OK} ] && return ${RES}
MSG="$(return_values ${RESSULT})"
RETURNCODE=$?
echo "${MSG} - ${ORACLE_SID} Total developer sessions : ${RESSULT}| Developers=${RESSULT}"
return ${RETURNCODE}
}
# Included SYSTEM in the query's exclusion pattern to avoid reporting backup sessions.
check_sessions()
{
local let RETURNCODE=${STATE_UNKNOWN}
local QUERY="${NOHEAD}
set numf 99
select count(SES.SID)
from V\\\$SESSION SES, V\\\$SQLAREA SQL, V\\\$SESSION_WAIT WA, V\\\$PROCESS P
where SES.STATUS='ACTIVE'
AND SES.SQL_ID=SQL.SQL_ID
AND SES.SID=WA.SID
and SES.paddr=p.addr
and UPPER(SES.USERNAME) not in ( 'SYS','SYSMAN','MDSYS','SYSTEM','NAGIOS', 'DBSNMP' )
/"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting sessions: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
MSG="$(return_values ${RESSULT})"
RETURNCODE=$?
echo "${MSG} - ${ORACLE_SID} Concurrent Active Sessions Count: ${RESSULT} |Sessions=${RESSULT};${WARNING};${CRITICAL};0;20"
return ${RETURNCODE}
}
# Included SYSTEM in the query's exclusion pattern to avoid reporting backup sessions.
check_activesessions()
{
local let RETURNCODE=${STATE_UNKNOWN}
local let TOTALSESSIONS=0
local PERFDATA=""
local QUERY="${NOHEAD}
set numf 999
select username || '=' || count(*)
from v\\\$session
where status='ACTIVE'
and username not in ( 'SYS','SYSMAN','MDSYS','SYSTEM','NAGIOS', 'DBSNMP' )
group by username
/
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting sessions: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
for LINE in ${RESSULT} ; do
PERFDATA="${PERFDATA} ${LINE}"
TOTALSESSIONS=$((${TOTALSESSIONS}+$(echo ${LINE} | awk -F= '{print $2}')))
done
MSG="$(return_values ${TOTALSESSIONS})"
RETURNCODE=$?
echo "${MSG} - ${ORACLE_SID} Concurrent Active Sessions Count: ${TOTALSESSIONS} |Sessions=${TOTALSESSIONS};${WARNING};${CRITICAL};0;20 ${PERFDATA}"
return ${RETURNCODE}
}
check_checknewtickets()
{
local let RETURNCODE=${STATE_UNKNOWN}
local let NEWTICKETS=0
local PERFDATA=""
# local QUERY="${NOHEAD}
#set numf 999
#select 'NewTickets =' || count(*) from DEVOLUIVA.requested_tickets where recption_date > sysdate - 0.010416;
#"
local QUERY="${NOHEAD}
set numf 999
select count(*) from DEVOLUIVA.requested_tickets where recption_date > sysdate - 0.010416;
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}' | egrep -v "^[[:space:]]{0,}$")"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting requested_tickets: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
# for LINE in ${RESSULT} ; do
# PERFDATA="${PERFDATA} ${LINE}"
# NEWTICKETS=$((${NEWTICKETS}+$(echo ${LINE} | awk -F= '{print $2}')))
# done
NEWTICKETS=${RESSULT}
PERFDATA="NewTickets=${NEWTICKETS}"
MSG="$(reverse_return_values ${NEWTICKETS})"
RETURNCODE=$?
echo "${MSG} - ${ORACLE_SID} New requested tikets: ${NEWTICKETS} |NewTickets=${NEWTICKETS};${WARNING};${CRITICAL};0;20 ${PERFDATA}"
return ${RETURNCODE}
}
check_cache()
{
local let RETURNCODE=${STATE_UNKNOWN}
local QUERY="${NOHEAD}
set numf 9999999.99
SELECT (1-(pr.value/(dbg.value+cg.value)))*100
from v\\\$sysstat pr, v\\\$sysstat dbg, v\\\$sysstat cg
where pr.name='physical reads'
and dbg.name='db block gets'
and cg.name='consistent gets'
/"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local LIBHITS="$(${SSH} "${AUX}" | awk '{print $1}')"
local QUERY="${NOHEAD}
set numf 9999999.99
select sum(lc.pins)/(sum(lc.pins)+sum(lc.reloads))*100
from v\\\$librarycache lc
/"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local CACHEHITS="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${CACHEHITS}" =~ .*(ORA\-[0-9]{1,}).* || "${LIBHITS}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting Cache: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
if ! [[ "${CACHEHITS}" =~ [0-9]{1,2}\.[0-9]{0,2} || "${LIBHITS}" =~ [0-9]{1,2}\.[0-9]{0,2} ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting Cache, values returned: ${CACHEHITS} , ${LIBHITS}"
return ${STATE_CRITICAL}
fi
if [[ ${CACHEHITS/.*} -le ${CRITICAL} || ${LIBHITS/.*} -le ${CRITICAL} ]] ; then
MSG="CRITICAL"
RETURNCODE=${STATE_CRITICAL}
elif [[ ${CACHEHITS/.*} -le ${WARNING} || ${LIBHITS/.*} -le ${WARNING} ]] ; then
MSG="WARNING"
RETURNCODE=${STATE_WARNING}
elif [[ ${CACHEHITS/.*} -gt ${WARNING} && ${LIBHITS/.*} -gt ${WARNING} ]] ; then
MSG="OK"
RETURNCODE=${STATE_OK}
else
MSG="UNKNOWN"
RETURNCODE=${STATE_UNKNOWN}
fi
echo "${MSG} - ${ORACLE_SID} - Cache Hit Rates: ${CACHEHITS}% Lib -- ${LIBHITS}% Buff|lib=${CACHEHITS}%;${CRITICAL};${WARNING};0;100 buffer=${LIBHITS}%;${CRITICAL};${WARNING};0;100"
return ${RETURNCODE}
}
check_parsing()
{
local let RETURNCODE=${STATE_UNKNOWN}
local QUERY="${NOHEAD}
set numf 99999999999999
SELECT VALUE FROM V\\\$SYSSTAT WHERE NAME = 'parse count (total)' ;
SELECT VALUE FROM V\\\$SYSSTAT WHERE NAME = 'parse count (hard)' ;
SELECT VALUE FROM V\\\$SYSSTAT WHERE NAME = 'parse count (failures)' ;
SELECT VALUE FROM V\\\$SYSSTAT WHERE NAME = 'parse count (describe)' ;"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | tr '\n' ' ')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* || "${RESSULT}" =~ ^(([[:space:]]|)[0-9]{1,}){4}$ ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting parsing data: ${RESSULT}"
return ${STATE_CRITICAL}
fi
# PARSING INDEXES like possitional parameter
# TOTAL=1
# HARD=2
# FAIL=3
# DESCRIBE=4
SOFTPARSE="$(echo "${RESSULT}" | awk '{printf "%2.2f",($1-$2-$3-$4)/$1*100}')"
HARDPARSE="$(echo "${RESSULT}" | awk '{printf "%2.2f",$2/$1*100}')"
FAILEDPARSE="$(echo "${RESSULT}" | awk '{printf "%2.2f",$3/$1*100}')"
if [[ ${SOFTPARSE/.*} -le ${CRITICAL} ]] ; then
MSG="CRITICAL"
RETURNCODE=${STATE_CRITICAL}
elif [[ ${SOFTPARSE/.*} -le ${WARNING} ]] ; then
MSG="WARNING"
RETURNCODE=${STATE_WARNING}
elif [[ ${SOFTPARSE/.*} -gt ${WARNING} ]] ; then
MSG="OK"
RETURNCODE=${STATE_OK}
else
MSG="UNKNOWN"
RETURNCODE=${STATE_UNKNOWN}
fi
echo "${MSG} - ${ORACLE_SID} - Parse Ratio %: ${SOFTPARSE}% Soft -- ${HARDPARSE}% Hard -- ${FAILEDPARSE}% Failed|Soft=${SOFTPARSE}%;${CRITICAL};${WARNING};0;100 Hard=${HARDPARSE}%;${CRITICAL};${WARNING};0;100 Failed=${FAILEDPARSE}%;${CRITICAL};${WARNING};0;100"
return ${RETURNCODE}
}
check_bigger_tables()
{
local let RETURNCODE=${STATE_UNKNOWN}
# IN GIGABYTES
#local BIGGERTHAN=2
local BIGGERTHAN=${WARNING}
local QUERY="${NOHEAD}
set numf 99999999999999
COL OWNER FORMAT A10;
COL SEGMENT_NAME FORMAT A35;
COL TABLESPACE_NAME FORMAT A35;
SELECT SEGMENT_NAME || '=' || SUM_BYTES FROM (
SELECT SEGMENT_NAME,
SUM(BYTES) SUM_BYTES
FROM DBA_EXTENTS
WHERE OWNER NOT IN ('SYS', 'SYSTEM' )
AND SEGMENT_TYPE='TABLE'
GROUP BY SEGMENT_NAME, SEGMENT_TYPE, OWNER, TABLESPACE_NAME
)
WHERE SUM_BYTES>$((${BIGGERTHAN}*1024*1024*1024))
ORDER BY SUM_BYTES DESC
;"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}")"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* || "${RESSULT}" =~ ^(([[:space:]]|)[0-9]{1,}){4}$ ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting parsing data: ${RESSULT}"
return ${STATE_CRITICAL}
fi
for LINE in ${RESSULT} ; do
PERFDATA="${LINE} ${PERFDATA}"
done
echo "OK - ${ORACLE_SID} - BIGGER tables|${PERFDATA}"
printf "%s${RESSULT}\n"
return ${STATE_OK}
}
# this version of the check is to cover #132284
check_sessionlock_v5()
{
######################################################
# HARD LOCKS (CRITICAL)
######################################################
# type hard 1: v$lock based
local QUERY="${NOHEAD}
SELECT L1.SID || ';' || L2.SID
FROM V\\\$LOCK L1, V\\\$LOCK L2
WHERE
L1.BLOCK=1
AND L2.REQUEST > 0
AND L1.ID1=L2.ID1
AND L1.ID2=L2.ID2
/
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | tr '\n' ' ')"
if [[ "${RESSULT}" ]] ; then
RETURNCODE=${STATE_CRITICAL}
echo "CRITICAL - ${ORACLE_SID} HARD LOCKS ${RESSULT//;/ is blocking }"
# return is here cause hardlock is much more important tan soft...
return ${RETURNCODE}
fi
# type hard 2: v$session based
local QUERY="${NOHEAD}
select sid || '.' || serial# || ';' || username || ';' || osuser || ';' || WAIT_CLASS || ';' || EVENT THEINFO
from v\\\$session
where state='WAITING'
AND WAIT_CLASS='Concurrency'
/
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}")"
if [[ "${RESSULT}" ]] ; then
RETURNCODE=${STATE_CRITICAL}
echo "CRITICAL - ${ORACLE_SID} HARD LOCKS : $(echo -e "${RESSULT}" | wc -l) Sessions in lock"
# return is here cause hardlock is much more important tan soft...
echo -e "${RESSULT}"
return ${RETURNCODE}
fi
######################################################
# SOFT LOCKS (WARNING)
######################################################
local QUERY="${NOHEAD}
SELECT
lk.SID || '.' || se.SERIAL# || ';' || se.username || ';' || se.OSUser || ';' || lk.type THEINFO
FROM
v\\\$lock lk,
v\\\$session se
WHERE
lk.type IN (
'AT', 'IV', 'JQ', 'TA', 'TM', 'TX', 'UL', 'CU',
'LA', 'LB', 'LC', 'LD', 'LE', 'LF', 'LG', 'LH',
'LI', 'LJ', 'LK', 'LL', 'LM', 'LN', 'LO', 'LP',
'LQ', 'LR', 'LS', 'LT', 'LU', 'LV', 'LW', 'LX',
'LY', 'LZ', 'NA', 'NB', 'NC', 'ND', 'NE', 'NF',
'NG', 'NH', 'NI', 'NJ', 'NK', 'NL', 'NM', 'NN',
'NO', 'NP', 'NQ', 'NR', 'NS', 'NT', 'NU', 'NV',
'NW', 'NX', 'NY', 'NZ'
)
AND lk.SID = se.SID
AND SE.USERNAME NOT IN ('MANAGER_AGENDAMAKER', 'SYS', 'SYSTEM', 'DBSNMP')
AND (
LK.ID1 in ( select object_id from dba_objects where object_name IN ( 'ESTABS', 'T_ENTERPRISES') AND OBJECT_TYPE='TABLE' )
or
LK.ID2 in ( select object_id from dba_objects where object_name IN ( 'ESTABS', 'T_ENTERPRISES') AND OBJECT_TYPE='TABLE' )
)
order by lk.sid, se.username, se.osuser, lk.type
;
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}")"
if [[ "${RESSULT}" ]] ; then
RETURNCODE=${STATE_WARNING}
echo "WARNING - ${ORACLE_SID} SOFT LOCKS"
echo -e "${RESSULT}"
else
RETURNCODE=${STATE_OK}
echo "OK - ${ORACLE_SID} NO LOCK FOUND"
fi
return ${RETURNCODE}
}
check_sessionlock()
{
local let SESSIONLOCK=1
local let RETURNCODE=${STATE_UNKNOWN}
local RETURNMSG=""
local QUERY="${NOHEAD}
set numf 99999999999999
SELECT COUNT(*)
FROM V\\\$LOCK L1, V\\\$LOCK L2
WHERE
L1.BLOCK=1
AND L2.REQUEST > 0
AND L1.ID1=L2.ID1
AND L1.ID2=L2.ID2 ;"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | tr '\n' ' ')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* || "${RESSULT}" =~ ^(([[:space:]]|)[0-9]{1,}){4}$ ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting locks: ${RESSULT}"
return ${STATE_CRITICAL}
fi
SESSIONLOCK=$(echo ${RESSULT}| awk '{print $1}')
SIDLOCKER=$(echo ${RESSULT}| awk '{print $2}')
if [[ ${SESSIONLOCK/.*} -gt 0 ]] ; then
MSG="CRITICAL"
RETURNCODE=${STATE_CRITICAL}
# Getting lockers
local QUERY="${NOHEAD}
SET COLSEP \\\";\\\"
COL SIDSERIAL FORMAT A15;
COL HOSTNAME FORMAT A30;
COL PROGRAM FORMAT A30;
SELECT ses.sid || ',' || ses.serial# SIDSERIAL,
SES.MACHINE HOSTNAME,
SES.PROGRAM PROGRAM
FROM V\\\$SESSION SES, V\\\$PROCESS P
WHERE SES.paddr = p.addr
AND SES.SID IN (
SELECT l1.sid
FROM v\\\$lock l1, v\\\$lock l2
WHERE l1.block =1 AND l2.request > 0
AND l1.id1=l2.id1
AND l1.id2=l2.id2
AND ROWNUM=1
)
ORDER BY SES.MACHINE
/"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
#Trimming the string
local RESSULT="$(${SSH} "${AUX}"| awk '{print $1$2$3}')"
# no spaces here (i think), so using for instead of readline
for i in ${RESSULT} ; do
RETURNMSG="$(echo ${i}| awk -F\; '{print $2";"$3}') ${PERFDATA}"
done
# while read LINE ; do
# PERFDATA="$(echo ${LINE} | awk -F\; '{print $2"/"$3}') ; ${PERFDATA}"
# echo ${LINE}
# read
# done < <(printf "%s${RESSULT}")
EXTENDEDSTATUS="${RESSULT}"
elif [[ ${SESSIONLOCK/.*} -eq 0 ]] ; then
MSG="OK"
RETURNCODE=${STATE_OK}
EXTENDEDSTATUS=""
RETURNMSG="No locks"
else
MSG="UNKNOWN"
RETURNCODE=${STATE_UNKNOWN}
fi
echo "${MSG} - ${ORACLE_SID} LOCKS : ${RETURNMSG}"
[[ "${EXTENDEDSTATUS}" ]] && printf "%s${EXTENDEDSTATUS}\n"
return ${RETURNCODE}
}
check_sessionlock_extended()
{
local let SESSIONLOCK=1
local let RETURNCODE=${STATE_UNKNOWN}
local RETURNMSG=""
local TMPFILE=$(mktemp)
local ALERTMAIL="dodger@ciberterminal.net"
local QUERY="${NOHEAD}
set numf 99999999999999
SELECT COUNT(*)
FROM V\\\$LOCK L1, V\\\$LOCK L2
WHERE
L1.BLOCK=1
AND L2.REQUEST > 0
AND L1.ID1=L2.ID1
AND L1.ID2=L2.ID2 ;"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | tr '\n' ' ')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* || "${RESSULT}" =~ ^(([[:space:]]|)[0-9]{1,}){4}$ ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting locks: ${RESSULT}"
return ${STATE_CRITICAL}
fi
SESSIONLOCK=$(echo ${RESSULT}| awk '{print $1}')
SIDLOCKER=$(echo ${RESSULT}| awk '{print $2}')
if [[ ${SESSIONLOCK/.*} -gt 0 ]] ; then
MSG="CRITICAL"
RETURNCODE=${STATE_CRITICAL}
# Getting lockers
local QUERY="${NOHEAD}
SET COLSEP \\\";\\\"
COL SIDSERIAL FORMAT A15;
COL SSID FORMAT 999999;
col SSERIAL FORMAT 999999;
COL HOSTNAME FORMAT A30;
COL PROGRAM FORMAT A30;
SELECT SES.SID SSID,
SES.SERIAL# SSERIAL,
SES.MACHINE HOSTNAME,
SES.PROGRAM PROGRAM,
SES.SQL_ID
FROM V\\\$SESSION SES, V\\\$PROCESS P
WHERE SES.paddr = p.addr
AND SES.SID IN (
SELECT l1.sid
FROM v\\\$lock l1, v\\\$lock l2
WHERE l1.block =1 AND l2.request > 0
AND l1.id1=l2.id1
AND l1.id2=l2.id2
AND ROWNUM=1
)
ORDER BY SES.MACHINE
/"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
#Trimming the string
local RESSULT="$(${SSH} "${AUX}" | awk -F\; '{gsub(/^ +| +$/,"",$1);gsub(/^ +| +$/,"",$2);gsub(/^ +| +$/,"",$3);gsub(/^ +| +$/,"",$4);gsub(/^ +| +$/,"",$5)} {print $1";"$2";"$3";"$4";"$5}')"
printf "%s${RESSULT}\n" >> ${TMPFILE}
OFS="${IFS}"
IFS=";"
local AUXARRAY=( ${RESSULT} )
IFS="${OFS}"
# if there's any SQLID (4th position), then try to get the SQL
if [[ "${AUXARRAY[4]}" ]] ; then
local QUERY="${NOHEAD}
SELECT SQL_FULLTEXT
FROM V\\\$SQLAREA SQL
WHERE SQL.SQL_ID='${AUXARRAY[4]}'
AND ROWNUM=1
/"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
${SSH} "${AUX}" >> ${TMPFILE}
# local RESSULT="$(${SSH} "${AUX}")"
# printf "%s${RESSULT}\n" >> ${TMPFILE}
fi
# no spaces here (i think), so using for instead of readline
for i in ${RESSULT} ; do
RETURNMSG="$(echo ${i}| awk -F\; '{print $2";"$3}') ${PERFDATA}"
done
# don't know but the hostname is not trimmed anyway except using hardcore regexps...
[[ "${AUXARRAY[2]}" =~ ^([[:alnum:][:graph:]]{1,100})[[:space:]]{1,}$ ]] && AUXARRAY[2]="${BASH_REMATCH[1]}"
RETURNMSG="${AUXARRAY[2]}; ${AUXARRAY[3]}; ${AUXARRAY[4]}"
EXTENDEDSTATUS="$(cat ${TMPFILE})"
# sending by mail the ressult
cat ${TMPFILE} | mail -s "${MSG} - ${ORACLE_SID} LOCKS : ${RETURNMSG}" ${ALERTMAIL}
elif [[ ${SESSIONLOCK/.*} -eq 0 ]] ; then
MSG="OK"
RETURNCODE=${STATE_OK}
EXTENDEDSTATUS=""
RETURNMSG="No locks"
else
MSG="UNKNOWN"
RETURNCODE=${STATE_UNKNOWN}
fi
echo "${MSG} - ${ORACLE_SID} LOCKS : ${RETURNMSG}"
[[ "${EXTENDEDSTATUS}" ]] && printf "%s${EXTENDEDSTATUS}\n"
rm -f ${TMPFILE}
return ${RETURNCODE}
}
all_tablespaces_space()
{
declare -a RESSULTARRAY
declare -a WARNINGARRAY
declare -a CRITICALARRAY
declare -a OKARRAY
local QUERY="${NOHEAD}
SELECT TABLESPACE_NAME || '=' || REPLACE(PERCENT, ' ')
FROM
(
SELECT TABLESPACE_NAME,to_char(((MAX_MB-REAL_FREE_MB)/MAX_MB*100),'00') PERCENT
FROM (
SELECT MAXUSAGE.TABLESPACE_NAME,
MAXUSAGE.MAX_MB,
CASE WHEN MAXUSAGE.ACTUAL_DATAFILE_MB < MAXUSAGE.MAX_MB THEN
MAX_MB-(ACTUAL_DATAFILE_MB-FREE_MB)
ELSE
FREE_MB
END REAL_FREE_MB
FROM
(
SELECT TABLESPACE_NAME,
(CASE WHEN INNER_MAX_MB < INNER_ACTUAL_DATAFILE_MB THEN INNER_ACTUAL_DATAFILE_MB ELSE INNER_MAX_MB END) MAX_MB,
INNER_ACTUAL_DATAFILE_MB ACTUAL_DATAFILE_MB
FROM (
SELECT TABLESPACE_NAME,
SUM(CASE WHEN MAXBYTES > 0 THEN MAXBYTES ELSE BYTES END)/1024/1024 INNER_MAX_MB,
SUM(BYTES)/1024/1024 INNER_ACTUAL_DATAFILE_MB
FROM DBA_DATA_FILES
GROUP BY TABLESPACE_NAME
) INNER_USAGE
) MAXUSAGE,
(
SELECT TABLESPACE_NAME, SUM(BYTES)/1024/1024 FREE_MB
FROM dba_free_space
GROUP BY TABLESPACE_NAME
) FREEUSAGE
WHERE MAXUSAGE.TABLESPACE_NAME=FREEUSAGE.TABLESPACE_NAME
) ALL_TABLESPACES_SPACE
order by TABLESPACE_NAME
)
;
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting ${RETURNMSG}: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
RESSULTARRAY=( ${RESSULT} )
for ((x=0; x<${#RESSULTARRAY[@]}; x++)) ; do
PERFDATA="${PERFDATA} ${RESSULTARRAY[$x]}"
TABLESPACENAME="$(echo ${RESSULTARRAY[$x]} | awk -F\= '{print $1}')"
TABLESPACEPERCENT=$(echo ${RESSULTARRAY[$x]} | awk -F\= '{print $2}')
#echo -e "${LIGHTGREEN}${TABLESPACENAME}${RESET}=${LIGHTRED}${TABLESPACEPERCENT}${RESET}"
if [[ ${TABLESPACEPERCENT} -ge ${CRITICAL} ]] ; then
CRITICALARRAY+=( "${TABLESPACENAME}=${TABLESPACEPERCENT}" )
elif [[ ${TABLESPACEPERCENT} -ge ${WARNING} ]] ; then
WARNINGARRAY+=( "${TABLESPACENAME}=${TABLESPACEPERCENT}" )
else
OKARRAY+=( "${TABLESPACENAME}=${TABLESPACEPERCENT}" )
fi
done
if [[ ${#CRITICALARRAY[@]} -gt 0 ]] ; then
MSG="CRITICAL"
echo "${MSG} - ${ORACLE_SID} Check Tablespace(s) Space: ${CRITICALARRAY[@]} ${WARNINGARRAY[@]} | ${CRITICALARRAY[@]} ${WARNINGARRAY[@]} ${OKARRAY[@]}"
return ${STATE_CRITICAL}
elif [[ ${#WARNINGARRAY[@]} -gt 0 ]] ; then
MSG="WARNING"
echo "${MSG} - ${ORACLE_SID} Check Tablespace(s) Space: ${CRITICALARRAY[@]} ${WARNINGARRAY[@]} | ${CRITICALARRAY[@]} ${WARNINGARRAY[@]} ${OKARRAY[@]}"
return ${STATE_WARNING}
else
MSG="OK"
echo "${MSG} - ${ORACLE_SID} ALL Tablespaces Space | ${CRITICALARRAY[@]} ${WARNINGARRAY[@]} ${OKARRAY[@]}"
return ${STATE_OK}
fi
}
generic_space_check()
{
local CHECK="$1"
local OBJECTNAME="$2"
case ${CHECK,,} in
"undo" )
local QUERY="${NOHEAD}
set numf 9999999.99
select TOTALSPACE.TOTAL TOTAL_SPACE,
TOTALSPACE.TOTAL-NVL(USEDSPACE.USED,0.0) FREE_SPACE
FROM (
SELECT TABLESPACE_NAME, SUM(MAXBYTES)/1024/1024 TOTAL
FROM DBA_DATA_FILES WHERE TABLESPACE_NAME = (SELECT value FROM V\\\$parameter WHERE name = 'undo_tablespace')
GROUP BY TABLESPACE_NAME
) TOTALSPACE
LEFT OUTER JOIN
(
SELECT TABLESPACE_NAME, SUM(BYTES)/1024/1024 USED
FROM DBA_UNDO_EXTENTS
WHERE (STATUS='UNEXPIRED' OR STATUS='ACTIVE')
AND TABLESPACE_NAME = (SELECT value FROM V\\\$parameter WHERE name = 'undo_tablespace')
GROUP BY TABLESPACE_NAME
) USEDSPACE
ON TOTALSPACE.TABLESPACE_NAME=USEDSPACE.TABLESPACE_NAME
;"
OBJECTNAME=UNDO
;;
"tablespace" )
local QUERY="${NOHEAD}
SET NUMF 99999999.99
SELECT MAX_MB,
REAL_FREE_MB FREE_MB
FROM (
SELECT MAXUSAGE.TABLESPACE_NAME,
MAXUSAGE.MAX_MB,
CASE WHEN MAXUSAGE.ACTUAL_DATAFILE_MB < MAXUSAGE.MAX_MB THEN
MAX_MB-(ACTUAL_DATAFILE_MB-FREE_MB)
ELSE
FREE_MB
END REAL_FREE_MB
FROM
(
select TABLESPACE_NAME,
SUM(case when MAXBYTES > 0 then MAXBYTES else BYTES END)/1024/1024 MAX_MB,
SUM(BYTES)/1024/1024 ACTUAL_DATAFILE_MB
FROM DBA_DATA_FILES
GROUP BY TABLESPACE_NAME
) MAXUSAGE,
(
select TABLESPACE_NAME, SUM(BYTES)/1024/1024 FREE_MB
FROM dba_free_space
GROUP BY TABLESPACE_NAME
) FREEUSAGE
WHERE MAXUSAGE.TABLESPACE_NAME=FREEUSAGE.TABLESPACE_NAME
AND MAXUSAGE.TABLESPACE_NAME = '${OBJECTNAME}'
)
;"
;;
"diskgroup" )
local QUERY="${NOHEAD}
SET NUMF 9999999999
SELECT TOTAL_MB, NVL(FREE_MB,0.0) FREE_MB FROM V\\\$ASM_DISKGROUP WHERE NAME='${OBJECTNAME}' ;"
;;
"fra")
local QUERY="${NOHEAD}
set numf 99999999999999
SELECT (SUM(SPACE_LIMIT))/1024/1024 TOTAL, (SUM(SPACE_LIMIT-SPACE_USED))/1024/1024 FREE, (SUM(SPACE_USED))/1024/1024 USED
FROM v\\\$recovery_file_dest ;
"
OBJECTNAME=FLASH_RECOVERY_AREA
;;
* )
echo "CRITICAL - Function generic_space_check received wrong parameter : ${CHECK} "
return ${STATE_CRITICAL}
;;
esac
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}")"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* || "${RESSULT}" =~ ^(([[:space:]]|)[0-9]{1,}){2}$ || ! "${RESSULT}" ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting ${CHECK^} usage: ${RESSULT}"
return ${STATE_CRITICAL}
fi
local TOTAL="$(echo ${RESSULT} | awk '{print $1}')"
local FREE="$(echo ${RESSULT} | awk '{print $2}')"
local USED="$(echo "${RESSULT}" | awk '{printf "%2.2f",$1-$2}')"
local PERCENT="$(echo "${RESSULT}" | awk '{printf "%2.2f",100-($2/$1*100)}')"
MSG="$(return_values ${PERCENT/.*})"
RETURNCODE=$?
echo "${MSG} - ${ORACLE_SID} ${CHECK^} ${OBJECTNAME} : ${PERCENT}%, Used : ${USED} of ${TOTAL} MB |${OBJECTNAME}=${PERCENT};${WARNING};${CRITICAL};0;20"
return ${RETURNCODE}
}
asmfs_space_check()
{
local OBJECTNAME="$1"
# symlink patch
local AUX="readlink ${OBJECTNAME}"
local RESSULT="$(${SSH} "${AUX}" 2> /dev/null)"
if [[ "${RESSULT}" ]] ; then
# the provided fs is a symlink
if [[ "${RESSULT}" =~ ^\/.*$ ]] ; then
OBJECTNAME=${RESSULT}
else
OBJECTNAME=$(dirname ${OBJECTNAME})/$(basename ${RESSULT})
fi
fi
local AUX="df -P ${OBJECTNAME} | egrep ${OBJECTNAME}"
local RESSULT="$(${SSH} "${AUX}" 2> /dev/null)"
#if [[ ! "${RESSULT}" =~ ^(\/|[a-z]{1,4}[a-z0-9]{1,8}:\/).*%.*${OBJECTNAME}$ ]] ; then
if [[ ! "${RESSULT}" =~ ^(\/|[a-z]{1,4}[a-z0-9]{1,8}:\/|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}:).*%.*${OBJECTNAME}$ ]] ; then
echo "CRITICAL - Error getting ${COMMAND} space for ${OBJECTNAME}"
return ${STATE_CRITICAL}
fi
local TOTAL="$(echo ${RESSULT} | awk '{print $2*1024}')"
local FREE="$(echo ${RESSULT} | awk '{print $4*1024}')"
local USED="$(echo "${RESSULT}" | awk '{printf $3*1024}')"
local PERCENT="$(echo "${RESSULT}" | awk '{printf $5}')"
local WARNINGVALUE="$(echo ${TOTAL} ${WARNING} | awk '{printf "%.2f",$1*$2/100}')"
local CRITICALVALUE="$(echo ${TOTAL} ${CRITICAL} | awk '{printf "%.2f",$1*$2/100}')"
MSG="$(return_values ${PERCENT//%/})"
RETURNCODE=$?
echo "${MSG} - ${CHECK^} ${OBJECTNAME} : ${PERCENT}, Used : $((${USED}/1024/1024/1024)) GB of $((${TOTAL}/1024/1024/1024)) GB |size=${TOTAL}B used=${USED}B;${WARNINGVALUE};${CRITICALVALUE};0;${TOTAL}"
return ${RETURNCODE}
}
# This check needs SYS/ AS SYSDBA priviledge as connect to the standby (supposed to be in mount state)
dataguard_stats_new()
{
local ORAENVSID="${ORAENV} export ORACLE_SID=${ORACLE_SID} ;"
local let RETURNCODE=${STATE_UNKNOWN}
local SQLPLUS="sqlplus -s '/ as sysdba'"
local TRANSPORTLAG=""
local APPLYLAG=""
local QUERY="${NOHEAD}
set numf 99999999999999
SELECT NVL(VALUE,'+00 00:00:00') FROM V\\\$DATAGUARD_STATS WHERE (NAME LIKE 'apply lag' OR NAME LIKE 'transport lag')
;"
local AUX="${ORAENVSID} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}")"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* || "${RESSULT}" =~ ^(([[:space:]]|)[0-9]{1,}){4}$ ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting dataguard data: ${RESSULT}"
return ${STATE_CRITICAL}
fi
TRANSPORTLAG="$(echo "${RESSULT}" | head -1)"
APPLYLAG="$(echo "${RESSULT}" | head -2| tail -1)"
# echo "Transport: ${TRANSPORTLAG}"
# echo "Apply: ${APPLYLAG}"
# read
TRANSPORTLAGSECONDS=$(echo "(((${TRANSPORTLAG:1:2}*24)+${TRANSPORTLAG:4:2})*60+${TRANSPORTLAG:7:2})*60+${TRANSPORTLAG:10:2}" | bc)
APPLYLAGSECONDS=$(echo "(((${APPLYLAG:1:2}*24)+${APPLYLAG:4:2})*60+${APPLYLAG:7:2})*60+${APPLYLAG:10:2}" | bc)
if [ ${TRANSPORTLAGSECONDS} -gt ${APPLYLAGSECONDS} ] ; then
MSG="$(return_values ${TRANSPORTLAGSECONDS})"
RETURNCODE=$?
else
MSG="$(return_values ${APPLYLAGSECONDS})"
RETURNCODE=$?
fi
echo "${MSG} - Dataguard stats for ${ORACLE_SID} - TransportLag: ${TRANSPORTLAG} ApplyLag: ${APPLYLAG}|transport=${TRANSPORTLAGSECONDS} apply=${APPLYLAGSECONDS};${WARNING};${CRITICAL};0;86400"
return ${RETURNCODE}
}
# to use this function you must create the table and grant permissions to nagios user:
# CREATE TABLE NAGIOS.TOTALSPACE (MYDATE VARCHAR(8), TOTALSPACE FLOAT(30));
# GRANT INSERT, UPDATE, DELETE ON NAGIOS.TOTALSPACE TO NAGIOS ;
# GRANT UNLIMITED TABLESPACE TO NAGIOS ;
totalspace_delta()
{
local let RETURNCODE=${STATE_UNKNOWN}
local TODAY="$(date +%Y%m%d)"
local YESTERDAY="$(date --date=yesterday +%Y%m%d)"
local DAYBEFOREY="$(date --date='2 days ago' +%Y%m%d)"
local let TOTALSPACE=0
local let TOTALSPACEY=0
local let DELTA=0
# quering for totalspace to our custom table
local QUERY="${NOHEAD}
SELECT TOTALSPACE FROM NAGIOS.TOTALSPACE
WHERE MYDATE='${YESTERDAY}'
AND ROWNUM=1 ;"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting ${RETURNMSG}: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
# if the totalspace is logged on table, that will be the returned value
#if [[ "${RESSULT}" ]] ; then
if [[ "${RESSULT}" =~ ^[0-9]{1,}$ ]] ; then
TOTALSPACE=${RESSULT}
else
# if there's no value in the table, then we must calculate it and then update the table
local QUERY="${NOHEAD}
set numf 9999999999
SELECT SUM(BYTES)/1024/1024 TOTAL_MB FROM DBA_DATA_FILES
/"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
TOTALSPACE=${RESSULT}
local QUERY="${NOHEAD}
set numf 9999999999
INSERT INTO NAGIOS.TOTALSPACE VALUES ('${YESTERDAY}', '${TOTALSPACE}') ;
commit ;
"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
fi
# quering for 2 days ago totalspace to our custom table
local QUERY="${NOHEAD}
SELECT TOTALSPACE FROM NAGIOS.TOTALSPACE
WHERE MYDATE='${DAYBEFOREY}'
AND ROWNUM=1;"
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
# if there's no 2 days ago totalspace, then DELTA must be 0
if [[ "${RESSULT}" =~ ^[0-9]{1,}$ ]] ; then
DELTA=$(echo "${TOTALSPACE} ${RESSULT}" | awk '{print $1-$2}')
else
DELTA=0
fi
#printf "%s${RESSULT}"
echo "OK - ${ORACLE_SID} TotalSpace Delta: ${DELTA} |TotalSpaceDelta=${DELTA}"
return 0
}
#This a statistics-only control, so it always return OK unless it can't connect to Oracle
statistics_check()
{
local CHECK=$1
local let RETURNCODE=${STATE_UNKNOWN}
unset RETURNMSG
declare -a RETURNMSG
case "${CHECK,,}" in
"old_totalspace_simple" )
RETURNMSG[0]="TOTAL DB SPACE"
RETURNMSG[1]="TotalSpace"
local QUERY="${NOHEAD}
set numf 9999999999
SELECT SUM(BYTES)/1024/1024 TOTAL_MB FROM DBA_DATA_FILES
/"
;;
"totalspace_simple" )
RETURNMSG[0]="TOTAL DB SPACE"
RETURNMSG[1]="TotalSpace"
local QUERY="${NOHEAD}
select
( select sum(bytes)/1024/1024 data_size from dba_data_files ) +
( select nvl(sum(bytes),0)/1024/1024 temp_size from dba_temp_files ) +
( select sum(bytes)/1024/1024 redo_size from sys.v_\\\$log ) +
( select sum(BLOCK_SIZE*FILE_SIZE_BLKS)/1024/1024 controlfile_size from v\\\$controlfile) TOTAL_MB
2022-05-12 10:24:40 +00:00
from dual
2022-05-11 15:46:16 +00:00
/"
;;
"redogen" )
RETURNMSG[0]="Redo generation"
RETURNMSG[1]="RedoGen"
local QUERY="${NOHEAD}
set numf 9999999999
SELECT Round(A.COUNT#*B.AVG#/1024/1024) YESTERDAY_REDOGEN_MB
FROM (
SELECT To_Char(First_Time,'YYYY-MM-DD') DAY, COUNT(1) COUNT#, MIN(RECID) MIN#, MAX(RECID) MAX#
FROM v\\\$log_history
WHERE To_Char(First_Time,'YYYY-MM-DD')=To_Char(SYSDATE-1,'YYYY-MM-DD')
GROUP BY To_Char(First_Time,'YYYY-MM-DD')
ORDER BY 1 DESC
) A,
(
SELECT Avg(BYTES) AVG#
FROM v\\\$log
) B
/"
;;
"plsqllines")
local QUERY="${NOHEAD}
set numf 9999999999
select count(*)
from dba_source
where NAME IN
(
select object_NAME
from dba_objects
where object_type in ('PROCEDURE', 'PACKAGE BODY', 'PACKAGE', 'TYPE BODY', 'TYPE', 'FUNCTION')
)
and owner not in ('SYS', 'SYSTEM', 'PUBLIC' ) ;"
;;
* )
echo "CRITICAL - Wrong value on function statistics_check: ${CHECK}"
return ${STATE_CRITICAL}
;;
esac
local AUX="${ORAENV} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error getting ${RETURNMSG}: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
if [ $(echo ${RESSULT} | wc -w) -gt 1 ] ; then
RESSULTARRAY=( ${RESSULT} )
local let x=0
PERFDATA=""
STATUSINFO=""
for i in ${RETURNMSG[1]} ; do
PERFDATA="${PERFDATA} $i=${RESSULTARRAY[$x]}"
STATUSINFO="${STATUSINFO} $i: ${RESSULTARRAY[$x]}"
let x++
done
echo "OK - ${ORACLE_SID} ${STATUSINFO} |${PERFDATA}"
else
echo "OK - ${ORACLE_SID} ${RETURNMSG[0]}: ${RESSULT} |${RETURNMSG[1]}=${RESSULT}"
fi
return 0
}
check_password_expiration()
{
#local AUX="chage -l oracle | egrep \"^Password expires\" | cut -d\: -f 2"
local EXPIREDATE="$(${SSH} "chage -l ${ORACLE_OSUSER}" | egrep "^Password expires" | cut -d\: -f 2)"
local TIMESLICESECONDS=0
if [[ "${EXPIREDATE}" = " never" ]] ; then
# xD
local EXPIREEPOH=$(date --date="Jan 1, 2999" +%s)
else
local EXPIREEPOH=$(date --date="${EXPIREDATE}" +%s)
fi
local ACTUALDATE=$(date +%s)
local TIMESLICESECONDS=$((${EXPIREEPOH}-${ACTUALDATE}))
local TIMESLICE=$((${TIMESLICESECONDS}/60/60/24))
MSG="$(reverse_return_values ${TIMESLICE})"
RETURNCODE=$?
echo "${MSG} - Password Expires in ${TIMESLICE} days"
return ${RETURNCODE}
}
check_userslocked()
{
local USERGROUPS=""
USERGROUPS=(
'DBA'
'CORE'
'CRON'
'EXTRA'
'INTRA'
'MANAGER'
'MIRINDA'
'BACKEND'
'INTEGRACION'
)
#SELECT '' || USERNAME || '' FROM SYS.DBA_users WHERE (
local QUERY="${NOHEAD}
SELECT USERNAME FROM SYS.DBA_users WHERE (
$(for ((x=0;x<${#USERGROUPS[@]};x++)); do echo "USERNAME like '${USERGROUPS[${x}]}\\_%' ESCAPE '\\' OR"; done )
USERNAME = 'JHOLGADO'
)
and NOT USERNAME LIKE '%\\_VOXELDEV' ESCAPE '\\'
AND ACCOUNT_STATUS LIKE 'LOCK%'
ORDER BY USERNAME
;
"
local AUX="${ORAENV} echo -e \"\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}'| tr '\n' ' ')"
if [[ "${RESSULT}" ]] ; then
RETURNCODE=${STATE_CRITICAL}
echo "CRITICAL - ${ORACLE_SID} Production USER locked: ${RESSULT}"
else
RETURNCODE=${STATE_OK}
echo "OK - ${ORACLE_SID} All Production USERS unlocked"
fi
return ${RETURNCODE}
}
check_seqapply()
{
if [[ "${ORACLE_SID}" =~ (.*)GDN$ ]] ; then
local AUXSID=${BASH_REMATCH[1]}
#echo ${AUXSID}
local AUXSID="$(${SSH} "ps -ef" | grep -v grep | grep "ora_pmon_${AUXSID}" | awk '{print $8}' | sed 's/ora_pmon_//g')"
ORACLE_SID="${AUXSID}"
fi
local ORAENVSID="${ORAENV} export ORACLE_SID=${ORACLE_SID} ;"
local SQLPLUS="sqlplus -s '/ as sysdba'"
local RETURNTHIS=""
local EXTENDEDINFORMATION=""
local QUERY=""
QUERY="${NOHEAD}
SELECT (ARCH.SEQUENCE# - APPL.SEQUENCE#) Difference
FROM
(SELECT THREAD# ,SEQUENCE# FROM V\\\$ARCHIVED_LOG WHERE (THREAD#,FIRST_TIME ) IN (SELECT THREAD#,MAX(FIRST_TIME) FROM V\\\$ARCHIVED_LOG GROUP BY THREAD#)) ARCH,
(SELECT THREAD# ,SEQUENCE# FROM V\\\$LOG_HISTORY WHERE (THREAD#,FIRST_TIME ) IN (SELECT THREAD#,MAX(FIRST_TIME) FROM V\\\$LOG_HISTORY GROUP BY THREAD#)) APPL
WHERE
ARCH.THREAD# = APPL.THREAD#
ORDER BY 1;
"
#local AUX="${ORAENV} echo -e \"\n${QUERY}\" | ${SQLPLUS}"
local AUX="${ORAENVSID} printf \"%s\n${QUERY}\" | ${SQLPLUS}"
local RESSULT="$(${SSH} "${AUX}" | awk '{print $1}')"
if [[ "${RESSULT}" =~ .*(ORA\-[0-9]{1,}).* ]] ; then
echo "CRITICAL - ${ORACLE_SID} Error executing query: ${BASH_REMATCH[1]}"
return ${STATE_CRITICAL}
fi
local DIFFERENCE=$(echo ${RESSULT} | awk -F\; '{print $1}')
MSG="$(return_values ${DIFFERENCE})"
RETURNCODE=$?
RETURNTHIS="${MSG} - ${ORACLE_SID} Apply difference = ${DIFFERENCE}"
echo "${RETURNTHIS}"
if [[ ${RETURNCODE} -ne ${STATE_OK} ]] ; then
EXTENDEDINFORMATION="AppyDifference=${DIFFERENCE}"
echo "${EXTENDEDINFORMATION}"
fi
return ${RETURNCODE}
}
2022-05-12 09:55:38 +00:00
printmsg()
{
echo -e "$*"
}
abort_message()
{
local let ABORTCODE=1
[[ ${EXITCODE} -ne 0 ]] && ABORTCODE=${EXITCODE}
printmsg "${LIGHTRED}ERROR${RESET}: $*"
exit ${ABORTCODE}
}
# debug_me uses variable ${DEBUG}
debug_me()
{
if [[ "${DEBUG}" && ${DEBUG} -eq 0 ]] ; then
echo -e "${LIGHTBLUE}DEBUG: ${RESET}$*"
fi
}
2022-05-11 15:46:16 +00:00
########################################################################
#
# / FUNCTIONS
#
########################################################################
########################################################################
#
# VARIABLES
#
########################################################################
PROGNAME=$(basename $0)
PROGPATH=$(dirname $0)
2022-05-11 16:14:55 +00:00
## getops ###[ $# -le 1 ] && usage $*
## getops ###
## getops ###REMOTE_SERVER=$2 && shift 2
## getops ###
## getops ###if [[ ! ${REMOTE_SERVER} ]]
## getops ###then
## getops ### echo "No remote server specified!!!"
## getops ### exit ${STATE_UNKNOWN}
## getops ###fi
## getops ###
## getops #### Checking for non-standard user to connect
## getops ###if [[ "${1}" = "-U" ]]
## getops ###then
## getops ### ORACLE_OSUSER=$2 && shift 2
## getops ###else
## getops ### ORACLE_OSUSER="oracle"
## getops ###fi
## getops ###
## getops ###SSH="ssh ${ORACLE_OSUSER}@${REMOTE_SERVER} -xq"
2022-05-11 15:46:16 +00:00
ORACLEUSER="NAGIOS"
ORACLEUSERPASSWORD="D2HSHBFMO5IINME9I9WT"
########################################################################
#
# / VARIABLES
#
########################################################################
########################################################################
#
# MAIN
#
########################################################################
2022-05-12 09:55:38 +00:00
while getopts "H:U:S:W:C:tdloscpbugfrhkaDF" arg; do
2022-05-11 16:14:55 +00:00
case $arg in
# H host
H)
REMOTE_SERVER=${OPTARG}
;;
# U oracle user
U)
ORACLE_OSUSER="${OPTARG}"
;;
# S sid
S)
ORACLE_SID="${OPTARG}"
;;
# W warning
W)
WARNING="${OPTARG}"
;;
# C critical
C)
CRITICAL="${OPTARG}"
;;
# t tns
t)
COMMAND="tns"
;;
# d db
d)
COMMAND="db"
;;
# l login
l)
COMMAND="login"
;;
2022-05-12 09:55:38 +00:00
# o ospassword <- not necessary
# o totalspace
2022-05-11 16:14:55 +00:00
o)
2022-05-12 09:55:38 +00:00
#COMMAND="ospassword"
COMMAND="totalspace"
2022-05-11 16:14:55 +00:00
;;
# s sessions
s)
COMMAND="sessions"
;;
# c cache
c)
COMMAND="cache"
;;
# p parsing
p)
COMMAND="parsing"
;;
# b tablespace
b)
2022-05-12 10:24:40 +00:00
#COMMAND="tablespace"
COMMAND="alltablespacesspace"
2022-05-11 16:14:55 +00:00
;;
# u undo
u)
COMMAND="undo"
;;
# g diskgroup
g)
COMMAND="diskgroup"
;;
# f FRA
f)
COMMAND="fra"
;;
# r redogen
r)
COMMAND="redogen"
;;
2022-05-12 09:55:38 +00:00
# k sessionlock
k)
COMMAND="sessionlock"
;;
# a dgstats
a)
COMMAND="dgstats"
;;
2022-05-11 16:14:55 +00:00
h)
usage
;;
F)
MAYTHEFORCEBEWITHYOU=true
echo -e "${LIGHTBLUE}The force is strong in you?${RESET}"
;;
D)
DEBUG=0
;;
*)
usage
;;
esac
done
2022-05-11 15:46:16 +00:00
2022-05-11 16:14:55 +00:00
# mandatory ops
if [[ ! "${REMOTE_SERVER}" ]] ; then
2022-05-12 09:55:38 +00:00
debug_me "No REMOTE_SERVER"
2022-05-11 16:14:55 +00:00
usage
2022-05-11 15:46:16 +00:00
fi
2022-05-11 16:14:55 +00:00
if [[ ! "${ORACLE_OSUSER}" ]] ; then
2022-05-12 09:55:38 +00:00
debug_me "No ORACLE_OSUSER"
2022-05-11 16:14:55 +00:00
usage
fi
if [[ ! "${ORACLE_SID}" ]] ; then
2022-05-12 09:55:38 +00:00
debug_me "No ORACLE_SID"
2022-05-11 16:14:55 +00:00
usage
2022-05-11 15:46:16 +00:00
fi
2022-05-11 16:14:55 +00:00
if [[ ! "${WARNING}" || ! "${CRITICAL}" ]] ; then
2022-05-12 09:55:38 +00:00
debug_me "no warning or critical, maybe this will fail"
fi
if [[ ! "${COMMAND}" ]] ; then
debug_me "No COMMAND received"
2022-05-11 16:14:55 +00:00
usage
fi
SSH="ssh ${ORACLE_OSUSER}@${REMOTE_SERVER} -xq"
get_remote_oraclehome
2022-05-25 10:37:31 +00:00
RES=$?
if [[ ${RES} -ne 0 ]] ; then
echo "CRITICAL - ORACLE_HOME not found"
exit ${STATE_CRITICAL}
fi
2022-05-11 15:46:16 +00:00
# SQLPLUS FOR CONNECTIONS
SQLPLUS="sqlplus -s '${ORACLEUSER}/${ORACLEUSERPASSWORD}@${ORACLE_SID}'"
ORAENV="ORACLE_HOME=${ORACLE_HOME};PATH=$PATH:$ORACLE_HOME/bin;LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib;export ORACLE_HOME PATH LD_LIBRARY_PATH;"
2022-05-12 09:55:38 +00:00
debug_me "${SSH}"
debug_me "${SQLPLUS}"
debug_me "${ORAENV}"
debug_me "${COMMAND}"
2022-05-11 16:14:55 +00:00
2022-05-11 15:46:16 +00:00
case "${COMMAND}" in
"tns")
check_tns
RES=$?
if [ ${RES} -eq ${STATE_OK} ] ; then
echo "OK - reply time ${BASH_REMATCH[1]} from ${ORACLE_SID}"
else
echo "CRITICAL - No TNS Listener on ${ORACLE_SID}"
fi
;;
"db")
check_db
RES=$?
if [ ${RES} -eq ${STATE_OK} ] ; then
echo "OK - ${ORACLE_SID} Database running"
else
echo "CRITICAL - ${ORACLE_SID} Database is DOWN"
fi
;;
"login")
check_login
RES=$?
if [ ${RES} -eq ${STATE_OK} ] ; then
echo "OK - ${ORACLE_SID} dummy login connected"
else
echo "CRITICAL - ${ORACLE_SID} dummy login fail"
fi
;;
"asessions")
check_asessions_v3
RES=$?
;;
"tsessions")
check_total_sessions
RES=$?
;;
"seqapply")
check_seqapply;
RES=$?
;;
"sessions")
# here the message is printed inside the function, sorry
#check_sessions
check_activesessions
RES=$?
;;
"cache")
check_cache
RES=$?
;;
"parsing")
check_parsing
RES=$?
;;
"undo")
generic_space_check undo
RES=$?
;;
"tablespace")
generic_space_check tablespace "${TSDG}"
RES=$?
;;
"diskgroup")
generic_space_check diskgroup "${TSDG}"
RES=$?
;;
"asmfs")
ASMFS_DISK=${ORACLE_SID}
asmfs_space_check ${ASMFS_DISK}
RES=$?
;;
"fra")
# check_FRA
generic_space_check fra
RES=$?
;;
"dgstats")
dataguard_stats_new
RES=$?
;;
"redogen")
statistics_check redogen
RES=$?
;;
"totalspace")
#statistics_check totalspace
statistics_check totalspace_simple
RES=$?
;;
"totalspacedelta")
totalspace_delta
RES=$?
;;
"sessionlock")
check_sessionlock
RES=$?
;;
"newtickets")
check_checknewtickets
RES=$?
;;
"locksextended")
check_sessionlock_v5
#check_sessionlock_v4
#check_sessionlock_v3
#check_sessionlock_extended
RES=$?
;;
"biggertables")
check_bigger_tables
RES=$?
;;
"sharedpool")
check_sharedpool
RES=$?
;;
"developers")
check_developers
RES=$?
;;
"activesessions")
check_activesessions
RES=$?
;;
"ospassword")
check_password_expiration
RES=$?
;;
"userslocked")
check_userslocked
RES=$?
;;
"sessionlockv5")
check_sessionlock_v5
RES=$?
;;
"alltablespacesspace")
all_tablespaces_space
RES=$?
;;
"plsqllines")
statistics_check plsqllines
;;
*)
exit $STATE_UNKNOWN
;;
esac
# EXIT STATUS
# STATE_OK=0
# STATE_WARNING=1
# STATE_CRITICAL=2
# STATE_UNKNOWN=3
# STATE_DEPENDENT=4
# /EXIT STATUS
#WIP
exit ${RES}
