#!/usr/bin/env perl
# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
package xCAT_monitoring::nagiosmon;
BEGIN
{
$::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
}
use lib "$::XCATROOT/lib/perl";
use strict;
use File::Copy qw/copy cp mv move/;
use xCAT::NodeRange;
use Sys::Hostname;
use xCAT::Utils;
use xCAT::GlobalDef;
use xCAT_monitoring::monitorctrl;
use xCAT::MsgUtils;
use xCAT::DBobjUtils;
use xCAT::TableUtils;
use xCAT::NetworkUtils;
use Data::Dumper;
1;
#-------------------------------------------------------------------------------
=head1 xCAT_monitoring:nagiosmon
=head2 Package Description
xCAT monitoring plugin package to handle Nagios monitoring.
=cut
#-------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
=head3 start
This function gets called by the monitorctrl module
when xcatd starts and when monstart command is issued by the user.
It starts the daemons and does necessary startup process for the Nagios monitoring.
p_nodes -- a pointer to an arrays of nodes to be monitored. null means all.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means both localhost and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(return code, message)
if the callback is set, use callback to display the status and error.
=cut
#--------------------------------------------------------------------------------
sub start {
print "nagiosmon::start called\n";
my $noderef=shift;
if ($noderef =~ /xCAT_monitoring::nagiosmon/) {
$noderef=shift;
}
my $scope=shift;
my $callback=shift;
my $grands=shift;
my $localhostname=hostname();
#only start once. this function will get called twice for mn, once for children and once for grand children.
if (($grands) && (keys(%$grands) > 0)) {
return (0, "ok");
}
my $isSN=xCAT::Utils->isServiceNode();
my $mychildren_cfg="/etc/nagios/objects/mychildren.cfg";
if ($isSN) { #start nagios daemon only when mychildren exists on the sn
if (-f $mychildren_cfg) {
my $rc=`service nagios restart 2>&1`;
reportError("$localhostname: $rc", $callback);
}
}
else { #always start nagios daemon on mn
my $rc=`service nagios restart 2>&1`;
reportError("$localhostname: $rc", $callback);
}
#go to nodes to start nrpe
my $inactive_nodes=[];
if (($scope) && ($noderef)) {
my @mon_nodes=@$noderef;
my %nodes_status=xCAT::NetworkUtils->pingNodeStatus(@mon_nodes);
$inactive_nodes=$nodes_status{$::STATUS_INACTIVE};
if (@$inactive_nodes>0) {
my $error="The following nodes cannot have nrpe started because they are inactive:\n @$inactive_nodes.";
reportError("$localhostname: $error", $callback);
}
my $active_nodes=$nodes_status{$::STATUS_ACTIVE};
if (@$active_nodes > 0) {
my $nodelist=join(',',@$active_nodes);
my $result=`XCATBYPASS=Y $::XCATROOT/bin/xdsh $nodelist "service nrpe restart" 2>&1`;
if ($?) {
reportError("$localhostname: $result", $callback);
return (1, $result);
}
}
}
return (0, "started");
}
#--------------------------------------------------------------------------------
=head3 stop
This function gets called when monstop command is issued by the user.
It stops the monitoring on all nodes, stops the Nagios daemons.
Arguments:
p_nodes -- a pointer to an arrays of nodes to be stoped for monitoring. null means all.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means both monservers and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(return code, message)
if the callback is set, use callback to display the status and error.
=cut
#--------------------------------------------------------------------------------
sub stop {
print "nagiosmon::stop called\n";
my $noderef=shift;
if ($noderef =~ /xCAT_monitoring::nagiosmon/) {
$noderef=shift;
}
my $scope=shift;
my $callback=shift;
my $grands=shift;
#only stop one. this function will get called twice for mn, once for children and once for grand children.
if (($grands) && (keys(%$grands) > 0)) {
return (0, "ok");
}
my $localhostname=hostname();
my $rc=`service nagios stop 2>&1`;
reportError("$localhostname: $rc", $callback);
#go to nodes to start nrpe
if (($scope) && ($noderef)) {
my @mon_nodes=@$noderef;
my %nodes_status=xCAT::NetworkUtils->pingNodeStatus(@mon_nodes);
my $active_nodes=$nodes_status{$::STATUS_ACTIVE};
if (@$active_nodes > 0) {
my $nodelist=join(',',@$active_nodes);
my $result=`XCATBYPASS=Y $::XCATROOT/bin/xdsh $nodelist "service nrpe stop" 2>&1`;
if ($?) {
reportError("$localhostname: $result", $callback);
return (1, $result);
}
}
}
return (0, "stopped");
}
#--------------------------------------------------------------------------------
=head3 config
This function configures the cluster for the given nodes.
This function is called when moncfg command is issued or when xcatd starts
on the service node. It will configure the cluster to include the given nodes within
the monitoring doamin.
Arguments:
p_nodes -- a pointer to an arrays of nodes to be added for monitoring. none means all.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means localhost and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
grands -- a hash pointer to store the information of the grandchildren. key: "servicenode,xcatmaseter" for the grandchildren, value: a array pointer of grandchildren nodes. This one is only set when the current node is mn and handleGrandChildren returns 1 by the monitoring plugin.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub config {
print "nagiosmon:config called\n";
my $noderef=shift;
if ($noderef =~ /xCAT_monitoring::nagiosmon/) {
$noderef=shift;
}
my $scope=shift;
my $callback=shift;
my $grands=shift;
#print "*****nagiosmon::config: noderef:" . Dumper($noderef);
#print "*****nagiosmon::config: grands:" . Dumper($grands);
my $localhostname=hostname();
#the identification of this node
my @hostinfo=xCAT::NetworkUtils->determinehostname();
my $isSN=xCAT::Utils->isServiceNode();
my %iphash=();
foreach(@hostinfo) {$iphash{$_}=1;}
if (!$isSN) { $iphash{'noservicenode'}=1;}
#set up the general settings in nagios.cfg file
my $nagios_cfg="/etc/nagios/nagios.cfg";
if (-f $nagios_cfg) {
#save the old version
if (! -f "$nagios_cfg".".ORIG") {
copy($nagios_cfg, "$nagios_cfg".".ORIG");
}
copy($nagios_cfg, "$nagios_cfg".".save");
if ($isSN) {
#configuration for SN
my @ret=setup_nagios_cfg_sn($nagios_cfg);
if ((@ret > 0) && ($ret[0] != 0)) { return @ret; }
} else {
#configuration for MN
my @ret=setup_nagios_cfg_mn($nagios_cfg);
if ((@ret > 0) && ($ret[0] != 0)) { return @ret; }
}
} else {
return (1, "$nagios_cfg cannot be found. Please make sure Nagios is installed.");
}
#adding children nodes
if (($noderef) && (@$noderef > 0)) {
my $pPairHash=xCAT_monitoring::monitorctrl->getMonServer($noderef);
if (ref($pPairHash) eq 'ARRAY') {
reportError($pPairHash->[1], $callback);
return (0, "");
}
#print "noderef=" . Dumper($noderef);
#print "iphash=" . Dumper(%iphash);
#print "pPairHash=" . Dumper($pPairHash);
foreach my $key (keys (%$pPairHash)) {
my @key_a=split(':', $key);
if (! $iphash{$key_a[0]}) { next;}
my $mon_nodes=$pPairHash->{$key};
my $master=$key_a[1];
#figure out what nodes to add
my @nodes_to_add=();
if ($mon_nodes) {
foreach(@$mon_nodes) {
my $node=$_->[0];
my $nodetype=$_->[1];
if ($nodetype){
if ($nodetype =~ /$::NODETYPE_OSI/) { push(@nodes_to_add, $node); }
}
}
}
#print "nodestoadd=@nodes_to_add\n";
#add new nodes to the Nagios cluster
if (@nodes_to_add> 0) {
my @ret=addNodes(\@nodes_to_add, $master, $scope, $callback, 0);
if ((@ret > 0) && ($ret[0] != 0)) { return @ret;}
}
}
}
#for grand childdren
if ((!$isSN) && ($grands) && (keys(%$grands) > 0)) {
my @ret=addGrandNodes($grands, $scope, $callback, 0);
if ((@ret > 0) && ($ret[0] != 0)) { return @ret;}
}
return (0, "configured");
}
sub setup_nagios_cfg_mn {
my $nagios_cfg=shift;
#set enable_notifications=1
`grep "enable_notifications=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*enable_notifications=.*\$/enable_notifications=1/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "enable_notifications=1" >> $nagios_cfg`;
}
#set execute_service_checks=1
`grep "execute_service_checks=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*execute_service_checks=.*\$/execute_service_checks=1/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "execute_service_checks=1" >> $nagios_cfg`;
}
#set check_external_commands=1
`grep "check_external_commands=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*check_external_commands=.*\$/check_external_commands=1/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "check_external_commands=1" >> $nagios_cfg`;
}
#set accept_passive_service_checks=1
`grep "accept_passive_service_checks=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*accept_passive_service_checks=.*\$/accept_passive_service_checks=1/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "accept_passive_service_checks=1" >> $nagios_cfg`;
}
return (0, "ok");
}
sub setup_nagios_cfg_sn {
my $nagios_cfg=shift;
#set enable_notifications=0
`grep "enable_notifications=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*enable_notifications=.*\$/enable_notifications=0/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "enable_notifications=0" >> $nagios_cfg`;
}
#set obsess_over_services=1
`grep "obsess_over_services=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*obsess_over_services=.*\$/obsess_over_services=1/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "obsess_over_services=1" >> $nagios_cfg`;
}
#set ocsp_command=submit_service_check_result
`grep "ocsp_command=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*ocsp_command=.*\$/ocsp_command=submit_service_check_result/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "ocsp_command=submit_service_check_result" >> $nagios_cfg`;
}
#set obsess_over_hosts=1
`grep "obsess_over_hosts=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*obsess_over_hosts=.*\$/obsess_over_hosts=1/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "obsess_over_hosts=1" >> $nagios_cfg`;
}
my $local_cfg= "/etc/nagios/objects/localhost.cfg";
if (-f $local_cfg) {
mv($local_cfg, "$local_cfg.save");
}
my $rc=`grep "cfg_file=$local_cfg" $nagios_cfg`;
#print "my rc=$rc\n";
#print "grep \"cfg_file=$local_cfg\" $nagios_cfg\n";
if ($rc && ($rc !~ /^(\s)*\#/)) {
`sed -i 's/cfg_file=\\\/etc\\\/nagios\\\/objects\\\/localhost.cfg/\#cfg_cfg=\\\/etc\\\/nagios\\\/objects\\\/localhost.cfg/' $nagios_cfg`;
}
#set ochp_command=submit_host_check_result
`grep "ochp_command=" $nagios_cfg`;
if ($? == 0) {
my $rc=`sed -i 's/^[\#]*ochp_command=.*\$/ochp_command=submit_host_check_result/' $nagios_cfg`;
if ($?) {
`echo "$rc"`;
}
} else {
`echo "ochp_command=submit_host_check_result" >> $nagios_cfg`;
}
#add commands in commands.cfg
my $commands_cfg="/etc/nagios/objects/commands.cfg";
if (-f $commands_cfg) {
#save the old version
if (! -f "$commands_cfg".".ORIG") {
copy($commands_cfg, "$commands_cfg".".ORIG");
}
copy($commands_cfg, "$commands_cfg".".save");
my $rc=`grep "submit_service_check_result" $commands_cfg |grep command_name`;
if (!$rc || ($rc !~ /^(\s)*command_name(\s)+submit_service_check_result$/)) {
`echo "define command{
command_name submit_service_check_result
command_line /usr/lib/nagios/plugins/eventhandler/submit_service_check_result \\\$HOSTNAME\$ '\\\$SERVICEDESC\\\$' \\\$SERVICESTATE\$ '\\\$SERVICEOUTPUT\\\$'
}" >> $commands_cfg`;
}
my $rc=`grep "submit_host_check_result" $commands_cfg |grep command_name`;
if (!$rc || ($rc !~ /^(\s)*command_name(\s)+submit_host_check_result$/)) {
`echo "define command{
command_name submit_host_check_result
command_line /usr/lib/nagios/plugins/eventhandler/submit_host_check_result \\\$HOSTNAME\$ \\\$HOSTSTATE\$ '\\\$HOSTOUTPUT\\\$'
}" >> $commands_cfg`;
}
} else {
return (1, "$commands_cfg cannot be found. Please make sure Nagios is installed.");
}
#create ncsa the commands
my $ocsp_command="/usr/lib/nagios/plugins/eventhandler/submit_service_check_result";
my $ochp_command="/usr/lib/nagios/plugins/eventhandler/submit_host_check_result";
my $master=xCAT::TableUtils->get_site_Master();
if (!$master) {
my $rc=`grep XCATMASTER /opt/xcat/xcatinfo`;
if ($rc && ($rc =~/^XCATMASTER=(.*)/)) {
$master=$1;
}
}
my $master_ip="127.0.0.1";
if ($master) {
$master_ip=xCAT::NetworkUtils::getipaddr($master);
}
#print "master=$master, ip=$master_ip\n";
if (-f $ocsp_command) {
#save the old version
if (! -f "$ocsp_command".".ORIG") {
copy($ocsp_command, "$ocsp_command".".ORIG");
}
copy($ocsp_command, "$ocsp_command".".save");
}
unlink($ocsp_command);
if (-f $ochp_command) {
#save the old version
if (! -f "$ochp_command".".ORIG") {
copy($ochp_command, "$ochp_command".".ORIG");
}
copy($ochp_command, "$ochp_command".".save");
}
unlink($ochp_command);
open(FILE1, ">$ocsp_command");
print FILE1 "\#!/bin/sh
\# Arguments:
\# \$1 = host_name (Short name of host that the service is
\# associated with)
\# \$2 = svc_description (Description of the service)
\# \$3 = state_string (A string representing the status of
\# the given service - \"OK\", \"WARNING\", \"CRITICAL\"
\# or \"UNKNOWN\")
\# \$4 = plugin_output (A text string that should be used
\# as the plugin output for the service checks)
\#
\# Convert the state string to the corresponding return code
return_code=-1
case \"\$3\" in
OK)
return_code=0
;;
WARNING)
return_code=1
;;
CRITICAL)
return_code=2
;;
UNKNOWN)
return_code=-1
;;
esac
echo \"1=\$1, 2=\$2, 3=\$3, 4=\$4, return_code=\$return_code\" >> /tmp/6.txt
\# pipe the service check info into the send_nsca program, which
\# in turn transmits the data to the nsca daemon on the central
\# monitoring server
/usr/bin/printf \"%s\\t%s\\t%s\\t%s\\n\" \"\$1\" \"\$2\" \"\$return_code\" \"\$4\" | /usr/bin/send_nsca -H $master_ip -c /etc/nagios/send_nsca.cfg
";
close FILE1;
open(FILE2, ">$ochp_command");
print FILE2 "\#!/bin/sh
\# Arguments:
\# \$1 = host_name (Short name of host that the service is
\# associated with)
\# \$2 = state_string (A string representing the status of
\# the given host - \"UP\", \"DOWN\")
\# \$3 = plugin_output (A text string that should be used
\# as the plugin output for the host checks)
\#
# Convert the state string to the corresponding return code
return_code=-1
case \"\$2\" in
UP)
return_code=0
;;
DOWN)
return_code=1
;;
UNREACHABLE)
return_code=1
;;
UNKNOWN)
return_code=-1
;;
esac
echo \"1=\$1, 2=\$2, 3=\$3, return_code=\$return_code\" >> /tmp/5.txt
\# pipe the service check info into the send_nsca program, which
\# in turn transmits the data to the nsca daemon on the central
\# monitoring server
/usr/bin/printf \"%s\\t%s\\t%s\\n\" \"\$1\" \"\$return_code\" \"\$3\" | /usr/bin/send_nsca -H $master_ip -c /etc/nagios/send_nsca.cfg
";
close FILE2;
chmod 0755, "$ocsp_command", "$ochp_command";
return (0, "ok");
}
#--------------------------------------------------------------------------------
=head3 addNodes
This function adds the nodes into the nagios cluster.
Arguments:
nodes --an array of nodes to be added.
master -- the monitoring master of the node.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means localhost and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub addNodes {
my $pmon_nodes=shift;
if ($pmon_nodes =~ /xCAT_monitoring::nagiosmon/) {
$pmon_nodes=shift;
}
my @mon_nodes = @$pmon_nodes;
if (@mon_nodes==0) { return (0, "");}
my $master=shift;
my $scope=shift;
my $callback=shift;
print "nagiosmon.addNodes mon_nodes=@mon_nodes\n";
my @hostinfo=xCAT::NetworkUtils->determinehostname();
my %iphash=();
foreach(@hostinfo) {$iphash{$_}=1;}
my $localhostname=hostname();
my $mychildren_cfg="/etc/nagios/objects/mychildren.cfg";
my $nagios_cfg="/etc/nagios/nagios.cfg";
if (-f $mychildren_cfg) {
#save the old version
if (! -f "$mychildren_cfg".".ORIG") {
copy($mychildren_cfg, "$mychildren_cfg".".ORIG");
}
copy($mychildren_cfg, "$mychildren_cfg".".save");
}
#populate mychildren with new hosts
#print "defining hosts in $mychildren_cfg\n";
foreach my $node (@mon_nodes) {
my $rc=`grep host_name $mychildren_cfg |grep $node`;
if (($rc) && ($rc =~ /host_name(\s)+$node(\s)*$/)) {
#if found, remove first
`sed -i "/#BEGIN HOST $node/,/#END HOST $node/ d" $mychildren_cfg`
}
my $ip=xCAT::NetworkUtils->getipaddr($node);
#print "ip=$ip\n";
`echo "\#BEGIN HOST $node
define host\{\n use linux-server
host_name $node
alias $node
address $ip
max_check_attempts 10
contact_groups admins
\}
\#END HOST $node" >> $mychildren_cfg`;
}
#define host group for the nodes
#print "defining host_group in $mychildren_cfg\n";
my $rc=`grep "hostgroup_name" $mychildren_cfg`;
if (!$rc || ($rc !~ /^(\s)*hostgroup_name(\s)+mychildren/)) {
`echo "define hostgroup{
hostgroup_name mychildren
alias mychildren
members
}
" >> $mychildren_cfg`;
}
$rc=`grep "members" $mychildren_cfg`;
if ($rc && ($rc =~ /members(\s)+(.*)/)) {
my $oldnodes=$2;
my %nodehash=();
if ($oldnodes) {
my @a=split(',', $oldnodes);
foreach (@a) {
$nodehash{$_}=1;
}
}
foreach my $node (@mon_nodes) {
if (!exists($nodehash{$node})) {
$nodehash{$node}=1;
}
}
my $newnodes=join(',', keys(%nodehash));
if ($newnodes) {
`sed -i 's/members.*\$/members $newnodes/' $mychildren_cfg`;
}
}
#add nrpe command in mychildren.cfg file
#print "defining nrpe command in $mychildren_cfg\n";
my $rc=`grep "command_name" $mychildren_cfg`;
if (!$rc || ($rc !~ /^(\s)*command_name(\s)+check_nrpe/)) {
`echo "\#check_nrpe command definition
define command{
command_name check_nrpe
command_line \\\$USER1\$/check_nrpe -H \\\$HOSTADDRESS\$ -t 30 -c \\\$ARG1\$
}
" >> $mychildren_cfg`;
}
#define services for the new hosts
#print "defining services in $mychildren_cfg\n";
my $rc=`grep "service_description" $mychildren_cfg`;
if (!$rc || ($rc !~ /(\s)*service_description(\s)+SSH/)) {
`echo "define service{\n use generic-service
hostgroups mychildren
service_description SSH
check_command check_ssh
}
" >> $mychildren_cfg`;
}
if (!$rc || ($rc !~ /(\s)*service_description(\s)+FTP/)) {
`echo "define service{\n use generic-service
hostgroups mychildren
service_description FTP
check_command check_ftp
}
" >> $mychildren_cfg`;
}
if (!$rc || ($rc !~ /(\s)*service_description(\s)+Load(\s)*/)) {
`echo "define service{\n use generic-service
contact_groups admins
hostgroups mychildren
service_description Load
check_command check_nrpe!check_load
}
" >> $mychildren_cfg`;
}
if (!$rc || ($rc !~ /(\s)*service_description(\s)+Processes(\s)*/)) {
`echo "define service{\n use generic-service
contact_groups admins
hostgroups mychildren
service_description Processes
check_command check_nrpe!check_total_procs
}
" >> $mychildren_cfg`;
}
if (!$rc || ($rc !~ /(\s)*service_description(\s)+Users(\s)*/)) {
`echo "define service{\n use generic-service
contact_groups admins
hostgroups mychildren
service_description Users
check_command check_nrpe!check_users
}
" >> $mychildren_cfg`;
}
#add cfg_file=/etc/nagios/objects/mychildren.cfg to nagios.cfg file
#print "adding $mychildren_cfg to $nagios_cfg file.\n";
my $rc=`grep "mychildren.cfg" $nagios_cfg`;
if (!$rc || ($rc !~ /^cfg_file=(.*)\/mychildren.cfg/)) {
`echo "\#BEGIN xCAT configiration file mychildren
cfg_file=/etc/nagios/objects/mychildren.cfg
\#END xCAT configiration file mychildren
" >> $nagios_cfg`;
}
#go to nodes to configure nrpe
my $inactive_nodes=[];
if ($scope) {
#print "Configuring the nodes.\n";
my %nodes_status=xCAT::NetworkUtils->pingNodeStatus(@mon_nodes);
$inactive_nodes=$nodes_status{$::STATUS_INACTIVE};
if (@$inactive_nodes>0) {
my $error="The following nodes cannot be configured because they are inactive:\n @$inactive_nodes.";
reportError($error, $callback);
}
my $active_nodes=$nodes_status{$::STATUS_ACTIVE};
if (@$active_nodes > 0) {
my $nodelist=join(',',@$active_nodes);
my $result=`XCATBYPASS=Y $::XCATROOT/bin/updatenode $nodelist -P confNagios 2>&1`;
if ($?) {
my $error= "$result";
reportError($error, $callback);
return (1, $error);
}
}
}
return (0, "ok");
}
#--------------------------------------------------------------------------------
=head3 removeNodes
This function removes the nodes from the nagios cluster.
Arguments:
nodes --an array of nodes to be removed.
master -- the monitoring master of the node.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means localhost and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub removeNodes {
my $pmon_nodes=shift;
if ($pmon_nodes =~ /xCAT_monitoring::nagiosmon/) {
$pmon_nodes=shift;
}
my @mon_nodes = @$pmon_nodes;
if (@mon_nodes==0) { return (0, "");}
my $master=shift;
my $scope=shift;
my $callback=shift;
print "nagiosmon.removeNodes mon_nodes=@mon_nodes\n";
my @hostinfo=xCAT::NetworkUtils->determinehostname();
my %iphash=();
foreach(@hostinfo) {$iphash{$_}=1;}
my $localhostname=hostname();
my $mychildren_cfg="/etc/nagios/objects/mychildren.cfg";
my $nagios_cfg="/etc/nagios/nagios.cfg";
if (-f $mychildren_cfg) {
#save the old version
if (! -f "$mychildren_cfg".".ORIG") {
copy($mychildren_cfg, "$mychildren_cfg".".ORIG");
}
copy($mychildren_cfg, "$mychildren_cfg".".save");
}
if (-f $mychildren_cfg) {
#remove from the host group
my $rc=`grep "hostgroup_name" $mychildren_cfg`;
if ($rc && ($rc =~ /^(\s)*hostgroup_name(\s)+mychildren/)) {
$rc=`grep "members" $mychildren_cfg`;
if ($rc && ($rc =~ /members(\s)+(.*)/)) {
my $oldnodes=$2;
my %nodehash=();
if ($oldnodes) {
my @a=split(',', $oldnodes);
foreach (@a) {
$nodehash{$_}=1;
}
}
foreach my $node (@mon_nodes) {
if (exists($nodehash{$node})) {
delete($nodehash{$node});
}
}
my $newnodes=join(',', keys(%nodehash));
if ($newnodes) {
`sed -i 's/members.*\$/members $newnodes/' $mychildren_cfg`;
#remove the given hosts from mychildren.cfg
foreach my $node (@mon_nodes) {
my $rc=`grep host_name $mychildren_cfg |grep $node`;
if (($rc) && ($rc =~ /host_name(\s)+$node(\s)*$/)) {
#if found, remove it
`sed -i "/#BEGIN HOST $node/,/#END HOST $node/ d" $mychildren_cfg`
}
}
} else { #no nodes in mychildren.cfg
#remove the file and remove it from nagios.cfg
unlink($mychildren_cfg);
my $rc=`grep "mychildren.cfg" $nagios_cfg`;
if ($rc && ($rc =~ /^cfg_file=(.*)\/mychildren.cfg/)) {
`sed -i "/#BEGIN xCAT configiration file mychildren/,/#END xCAT configiration file mychildren/ d" $nagios_cfg`;
}
}
}
}
}
return (0, "ok");
}
#--------------------------------------------------------------------------------
=head3 addGrandNodes
This function adds the grand children nodes into the nagios cluster.
Arguments:
grands -- pointer to a hash. key: "servicenode, xcatmaster" for the nodes,
value: an array pointer to the nodes.
master -- the monitoring master of the node.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means localhost and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub addGrandNodes {
my $grands=shift;
if ($grands =~ /xCAT_monitoring::nagiosmon/) {
$grands=shift;
}
my $scope=shift;
my $callback=shift;
print "nagiosmon.addGrandNodes\n";
my @hostinfo=xCAT::NetworkUtils->determinehostname();
my %iphash=();
foreach(@hostinfo) {$iphash{$_}=1;}
my $localhostname=hostname();
my $cn_template_cfg="/etc/nagios/objects/cn_template.cfg";
my $nagios_cfg="/etc/nagios/nagios.cfg";
#create cn_template.cfg
if (-f $cn_template_cfg) {
#save the old version
if (! -f "$cn_template_cfg".".ORIG") {
copy($cn_template_cfg, "$cn_template_cfg".".ORIG");
}
copy($cn_template_cfg, "$cn_template_cfg".".save");
}
#print "defining xCAT-node in $cn_template_cfg\n";
my $rc=`grep "xCAT-node" $cn_template_cfg`;
if (!$rc || ($rc !~ /^(\s)*name(\s)+xCAT-node/)) {
`echo "define host{
name xCAT-node\n use generic-host
check_period 24x7
active_checks_enabled 0
passive_checks_enabled 1
check_interval 5
retry_interval 1
max_check_attempts 10
check_command check-host-alive
notification_period workhours
notification_interval 120
notification_options d,u,r
contact_groups admins
register 0
}
" >> $cn_template_cfg`;
}
foreach my $sv_pair (keys(%$grands)) {
my @server_pair=split(',', $sv_pair);
my $sv=$server_pair[0];
my $sv1;
if (@server_pair>1) {
$sv1=$server_pair[1];
}
my $pnodes=$grands->{$sv_pair};
my @mon_nodes;
if ($pnodes) {
@mon_nodes=@$pnodes;
}
my $cn_cfg="/etc/nagios/objects/cn_$sv.cfg";
#create compute node cfg file for a service node
if (-f $cn_cfg) {
copy($cn_cfg, "$cn_cfg".".save");
}
#populate cn cfg with new hosts
#print "defining hosts in $cn_cfg\n";
foreach my $node (@mon_nodes) {
my $rc=`grep host_name $cn_cfg |grep $node`;
if (($rc) && ($rc =~ /host_name(\s)+$node(\s)*$/)) {
#if found, remove first
`sed -i "/#BEGIN HOST $node/,/#END HOST $node/ d" $cn_cfg`
}
my $ip=xCAT::NetworkUtils->getipaddr($node);
#print "ip=$ip\n";
`echo "\#BEGIN HOST $node
define host\{\n use xCAT-node
host_name $node
alias $node
address $ip
parents $sv
\}
\#END HOST $node" >> $cn_cfg`;
}
#define host group for the nodes
#print "defining host_group in $cn_cfg\n";
my $rc=`grep "hostgroup_name" $cn_cfg`;
if (!$rc || ($rc !~ /^(\s)*hostgroup_name(\s)+cn_$sv/)) {
`echo "define hostgroup{
hostgroup_name cn_$sv
alias cn_$sv
members
}
" >> $cn_cfg`;
}
$rc=`grep "members" $cn_cfg`;
if ($rc && ($rc =~ /members(\s)+(.*)/)) {
my $oldnodes=$2;
my %nodehash=();
if ($oldnodes) {
my @a=split(',', $oldnodes);
foreach (@a) {
$nodehash{$_}=1;
}
}
foreach my $node (@mon_nodes) {
if (!exists($nodehash{$node})) {
$nodehash{$node}=1;
}
}
my $newnodes=join(',', keys(%nodehash));
if ($newnodes) {
`sed -i 's/members.*\$/members $newnodes/' $cn_cfg`;
}
}
#define services for the new hosts
#print "defining services in $cn_cfg\n";
my $rc=`grep "service_description" $cn_cfg`;
if (!$rc || ($rc !~ /(\s)*service_description(\s)+SSH/)) {
`echo "define service{\n use generic-service
hostgroups cn_$sv
service_description SSH
check_command check_ssh
active_checks_enabled 0
passive_checks_enabled 1
}
" >> $cn_cfg`;
}
if (!$rc || ($rc !~ /(\s)*service_description(\s)+FTP/)) {
`echo "define service{\n use generic-service
hostgroups cn_$sv
service_description FTP
check_command check_ssh
active_checks_enabled 0
passive_checks_enabled 1
}
" >> $cn_cfg`;
}
if (!$rc || ($rc !~ /(\s)*service_description(\s)+Load(\s)*/)) {
`echo "define service{\n use generic-service
hostgroups cn_$sv
service_description Load
check_command check_ssh
active_checks_enabled 0
passive_checks_enabled 1
}
" >> $cn_cfg`;
}
if (!$rc || ($rc !~ /(\s)*service_description(\s)+Processes(\s)*/)) {
`echo "define service{\n use generic-service
hostgroups cn_$sv
service_description Processes
check_command check_ssh
active_checks_enabled 0
passive_checks_enabled 1
}
" >> $cn_cfg`;
}
#add cfg_file=/etc/nagios/objects/cn_$sv.cfg to nagios.cfg file
#print "adding $cn_cfg to $nagios_cfg file.\n";
my $rc=`grep "cn_$sv.cfg" $nagios_cfg`;
if (!$rc || ($rc !~ /^cfg_file=(.*)\/cn_$sv.cfg/)) {
`echo "\#BEGIN xCAT configiration file cn_$sv
cfg_file=/etc/nagios/objects/cn_$sv.cfg
\#END xCAT configiration file cn_$sv
" >> $nagios_cfg`;
}
#print "adding $cn_template_cfg to $nagios_cfg file.\n";
my $rc=`grep "cn_template.cfg" $nagios_cfg`;
if (!$rc || ($rc !~ /^cfg_file=(.*)\/cn_template.cfg/)) {
`echo "\#BEGIN xCAT configiration file for grandchildren template
cfg_file=$cn_template_cfg
\#END xCAT configiration file for grandchildren template
" >> $nagios_cfg`;
}
}
return (0, "ok");
}
#--------------------------------------------------------------------------------
=head3 removeGrandNodes
This function removes the grand children nodes from the nagios cluster.
Arguments:
grands -- pointer to a hash. key: "servicenode, xcatmaster" for the nodes,
value: an array pointer to the nodes.
master -- the monitoring master of the node.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means localhost and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub removeGrandNodes {
my $grands=shift;
if ($grands =~ /xCAT_monitoring::nagiosmon/) {
$grands=shift;
}
my $scope=shift;
my $callback=shift;
print "nagiosmon.removeGrandNodes\n";
my @hostinfo=xCAT::NetworkUtils->determinehostname();
my %iphash=();
foreach(@hostinfo) {$iphash{$_}=1;}
my $localhostname=hostname();
my $nagios_cfg="/etc/nagios/nagios.cfg";
foreach my $sv_pair (keys(%$grands)) {
my @server_pair=split(',', $sv_pair);
my $sv=$server_pair[0];
my $sv1;
if (@server_pair>1) {
$sv1=$server_pair[1];
}
my $pnodes=$grands->{$sv_pair};
my @mon_nodes;
if ($pnodes) {
@mon_nodes=@$pnodes;
}
my $cn_cfg="/etc/nagios/objects/cn_$sv.cfg";
if (-f $cn_cfg) {
#remove hosts from the hostgroup
my $rc=`grep "hostgroup_name" $cn_cfg`;
if ($rc && ($rc =~ /^(\s)*hostgroup_name(\s)+cn_$sv/)) {
$rc=`grep "members" $cn_cfg`;
if ($rc && ($rc =~ /members(\s)+(.*)/)) {
my $oldnodes=$2;
my %nodehash=();
if ($oldnodes) {
my @a=split(',', $oldnodes);
foreach (@a) {
$nodehash{$_}=1;
}
}
foreach my $node (@mon_nodes) {
if (exists($nodehash{$node})) {
delete($nodehash{$node});
}
}
my $newnodes=join(',', keys(%nodehash));
if ($newnodes) {
`sed -i 's/members.*\$/members $newnodes/' $cn_cfg`;
#remove the hosts from cn cfg
foreach my $node (@mon_nodes) {
my $rc=`grep host_name $cn_cfg |grep $node`;
if (($rc) && ($rc =~ /host_name(\s)+$node(\s)*$/)) {
#if found, remove it
`sed -i "/#BEGIN HOST $node/,/#END HOST $node/ d" $cn_cfg`
}
}
} else {
unlink($cn_cfg);
my $rc=`grep "$cn_cfg" $nagios_cfg`;
if ($rc || ($rc =~ /^cfg_file=(.*)\/cn_$sv.cfg/)) {
`sed -i "/#BEGIN xCAT configiration file cn_$sv/,/#END xCAT configiration file cn_$sv/ d" $nagios_cfg`;
}
}
}
}
}
}
return (0, "ok");
}
#--------------------------------------------------------------------------------
=head3 deconfig
This function de-configures the cluster for the given nodes.
This function is called when mondecfg command is issued by the user.
It should remove the given nodes from the product for monitoring.
Arguments:
p_nodes -- a pointer to an arrays of nodes to be removed for monitoring. none means all.
scope -- the action scope, it indicates the node type the action will take place.
0 means local host only.
2 means both local host and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub deconfig {
print "nagiosmon:deconfig called\n";
my $noderef=shift;
if ($noderef =~ /xCAT_monitoring::nagiosmon/) {
$noderef=shift;
}
my $scope=shift;
my $callback=shift;
my $grands=shift;
my $localhostname=hostname();
#the identification of this node
my @hostinfo=xCAT::NetworkUtils->determinehostname();
my $isSN=xCAT::Utils->isServiceNode();
my %iphash=();
foreach(@hostinfo) {$iphash{$_}=1;}
if (!$isSN) { $iphash{'noservicenode'}=1;}
#removinging children nodes
if (($noderef) && (@$noderef > 0)) {
my $pPairHash=xCAT_monitoring::monitorctrl->getMonServer($noderef);
if (ref($pPairHash) eq 'ARRAY') {
reportError($pPairHash->[1], $callback);
return (0, "");
}
#print "noderef=" . Dumper($noderef);
#print "iphash=" . Dumper(%iphash);
#print "pPairHash=" . Dumper($pPairHash);
foreach my $key (keys (%$pPairHash)) {
my @key_a=split(':', $key);
if (! $iphash{$key_a[0]}) { next;}
my $mon_nodes=$pPairHash->{$key};
my $master=$key_a[1];
#figure out what nodes to remove
my @nodes_to_rm=();
if ($mon_nodes) {
foreach(@$mon_nodes) {
my $node=$_->[0];
my $nodetype=$_->[1];
if ($nodetype){
if ($nodetype =~ /$::NODETYPE_OSI/) { push(@nodes_to_rm, $node); }
}
}
}
#print "nodes to rme=@nodes_to_rm\n";
#remove new nodes to the Nagios cluster
if (@nodes_to_rm> 0) {
my @ret=removeNodes(\@nodes_to_rm, $master, $scope, $callback, 0);
if ((@ret > 0) && ($ret[0] != 0)) { return @ret;}
}
}
}
#for grand childdren
if ((!$isSN) && ($grands) && (keys(%$grands) > 0)) {
my @ret=removeGrandNodes($grands, $scope, $callback, 0);
if ((@ret > 0) && ($ret[0] != 0)) { return @ret;}
}
return (0, "deconfigured");
}
#--------------------------------------------------------------------------------
=head3 supportNodeStatusMon
This function is called by the monitorctrl module to check
if Nagios can help monitoring and returning the node status.
Arguments:
none
Returns:
1
=cut
#--------------------------------------------------------------------------------
sub supportNodeStatusMon {
print "nagiosmon::supportNodeStatusMon called\n";
return 0;
}
#--------------------------------------------------------------------------------
=head3 startNodeStatusMon
This function is called by the monitorctrl module to tell
Nagios to start monitoring the node status and feed them back
to xCAT. Nagios will start setting up the notification
to monitor the node status changes.
Arguments:
p_nodes -- a pointer to an arrays of nodes for monitoring. none means all.
scope -- the action scope, it indicates the node type the action will take place.
0 means local host only.
2 means both local host and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub startNodeStatusMon {
print "nagiosmon::startNodeStatusMon\n";
my $noderef=shift;
if ($noderef =~ /xCAT_monitoring::nagiosmon/) {
$noderef=shift;
}
my $scope=shift;
my $callback=shift;
my $localhostname=hostname();
my $retcode=0;
my $retmsg="";
my $isSN=xCAT::Utils->isServiceNode();
#get all the nodes status from IBM.MngNode class of local host and
#the identification of this node
my $pPairHash=xCAT_monitoring::monitorctrl->getMonServer($noderef);
if (ref($pPairHash) eq 'ARRAY') {
reportError($pPairHash->[1], $callback);
return (1, "");
}
my @hostinfo=xCAT::NetworkUtils->determinehostname();
my %iphash=();
foreach(@hostinfo) {$iphash{$_}=1;}
if (!$isSN) { $iphash{'noservicenode'}=1;}
return ($retcode, $retmsg);
}
#--------------------------------------------------------------------------------
=head3 stopNodeStatusMon
This function is called by the monitorctrl module to tell
Nagios to stop feeding the node status info back to xCAT. It will
stop the notification that is monitoring the node status.
Arguments:
p_nodes -- a pointer to an arrays of nodes for monitoring. none means all.
scope -- the action scope, it indicates the node type the action will take place.
0 means local host only.
2 means both local host and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(return code, message)
=cut
#--------------------------------------------------------------------------------
sub stopNodeStatusMon {
print "nagiosmon::stopNodeStatusMon called\n";
my $noderef=shift;
if ($noderef =~ /xCAT_monitoring::nagiosmon/) {
$noderef=shift;
}
my $scope=shift;
my $callback=shift;
my $retcode=0;
my $retmsg="";
my $isSN=xCAT::Utils->isServiceNode();
my $localhostname=hostname();
return ($retcode, $retmsg);
}
#--------------------------------------------------------------------------------
=head3 reportError
This function writes the error message to the callback, otherwise to syslog.
Arguments:
error
callback
Returns:
none
=cut
#--------------------------------------------------------------------------------
sub reportError
{
my $error=shift;
my $callback=shift;
if ($callback) {
my $rsp={};
$rsp->{data}->[0]=$error;
$callback->($rsp);
} else { xCAT::MsgUtils->message('S', "[mon]: $error\n"); }
return;
}
#--------------------------------------------------------------------------------
=head3 processSettingChanges
This function gets called when the setting for this monitoring plugin
has been changed in the monsetting table.
Arguments:
none.
Returns:
0 for successful.
non-0 for not successful.
=cut
#--------------------------------------------------------------------------------
sub processSettingChanges {
}
#--------------------------------------------------------------------------------
=head3 getDiscription
This function returns the detailed description of the plugin inluding the
valid values for its settings in the monsetting tabel.
Arguments:
none
Returns:
The description.
=cut
#--------------------------------------------------------------------------------
sub getDescription {
return
" Description:
nagiosmon is a monitoring plug-in for Nagios to monitor xCAT cluster. It defines hosts, host groups and services in the Nagios configuration files. The xCAT nodes and services will to be monitored by Nagios with its NRPE and NSCA add-ons. The following sequence of commands will do the configuration and monitoring.
monadd nagiosmon
moncfg nagiosmon service -r
moncfg nagiosmon compute -r
monstart nagiosmon service -r
monstart nagiosmon compute -r
where 'service' is the node group name for the service node, 'compute' is the node group name for the compute node.
";
}
#--------------------------------------------------------------------------------
=head3 getPostscripts
This function returns the postscripts needed for the nodes and for the servicd
nodes.
Arguments:
none
Returns:
The the postscripts. It a pointer to an array with the node group names as the keys
and the comma separated poscript names as the value. For example:
{service=>"cmd1,cmd2", xcatdefaults=>"cmd3,cmd4"} where xcatdefults is a group
of all nodes including the service nodes.
=cut
#--------------------------------------------------------------------------------
sub getPostscripts {
my $ret={};
$ret->{xcatdefaults}="confNagios";
return $ret;
}
#--------------------------------------------------------------------------------
=head3 show
This function shows the monitoring status.
This function is called when monshow command is issued.
Arguments:
p_nodes -- a pointer to an arrays of nodes to be added for monitoring. none means all.
scope -- the action scope, it indicates the node type the action will take place.
0 means localhost only.
2 means localhost and nodes,
callback -- the callback pointer for error and status displaying. It can be null.
Returns:
(error code, error message)
=cut
#--------------------------------------------------------------------------------
sub show
{
print "nagiosmon:show called\n";
no strict 'refs';
my ($noderef, $sum, $time, $attrs, $pe, $where,$callback) = @_;
return (0, "");
}
#--------------------------------------------------------------------------
=head3 handleGrandChildren
This function tells if the mn shall handle the nodes that are managed by the service nodes.
=cut
#---------------------------------------------------------------------------
sub handleGrandChildren {
return 1;
}