pandorafms/pandora_plugins/MySQL/pandora_mysql.pl

#!/usr/bin/perl
# Pandora FMS Plugin for MySQL
# (c) Artica ST 2015
# v1.4, 19 Feb 2015
# ----------------------------------------------------------------------

# Default lib dir for RPM and DEB packages
use lib '/usr/lib/perl5';

use strict;
use Data::Dumper;
use POSIX qw(setsid strftime);
use POSIX;
use Time::Local;

#---------------------------- Global parameters -----------------------#

# OS and OS version
my $OS = $^O;

# Store original PATH
my $ORIGINAL_PATH = $ENV{'PATH'};

# FLUSH in each IO
$| = 1;

# Conf file divided line by line
my @config_file;
# Conf filename received by command line
my $archivo_cfg = $ARGV[0];
# Hash with this plugin setup
my %plugin_setup; 
# Array with different block checks 
my @checks;

# ----------------------------------------------------------------------
# parse_dosline (line) 
#
# This cleans DOS-like line and cleans ^M character. VERY Important when 
# you process .conf edited from DOS
# ----------------------------------------------------------------------
sub parse_dosline ($){
    my $str = $_[0];

    $str =~ s/\r//g;
    return $str;
}

# ----------------------------------------------------------------------
# load_external_setup (config file) 
#
# Loads a config file 
# ----------------------------------------------------------------------
sub load_external_setup ($){
    my $archivo_cfg = $_[0];
    my $buffer_line;

    # Collect items from config file and put in an array
    if (! open (CFG, "< $archivo_cfg")) {
		print "[ERROR] Error opening configuration file $archivo_cfg: $!.\n";
        logger ("[ERROR] Error opening configuration file $archivo_cfg: $!");
        exit 0;
	}

    while (<CFG>) {
		$buffer_line = parse_dosline ($_);
        # Parse configuration file, this is specially difficult because can contain SQL code, with many things
        if ($buffer_line !~ /^\#/) {  # begins with anything except # (for commenting)
			if ($buffer_line =~ m/(.+)\s(.*)/) {
				push @config_file, $buffer_line;
            }
        }
    }
    
    close (CFG);
}

# ----------------------------------------------------------------------
# logger_begin (message)
# Beggining of logging to file
# ----------------------------------------------------------------------
sub logger_begin ($) {
	my ($message) = @_;
		
	my $file = "/tmp/pandora_mysql";
			
    if (! open (FILE, "> $file")) {
		print "[ERROR] Could not open logfile '$file' \n";
        logger ("[ERROR] Error opening logfile $file");
        exit 0;
	}				
				
#	open (FILE, "> $file") or die "[FATAL] Could not open logfile '$file'";
	print FILE strftime ("%Y-%m-%d %H:%M:%S", localtime()) . " >> " . $message . "\n";
	close (FILE);
}

# ----------------------------------------------------------------------
# logger (message)
# Log to file
# ----------------------------------------------------------------------
sub logger ($) {
	my ($message) = @_;
		
	my $file = "/tmp/pandora_mysql";	
	
    if (! open (FILE, ">> $file")) {
		print "[ERROR] Could not open logfile '$file' \n";
        logger ("[ERROR] Error opening logfile $file");
        exit 0;
	}	
	
	print FILE strftime ("%Y-%m-%d %H:%M:%S", localtime()) . " >> " . $message . "\n";
	close (FILE);
}

# ----------------------------------------------------------------------
# trim (string) 
#
# Erase blank spaces before and after the string
# ----------------------------------------------------------------------
sub trim ($) {
	my $string = shift;
	$string =~ s/^\s+//;
	$string =~ s/\s+$//;
	
	return $string;
}

# ----------------------------------------------------------------------
# clean_blank (string)
#
# This function return a string without blankspaces, given a simple text 
# string
# ----------------------------------------------------------------------
sub clean_blank($) {
	my $input = $_[0];
	$input =~ s/[\s\r\n]*//g;
        
    return $input;
}

# ----------------------------------------------------------------------
# print_module (module name, module type, module value, module 
# description, [module severity])
#
# This function returns a XML module part for the plugin
# ----------------------------------------------------------------------
sub print_module ($$$$;$) {
    my $MODULE_NAME = $_[0];
    my $MODULE_TYPE = $_[1];
    my $MODULE_VALUE = $_[2];
    my $MODULE_DESC = $_[3];    
	my $MODULE_SEVERITY = $_[4];

    # If not a string type, remove all blank spaces and check for not value returned!    
    if ($MODULE_TYPE !~ m/string/) {
		$MODULE_VALUE =  clean_blank($MODULE_VALUE);
    }    

    print "<module>\n";
    print "<name>$MODULE_NAME</name>\n";
    print "<type>$MODULE_TYPE</type>\n";
    print "<data><![CDATA[$MODULE_VALUE]]></data>\n";
    print "<description><![CDATA[$MODULE_DESC]]></description>\n";
    if (defined($MODULE_SEVERITY)) {
		print "<status>$MODULE_SEVERITY</status>\n";    
	} else {
		print "<status>NORMAL</status>\n";  	
	}	
		
    print "</module>\n";
}

# ----------------------------------------------------------------------
# parse_config
#
# This function load configuration tokens and store in a global hash
# called %plugin_setup accesible on all program.
# ----------------------------------------------------------------------
sub parse_config {

    my $check_block = 0;
    my $parametro;

    # Some default options
    $plugin_setup{"conf_mysql_homedir"} = "/var/lib/mysql";
    $plugin_setup{"conf_mysql_basedir"} = "/var/lib/mysql";    
    $plugin_setup{"conf_temp"} = "/tmp";
    $plugin_setup{"numchecks"} = 0;
    $plugin_setup{"conf_mysql_version"} = "5.5";

	foreach (@config_file) {
        $parametro = $_;

        if ($parametro =~ m/^include\s(.*)/i) {
            load_external_setup ($1);
        }
    
 	if ($parametro =~ m/^conf\_mysql\_version\s(.*)/i) {
            $plugin_setup{"conf_mysql_version"} = trim($1);
        }

        if ($parametro =~ m/^conf\_mysql\_user\s(.*)/i) {
            $plugin_setup{"conf_mysql_user"} = trim($1);
        }
    
        if ($parametro =~ m/^conf\_mysql\_pass\s(.*)/i) {
	    my $temp = $1;
	    $temp =~ s/\"//g;
            $plugin_setup{"conf_mysql_pass"} = trim($temp);
        }

        if ($parametro =~ m/^conf\_mysql\_host\s(.*)/i) {
            $plugin_setup{"conf_mysql_host"} = trim($1);
        }
        
        if ($parametro =~ m/^conf\_mysql\_homedir\s(.*)/i) {
			$plugin_setup{"conf_mysql_homedir"} = trim($1);
		}
		if ($parametro =~ m/^conf\_mysql\_basedir\s(.*)/i) {
			$plugin_setup{"conf_mysql_basedir"} = trim($1);
		}
		
        if ($parametro =~ m/^conf\_mysql\_logfile\s(.*)/i) {
			$plugin_setup{"conf_mysql_logfile"} = trim($1);
		}
	
        if ($parametro =~ m/^conf\_temp\s(.*)/i) {
			$plugin_setup{"conf_temp"} = trim($1);
		}
		
        if ($parametro =~ m/^conf\_logparser\s(.*)/i) {
			$plugin_setup{"conf_logparser"} = trim($1);
		}		
		
        # Detect begin of check definition
        if ($parametro =~ m/^check\_begin/i) {
            $check_block = 1;
            $checks[$plugin_setup{"numchecks"}]{'type'} = 'unknown';
        }
        
		############### Specific check block parsing ###################       		
		if ($check_block == 1) {

			if ($parametro =~ m/^check\_end/i) {
				$check_block = 0;
				$plugin_setup{"numchecks"}++;
			}
		
			# Try to parse check type (System parameters)
			if ($parametro =~ m/^check\_mysql\_service/i) {
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'mysql_service';
			} 
			
			if ($parametro =~ m/^check\_mysql\_memory/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'mysql_memory';				
			}
			
			if ($parametro =~ m/^check\_mysql\_cpu/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'mysql_cpu';				
			}
			
			if ($parametro =~ m/^check\_system\_timewait/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'system_timewait';				
			}
	
			if ($parametro =~ m/^check\_system\_diskusage/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'system_diskusage';				
			}		
	
			if ($parametro =~ m/^check\_mysql\_ibdata1/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'mysql_ibdata1';				
			}	

			if ($parametro =~ m/^check\_mysql\_logs/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'mysql_logs';				
			}
			
			if ($parametro =~ m/^check\_mysql\_connect/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'mysql_connection';				
			}		
			
			
			# Try to parse check type (Performance parameters)
			if ($parametro =~ m/^mysql\_status\s(.*)/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'status';
				$checks[$plugin_setup{"numchecks"}]{'show'} = trim($1);					
			}
			
			# Try to parse check type (Open SQL interface)
			if ($parametro =~ m/^check\_sql\s(.*)/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'sql';
				$checks[$plugin_setup{"numchecks"}]{'sql'} = trim($1);					
			}
			
			# Try to parse check type (Query Innodb status)
			if ($parametro =~ m/^mysql\_innodb\s(.*)/i) { 
				$checks[$plugin_setup{"numchecks"}]{'type'} = 'innodb';
				$checks[$plugin_setup{"numchecks"}]{'query'} = trim($1);					
			}			
			
			if ($parametro =~ m/^check\_name\s(.*)/i) { 
				$checks[$plugin_setup{"numchecks"}]{'check_name'} = trim($1);					
			}	
			
			if ($parametro =~ m/^check\_schema\s(.*)/i) { 
				$checks[$plugin_setup{"numchecks"}]{'check_schema'} = trim($1);					
			}					
			
			if ($parametro =~ m/^module\_type\s(generic_data|generic_data_inc|generic_data_string|generic_proc|async_string|async_proc|async_data)/i) { 
				$checks[$plugin_setup{"numchecks"}]{'module_type'} = trim($1);				
			}			
			
			if ($parametro =~ m/^post\_condition\s+(==|!=|<|>)\s+(.*)/i) {
				$checks[$plugin_setup{"numchecks"}]{'postcondition_op'} = trim($1);	
				$checks[$plugin_setup{"numchecks"}]{'postcondition_val'} = trim($2);
			}
			
			if ($parametro =~ m/^post\_execution\s(.*)/i) {
				$checks[$plugin_setup{"numchecks"}]{'postexecution'} = trim($1);
			}
			
			if ($parametro =~ m/^data\_absolute/i) {
				$checks[$plugin_setup{"numchecks"}]{'return_type'} = 'data_absolute';
			}			
		
			if ($parametro =~ m/^data\_delta/i) {
				$checks[$plugin_setup{"numchecks"}]{'return_type'} = 'data_delta';
			}		

			if ($parametro =~ m/^post\_status\s(WARNING|CRITICAL)/i) {
				$checks[$plugin_setup{"numchecks"}]{'status'} = trim($1);
			}			
				
		} # Check block
	
	}
}

# ----------------------------------------------------------------------
# check_mysql_service
#
# This function check MySQL service status 
# ----------------------------------------------------------------------
sub check_mysql_service {
	my ($mysql_service_result1, $mysql_service_result2, $mysql_service_result3, $mysql_service_result4);
	my $mysql_service_result = 0;
	
	# Try different flavours of mysql status
	$mysql_service_result1 = `service mysql status 2> /dev/null`;
	$mysql_service_result2 = `service mysqld status 2> /dev/null`;
	$mysql_service_result3 = `/etc/init.d/mysql status 2> /dev/null`;		
	$mysql_service_result4 = `/etc/init.d/mysqld status 2> /dev/null`;		
	
	
	#print "1 >> " . $mysql_service_result1 . "\n";
	#print "2 >> " . $mysql_service_result2 . "\n";
	#print "3 >> " . $mysql_service_result3 . "\n";
	#print "4 >> " . $mysql_service_result4 . "\n";	
	
	# If any of these ones is up then check result eq OK!
	if (($mysql_service_result1 =~ /start/i) || ($mysql_service_result1 =~ /running/i) ||
		($mysql_service_result2 =~ /start/i) || ($mysql_service_result2 =~ /running/i) ||
		($mysql_service_result3 =~ /start/i) || ($mysql_service_result3 =~ /running/i) ||
		($mysql_service_result4 =~ /start/i) || ($mysql_service_result4 =~ /running/i)) {
		
		# OK!
		$mysql_service_result = 1;
			
	} else {
		
		# Fail
		$mysql_service_result = 0;
		
	}	

	logger("[INFO] check_mysql_service with result: " . $mysql_service_result);
	
	return $mysql_service_result;
	
}

# ----------------------------------------------------------------------
# check_mysql_memory
#
# This function check MySQL memory usage
# ----------------------------------------------------------------------
sub check_mysql_memory {
	my $mysql_memory_result = 0;
	
	# Depends on OS 
	if ($OS =~ /hpux/i){
		$mysql_memory_result = `ps -eo comm,pmem | grep -v "grep" | grep "mysqld --basedir" | awk '{print \$2}'`;
	} else {
		$mysql_memory_result = `ps aux | grep -v "grep" | grep "mysqld --basedir" | awk '{print \$4}'`;
	}
	
	logger("[INFO] check_mysql_memory with result: " . $mysql_memory_result);	
	
	return $mysql_memory_result;
}

# ----------------------------------------------------------------------
# check_mysql_cpu
#
# This function check MySQL cpu usage
# ----------------------------------------------------------------------
sub check_mysql_cpu {
	my $mysql_cpu_result = 0;
	
	# Depends on OS 
	if ($OS =~ /hpux/i){
		$mysql_cpu_result = `ps -eo comm,pcpu | grep -v "grep" | grep "mysqld --basedir" | awk '{print \$2}'`;
	} else {
		$mysql_cpu_result = `ps aux | grep -v "grep" | grep "mysqld --basedir" | awk '{print \$3}'`;
	}
	
	logger("[INFO] check_mysql_cpu with result: " . $mysql_cpu_result);	
	
	return $mysql_cpu_result;
}

# ----------------------------------------------------------------------
# check_system_timewait
#
# This function check system timewait
# ----------------------------------------------------------------------
sub check_system_timewait {
	my $system_timewait_result = 0;
	
	$system_timewait_result = `netstat -ntu | grep "TIME_WAIT" | wc -l`;
	
	logger("[INFO] check_system_timewait with result: " . $system_timewait_result);	
	
	return $system_timewait_result;
}

# ----------------------------------------------------------------------
# check_system_diskusage
#
# This function check system disk usage
# ----------------------------------------------------------------------
sub check_system_diskusage {
	my $system_diskusage_result_tmp = 0;
	my $system_diskusage_result = 0;
	
	if (!defined($plugin_setup{"conf_mysql_homedir"})) {
		logger("[INFO] system_diskusage_result check needs conf_mysql_homedir token defined in configuration file.");
		return 0;
	}
	
	my $system_diskusage_result_tmp = `df -k "$plugin_setup{'conf_mysql_homedir'}" | awk '{print \$5}' | tail -1 | tr -d "%"`;
 
	$system_diskusage_result = 100 - $system_diskusage_result_tmp;
	
	logger("[INFO] check_system_diskusage with result: " . $system_diskusage_result);	
	
	return $system_diskusage_result;
}


# ----------------------------------------------------------------------
# check_mysql_ibdata1
#
# This function check ibdata1 file disk usage
# ----------------------------------------------------------------------
sub check_mysql_ibdata1 {
	my $mysql_ibdata1_result = 0;
	
	if (!defined($plugin_setup{"conf_mysql_basedir"})) {
		logger("[INFO] check_mysql_ibdata1 check needs conf_mysql_basedir token defined in configuration file.");
	}
	
	$mysql_ibdata1_result = `du -k $plugin_setup{"conf_mysql_basedir"}/ibdata1 | tail -1 | awk '{ print \$1 }'`;
	
	logger("[INFO] check_mysql_ibdata1 with result: " . $mysql_ibdata1_result);
	
	return $mysql_ibdata1_result;
}

# ----------------------------------------------------------------------
# check_mysql_connection
#
# This function check connection against MySQL, if goes wrong abort monitoring
# ----------------------------------------------------------------------
sub check_mysql_connection {
	my $mysql_connection_result = 1;
	my $connection_string = 0;
	if (!defined($plugin_setup{"conf_mysql_pass"})){
	$connection_string = "mysql -u" . $plugin_setup{"conf_mysql_user"} .  
								 " -h" . $plugin_setup{"conf_mysql_host"} ;
						}else{
	# Connection string
	$connection_string = "mysql -u" . $plugin_setup{"conf_mysql_user"} . 
								 " -p" . $plugin_setup{"conf_mysql_pass"} . 
								 " -h" . $plugin_setup{"conf_mysql_host"} ;
	}
	my $tmp_file = $plugin_setup{'conf_temp'} . '/mysql_connection.tmp';
								 
	my $connection_result = `$connection_string -e "SELECT 1 FROM DUAL" 2> $tmp_file`;
		
	# Collect info from temp file
	open (TMP, "< $tmp_file");
	
	while (<TMP>) {
		my $buffer_line = parse_dosline ($_);
		
		if ($buffer_line =~ /error/i) {
			$mysql_connection_result = 0;
		}
	}
	
	close (TMP);
	
	unlink($tmp_file);		

	logger("[INFO] check_mysql_connection with result: " . $mysql_connection_result);
	
	# Abort monitoring
	if ($mysql_connection_result == 0) {
		print_module("MySQL_connection_error", "async_string", "Error", "MySQL plugin cannot connect to Database. Abort execution of plugin", "CRITICAL");
	}
	
	return $mysql_connection_result;
}


# ----------------------------------------------------------------------
# check_mysql_logs
#
# This function check ibdata1 file disk usage
# ----------------------------------------------------------------------
sub check_mysql_logs(;$) {
    my $module_type = $_[0];
	
	my $mysql_logs_result = 0;
	
	if (!defined($plugin_setup{"conf_logparser"})) {
		logger("[INFO] check_mysql_logs check needs conf_logparser token defined in configuration file.");
		return 0;
	}
	
	if (!defined($plugin_setup{"conf_logparser"})) {
		logger("[INFO] check_mysql_logs check needs conf_mysql_logfile token defined in configuration file.");
		return 0;
	}	
	
	my $plugin_call = $plugin_setup{"conf_logparser"}. " " . $plugin_setup{"conf_mysql_logfile"} . " MySQL_error_logs error 2> /dev/null";

	$mysql_logs_result = `$plugin_call`;

    if ($mysql_logs_result ne "") {
		logger ("[INFO] check_mysql_logs with result:\n$mysql_logs_result");		
        print $mysql_logs_result;
        
		# Process output of grep_log plugin
		my @temp = split ("\n", $mysql_logs_result);
		my @result;
		
		# Try to get return values
		my $i = 0;
		foreach (@temp) {
			# Get return values
			if ($_ =~ /<data><value><!\[CDATA\[(.*)\]\]><\/value><\/data>/){
				$result[$i] = $1;
				$i++;
			}
		}
		
		return @result;        
        
    } else {
		logger ("[INFO] Blank output in check_mysql_logs searching in logfile: " . $plugin_setup{"conf_mysql_logfile"});
		
#		if (defined($module_type)) {
#			print_module("MySQL_error_logs", $module_type, "Blank output", "Blank output in check_mysql_logs searching in logfile " . $plugin_setup{"conf_mysql_logfile"});
#		} else {
#			print_module("MySQL_error_logs", "async_string", "Blank output", "Blank output in check_mysql_logs searching in logfile " . $plugin_setup{"conf_mysql_logfile"});			
#		}
	}
}

# ----------------------------------------------------------------------
# check_mysql_status (SHOW parameter, [SQL statement/ Query for Innodb status, Mysql_schema])
#
# This function check status parameter (Performance parameters)
# ----------------------------------------------------------------------
sub check_mysql_status($;$$) {
	my $show_parameter = $_[0];
	my $sql_statement = $_[1];	
	my $sql_schema = $_[2];	
	my $mysql_status_result = 0;
	
	if (!defined($show_parameter)){
		logger("[INFO] Empty parameter in check_mysql_status check, please revise configuration file.");
		return 0;
	}
	
	# Writes in temp file
	my $temp_file = $plugin_setup{"conf_temp"} . "/mysql_pandora.tmp";
	
    open (TEMP1, "> " . $temp_file);
    
    # Depends on the request write different statements ('pending_io', 'sql', 'innodb' is different)
    if ($show_parameter =~ /processlist/i) {
		print TEMP1 "SHOW " . $show_parameter;
	} elsif ($show_parameter =~ /total_size/i) {
		print TEMP1 "SELECT \"Total_size\", 
						   sum( data_length + index_length ) / 1024 / 1024 / 1024 \"Data Base Size in GB\" 
					FROM information_schema.TABLES";
    } elsif (($show_parameter !~ /pending_io/i) and ($show_parameter !~ /sql/i) and ($show_parameter ne 'innodb')) {
		print TEMP1 "SHOW GLOBAL STATUS LIKE '" . $show_parameter . "'";
	}
    
    close (TEMP1);

	# Connection string
	my $connection_string = 0;
	if (!defined($plugin_setup{"conf_mysql_pass"} ) ){
	$connection_string = "mysql -u" . $plugin_setup{"conf_mysql_user"} .  
								 " -h" . $plugin_setup{"conf_mysql_host"} ;
						}else{
	$connection_string = "mysql -u" . $plugin_setup{"conf_mysql_user"} . 
								 " -p" . $plugin_setup{"conf_mysql_pass"} . 
								 " -h" . $plugin_setup{"conf_mysql_host"} ;
	}
	#my $connection_string = "mysql -u" . $plugin_setup{"conf_mysql_user"} . 
	#							 " -p" . $plugin_setup{"conf_mysql_pass"} . 
	#							 " -h" . $plugin_setup{"conf_mysql_host"} ;
								 
	# If its a query, then try to add schema to the connection string
	if ($show_parameter =~ /sql/i) {
		if (defined($sql_schema)) {
			$connection_string .= " $sql_schema";
		}
	}
		
	my $post_sql = '';			
	# If we want to retrieve 'active sessions' count lines				 
	if ($show_parameter =~ /processlist/i) {
		$post_sql = ' | wc -l';
	} # Rest of request have this suffix 
	else {
		$post_sql = ' | tail -1 | awk \'{print $2}\'';
	}
	
	# 'pending_io' and 'sql' and 'innodb' are different
	if (($show_parameter !~ /pending_io/i) and ($show_parameter !~ /sql/i) and ($show_parameter ne 'innodb')) {										 
		$mysql_status_result = `$connection_string  <  $temp_file  $post_sql`;							 
	} elsif ($show_parameter =~ /sql/i) {
		$mysql_status_result = `$connection_string -e "$sql_statement" | tail -1`;
	} elsif ($show_parameter =~ /innodb/i) {


		if ($plugin_setup{"conf_mysql_version"} == "5.0") {
			$mysql_status_result = `$connection_string -e "SHOW INNODB STATUS\\G"`;
		} else {
			$mysql_status_result = `$connection_string -e "SHOW ENGINE INNODB STATUS\\G"`;
		}

		# Process output of show innodb status
		my @temp = split ("\n", $mysql_status_result);
		
		# If we detect query lines then output
		$mysql_status_result = 0;
		foreach (@temp) {
			if ($_ =~ m/$sql_statement\s+(.*)/) {
				$mysql_status_result = $1;
			}
		}

	} else {

		if ($plugin_setup{"conf_mysql_version"} == "5.0") {
			$mysql_status_result = `$connection_string -e "SHOW INNODB STATUS\\G"`;
		} else {
			$mysql_status_result = `$connection_string -e "SHOW ENGINE INNODB STATUS\\G"`;
		}
	
		# Process output of show innodb status
		my @temp = split ("\n", $mysql_status_result);
		
		# If we detect 'i/o waiting' lines then increment counter
		$mysql_status_result = 0;
		foreach (@temp) {
			if ($_ =~ m/(.*)waiting for i\/o request(.*)/){
				$mysql_status_result++;
			}
		}
	}
	
	unlink ($temp_file);

	# If we want to retrieve active session substract 1 due to header
	if ($show_parameter =~ /processlist/i) {
		if ($mysql_status_result > 0){
			$mysql_status_result--;
		}
	}

	logger("[INFO] check_mysql_status executing: $show_parameter with result: " . $mysql_status_result);
	
	return $mysql_status_result;
}

# ----------------------------------------------------------------------
# is_numeric (arg)
#
# Return TRUE if given argument is numeric
# ----------------------------------------------------------------------
sub is_numeric($) {
	my $val = $_[0];
	
	if (!defined($val)){
		return 0;
	}
	# Replace "," for "."
	$val =~ s/\,/\./;
	
	my $DIGITS = qr{ \d+ (?: [.] \d*)? | [.] \d+ }xms;
	my $SIGN   = qr{ [+-] }xms;
	my $NUMBER = qr{ ($SIGN?) ($DIGITS) }xms;
	if ( $val !~ /^${NUMBER}$/ ) {
		return 0;   #Non-numeric
	} else {
		return 1;   #Numeric
	}
}

# ----------------------------------------------------------------------
# eval_postcondition (result, operator, value)
#
# This function eval postcondition and return a boolean
# ----------------------------------------------------------------------
sub eval_postcondition($$$) {
	my $result = $_[0];
	my $operator = $_[1];
	my $value = $_[2];
	my $eval_postcondition_result = 0;

	my $result_type = is_numeric($result);
	
	logger("[INFO] Evaluating poscondition: $result $operator $value.");
	
	 # Numeric result
	if ($result_type == 1) {
		 # Equal to
		if ($operator =~ /==/) {
			if (int($result) == int($value)) {
				
				$eval_postcondition_result = 1;
				
			}
		}# Not equal to
		elsif ($operator =~ /!=/) {
			
			if (int($result) != int($value)) {
				
				$eval_postcondition_result = 1;
				
			}			
		}# Less than
		elsif ($operator =~ /</) {
			
			if (int($result) < int($value)) {
				
				$eval_postcondition_result = 1;
				
			}			
		}# More than
		elsif ($operator =~ />/) {
			
			if (int($result) > int($value)) {
				
				$eval_postcondition_result = 1;
				
			}			
		} else {
			
			logger("[ERROR] Unknown operator in postcondition, please revise your configuration file.");
			$eval_postcondition_result = 0;
			
		}	
	} # Non numeric result
	else {
		
		my $result_value = sprintf("%s", $result);
		my $string_value = sprintf("%s", $value);
		
		 # Equal to
		if ($operator =~ /==/) {
			
			if ($result_value =~ /$string_value/) {
				
				$eval_postcondition_result = 1;
				
			}
		}# Not equal to
		elsif ($operator =~ /!=/) {
			
			if ($result_value !~ /$string_value/) {
				
				$eval_postcondition_result = 1;
				
			}			
		}# Less than
		elsif ($operator =~ /</) {
			
			if ($result_value lt $string_value) {
				
				$eval_postcondition_result = 1;
				
			}			
		}# More than
		elsif ($operator =~ />/) {
			
			if ($result_value gt $string_value) {
				
				$eval_postcondition_result = 1;
				
			}			
		} else {
			
			logger("[ERROR] Unknown operator in postcondition, please revise your configuration file.");
			$eval_postcondition_result = 0;
			
		}			
	}
	
	return $eval_postcondition_result;
}

# ----------------------------------------------------------------------
# eval_postcondition_array (Array result, operator, value)
#
# This function eval postcondition and return a boolean if some of the 
# elements fulfill the condition
# ----------------------------------------------------------------------
sub eval_postcondition_array {
	# This works
	my $value = pop;
	my $operator = pop;
	my @result = @_;
	
	my $eval_postcondition_array_result = 0;
	my $return_postcondition_element = 0;
	
	# Eval all array
	foreach my $single_result (@result) {
		
		$return_postcondition_element = 0;
				
		$return_postcondition_element = eval_postcondition($single_result, $operator, $value);

		if ($return_postcondition_element) {
			$eval_postcondition_array_result = 1;
		}
	}

	return $eval_postcondition_array_result;
}

# ----------------------------------------------------------------------
# store_result_check(check_type, value)
#
# This function stores in a temporary file the last value of the check
# ----------------------------------------------------------------------
sub store_result_check($$) {
	my $type = $_[0];
	my $value = $_[1];
	
	# Compose the temp filename
	my $tmp_file = $plugin_setup{'conf_temp'} . '/mysql_check_' . $type . '.tmp';

	# Try to open temp file
	if (! open (TMP, "> $tmp_file")) {
		logger("[ERROR] Error opening temp file: $tmp_file for write last check value: $type, $value");
		return;
	}
	
	# Write las check value
	print TMP $value;	
	close (TMP);
	
	logger("[INFO] Saving last check value: $value of check: $type in file $tmp_file .");	
}

# ----------------------------------------------------------------------
# process_delta_data(check_type, value)
#
# This function calculates delta value for the current check
# ----------------------------------------------------------------------
sub process_delta_data($$) {
	my $type = $_[0];
	my $value = $_[1];
	my $buffer_line;
	
	# Compose the temp filename
	my $tmp_file = $plugin_setup{'conf_temp'} . '/mysql_check_' . $type . '.tmp';

	# Collect info from temp file
	# If it's not possible then return token for not print module
	if (! open (TMP, "< $tmp_file")) {
		return '::MYSQL _ NON EXEC';
	}
	
	while (<TMP>) {
		$buffer_line = parse_dosline ($_);
	}
	
	my $process_delta_result = int($value) - int($buffer_line);
	
	close (TMP);
	
	# If delta value is negative then reset check last value
	if ($process_delta_result < 0) {
		logger("[INFO] Reset last value of check_" . $type . " due to negative value: " . $process_delta_result);
		return '::MYSQL _ NON EXEC';
	}
	
	logger("[INFO] check_" . $type . " postprocessed by delta calculation: " . $process_delta_result);
	
	return $process_delta_result;
}

###############################################################################
###############################################################################
######################## MAIN PROGRAM CODE ####################################
###############################################################################
###############################################################################

# ----------------------------------------------------------------------
# Checks input parameter from command line (Conf file)
# ----------------------------------------------------------------------
my $log_init = 0;

# Load config file from command line
if ($#ARGV == -1){
	print "I need at least one parameter: Complete path to external configuration file \n";
	logger_begin("[ERROR] Path to configuration file it's needed");
	
	# Logfile is initiated
	$log_init = 1;
	
	exit 0;
}

# Check for conf file
if ( ! -f $archivo_cfg ) {
	printf "\n [ERROR] Cannot open configuration file at $archivo_cfg. \n\n";
	
	if ($log_init == 1) {
		logger("[ERROR] Cannot open configuration file at $archivo_cfg, please set permissions correctly.");
	} else {
		logger_begin("[ERROR] Cannot open configuration file at $archivo_cfg, please set permissions correctly.");
		$log_init = 1;
	}
	
	print_module("MySQL_plugin_error", "generic_proc", 0, "Cannot open configuration file at $archivo_cfg, please set permissions correctly.");
    exit 0;
}

# ----------------------------------------------------------------------
# Parse external configuration file
# ----------------------------------------------------------------------
load_external_setup ($archivo_cfg);

if ($log_init == 1){
	
	logger("[INFO] Parsing config file $archivo_cfg.");	
	
} else {
	
	logger_begin("[INFO] Parsing config file $archivo_cfg.");
	$log_init = 1;	
	
}	

parse_config;

=COMMENT
print Dumper(%plugin_setup);
print Dumper(@checks);

exit;
=cut

# ----------------------------------------------------------------------
# First check connection to MySQL
# ----------------------------------------------------------------------
my $result_connection = check_mysql_connection;
if ($result_connection == 0) {
	logger ("[ERROR] Connection to MySQL error, abort monitoring.");
	exit 0;
}

# ----------------------------------------------------------------------
# Process each check
# ----------------------------------------------------------------------
my $result_check;
my $module_type;
my $module_status;
my @result_check;
my $performance_parameter;
foreach (@checks) {
	
	# Don't asumme performance parameter
	$performance_parameter = 0;
	my $type = $_->{'type'};
	my $postcondition_op =  $_->{'postcondition_op'};
	my $postcondition_val = $_->{'postcondition_val'};
	my $postexecution = $_->{'postexecution'};
	my $check_status = $_->{'status'};
	my $check_show = $_->{'show'};
	my $return_type = $_->{'return_type'};
	my $check_name = $_->{'check_name'};
	
	$result_check = 0;
	# Process check (System parameters)
	if ($_->{'type'} eq 'mysql_service') {
		
		$result_check = check_mysql_service;
		
	} elsif ($_->{'type'} eq 'mysql_memory') {
		
		$result_check = check_mysql_memory;
		
	} elsif ($_->{'type'} eq 'mysql_cpu') {
		
		$result_check = check_mysql_cpu;
		
	} elsif ($_->{'type'} eq 'system_timewait') {
		
		$result_check = check_system_timewait;
		
	} elsif ($_->{'type'} eq 'system_diskusage') {	
			
		$result_check = check_system_diskusage;
							
	} elsif ($_->{'type'} eq 'mysql_ibdata1') {
		
		$result_check = check_mysql_ibdata1;
		
	} elsif ($_->{'type'} eq 'mysql_connection') {
		
		$result_check = check_mysql_connection;
		
	} elsif ($_->{'type'} eq 'mysql_logs') {
		
		@result_check = check_mysql_logs($_->{'module_type'});
		
	}
	# Process check (Perfomance parameters) 
	elsif ($_->{'type'} eq 'status') {
		
		# This is a performance parameter
		$performance_parameter = 1;
		$result_check = check_mysql_status($_->{"show"});
		
	} 
	# Process check (Open SQL interface)
	elsif ($_->{'type'} eq 'sql') {
		
		$performance_parameter = 1;		
		$result_check = check_mysql_status($_->{'type'}, $_->{"sql"}, $_->{'check_schema'});
	
	}
	# Process check (Query Innodb status)
	elsif ($_->{'type'} eq 'innodb') {
		
		$result_check = check_mysql_status($_->{'type'}, $_->{"query"});
				 
	}else {
		
		logger("[INFO] Check block with invalid type, discart it. Please revise your configuration file.");
		$result_check = 0;
		
	}
	
	# Use results
	if (($_->{'type'} ne 'unknown')) {
		
		# Prints module ('mysql_logs' check prints it's module inside check_mysql_logs function)
		if ($_->{'type'} ne 'mysql_logs') {
			
			# Evalue module type
			$module_type = $_->{'module_type'};

			 # 'mysql_service' and 'mysql_connection' has always generic_proc type
			if (($_->{'type'} eq 'mysql_service') or ($type eq 'mysql_connection')) {

				$module_type = 'generic_proc';
			
			}# By default type is generic_data 
			else {
				
				$module_type = 'generic_data';
			
			}
			
			my $last_result_check = $result_check;
			# If where are dealing with a performance parameter then look at return_type value
			if ($performance_parameter and defined($_->{'return_type'})) {
				
				if ($_->{'return_type'} eq 'data_delta') {
	
					$result_check = process_delta_data($_->{'type'} . '_' . $_->{'show'}, $result_check);
						
				}
				
			}
			
			# Store result_check in temp file for delta postprocess 
			if ($performance_parameter) {
				
				store_result_check($type . '_' . $check_show, $last_result_check);
			
			}				

		}
		
		 # Postcondition ('mysql_logs' type will have an array like result)
		my $exec_postexecution = 0;
		my $result_check_test = sprintf("%s", $result_check);
		if (($type eq 'mysql_logs') and ($result_check_test ne '::MYSQL _ NON EXEC')) {

#			if (defined($postcondition_op) and defined($postcondition_val)) {

#				$exec_postexecution = eval_postcondition_array(@result_check, $postcondition_op, $postcondition_val);
				
#			}

			# If data has been returned, exec postcommand
			if (@result_check) {
				$exec_postexecution = 1;
			}
			
		}# Postcondition (other check types) 
		elsif (defined($postcondition_op) and defined($postcondition_val) and ($result_check_test ne '::MYSQL _ NON EXEC')) {
			
			$exec_postexecution = eval_postcondition($result_check, $postcondition_op, $postcondition_val);
			
		}

		# If postcondition is not fulfilled then don't assign status to module
		if (!$exec_postexecution) {
			$check_status = 'NORMAL';
		}
		
		# Prints module ('mysql_logs' check prints it's module inside check_mysql_logs function)
		if ($type ne 'mysql_logs') {		
			if ($result_check_test ne '::MYSQL _ NON EXEC') { 
				# Prints module
				if ($type eq 'status') {
					print_module("MySQL_" . $type . '_' . $check_show, $module_type, $result_check, '', $check_status);
				} else {
					if (defined($check_name)) {
						print_module("MySQL_" . $type . "_" . $check_name, $module_type, $result_check, '', $check_status);					
					} else {
						print_module("MySQL_" . $type, $module_type, $result_check, '', $check_status);
					}
				}
			} else {
				logger("[INFO] First execution of delta value for check $type, ignoring.");
			}
		}	

		# Exec command
		if ($exec_postexecution) {
			
			if (defined($postexecution)) {
				
				logger("[INFO] Executing postexecution command: " . $postexecution);
				if ($postexecution =~ /\_DATA\_/i) {
					my $round_data = ceil ($result_check);

					logger("[INFO] Detected macro _DATA_ in postexecution command, replacing with: $result_check");
					$postexecution =~ s/\_DATA\_/$round_data/;
				}
				my $command_output = `$postexecution`;
				logger("[INFO] Postexecution command result: " . $command_output);
				
			}
		}		
		
	} # type ne 'unknown'
}