Fence na.lib

Node Assassin :: Fence na.lib

NOTE: The comments in this file need to be update, please don't trust them.

This is the fence agent's function library that exists in /etc/na/.

#!/usr/bin/perl
#
# This is the function library for the Node Assassin fence agent.
# 
# Node Assassin - Fence Agent
# Digimer; digimer@alteeve.com
# Mar. 05, 2010.
# Version: 0.1.003
#


# This cleanly exits the agent.
sub do_exit
{
	($conf, $log, $exit_status)=@_;
	$exit_status=9 if not defined $exit_status;
	
	$conf->{node}{handle}->close;
	$log->close();
	exit ($exit_status);
}

# This returns the 'help' message.
sub help
{
	my ($conf, $log)=@_;
	my $msg=q`
NOTE: This is now out of date!
	
Node Assassin Fencing Agent

	This program interfaces with the Node Assassin to set one or more nodes
	to one or more states.

Usage:

	./fence_na <options>

Overview:

	This takes one or more arguments relating to the desired state to set a
	node to follow by one or more Node IDs to act on. Multiple states can
	be set at the same time.

	When specifying a single node, pass a single ID (not zero-padded).

	When specifying two or more nodes, seperate them with a comma with no
	spaces.

States:

	0
		This state will fence the nodes specified by the list.
	
	1
		This will release the fence and allow the specified node(s) to
		boot.
	
	2
		This will fence the node(s) for one second. This is meant to be
		used on ports connected to a node's power button. If the node
		is alive and supports ACPI, this should start a graceful power
		down of the node. Conversly, if the node was off, this will
		boot the node. When connected to a node's reset switch, this
		will cause a quick reboot without a graceful power off.
	
	3
		This state will fence the node(s) for five seconds. This is
		specifically designed for ports connected to a node's power
		button. It will allow a frozen node to be forced off by holding
		the power button closed long enough to force a power off. This
		state serves no real difference over state 2 when connected to
		a reset switch.

Options:

	In all cases, '--set_state_X=<list>' and '-X <list>' are equal and
	interchangable. The examples below will use the long-form arguments for
	the sake of clarity.
	
	--set_state_0=<list>
	
		This sets the specified port(s) state 0.
	
	--set_state_1=<list>
	
		This sets the specified port(s) state 0.

	--set_state_2=<list>
	
		This sets the specified port(s) state 2.
	
	--set_state_2=<list>
	
		This sets the specified port(s) state 2.

Examples:

	Fence node 1.
	
		./fence_na --set_state_0=1
	
	Release the fence on node 1.
	
		./fence_na --set_state_1=1
	
	Boot nodes 1 and 2
	
		./fence_na --set_state_2=1,2
	
	Force node 2 to power off.
	
		./fence_na --set_state_3=2
	
	Fence nodes 4 and 5 then boot node 6
	
		./fence_na --set_state_0=4,5 --set_state_2=6
		
Note:

	An internal pager is not implemented. You may wish to run this via
	'less':
	
	./fence_na | less

NOTE: This is now out of date!
`;
	print $msg;
	
	do_exit($conf, $log, 0);
}

# This handles the actual actions.
sub process_action
{
	my ($conf, $log)=@_;
	
	# Make this more readable.
	my $na_id=$conf->{'system'}{node_assassin_id};
	my $action=$conf->{node}{action};
	my $port=$conf->{node}{port};
	
	# Translate the port passed in by the fence agent into the actual ports
	# in the Node Assassin. Mapping is:
	# Node 01 -> Power = Port 01
	# Node 01 -> Reset = Port 02
	# Node 02 -> Power = Port 03
	# Node 02 -> Reset = Port 04
	# Node 03 -> Power = Port 05
	# Node 03 -> Reset = Port 06
	# Node 04 -> Power = Port 07
	# Node 04 -> Reset = Port 08
	# ...
	my $power_port=sprintf("%02d", (($port*2)-1));
	my $reset_port=sprintf("%02d", ($port*2));
	record($conf, $log, "Translated node port: [$port] to power port: [$power_port] and reset port: [$reset_port]\n");
	
	if ($action eq "on")
	{
		# Release the fence and boot the node.
		$conf->{'system'}{call_order}="$reset_port:1,$power_port:1,sleep,$power_port:2";
	}
	elsif ($action eq "off")
	{
		# Fence the node by pressing and holding the reset to make sure
		# the node immediately dies. Then I release the fence long
		# enough to force a power off, then I re-apply then fence to
		# make sure the node doesn't come back up. This is needed
		# because some machines won't power off if the reset is held
		# high when the power is pressed, even for > 4 seconds.
		$conf->{'system'}{call_order}="$reset_port:0,sleep,$reset_port:1,sleep,$power_port:0,sleep 5,$reset_port:0";
	}
	elsif ($action eq "reboot")
	{
		# Currently, I don't do this gracefully because, well, if it's
		# being fenced, it's not meant to be graceful.
		# This is a combination of the 'off' -> 'on' actions.
		$conf->{'system'}{call_order}="$reset_port:0,sleep,$reset_port:1,sleep,$power_port:0,sleep 5,$reset_port:0";
		$conf->{'system'}{call_order}.=",$reset_port:1,$power_port:1,sleep,$power_port:2";
	}
	elsif ($action eq "status")
	{
		# This should check the probe, but for now, it checks the
		# port's state.
	}
	elsif (($action eq "monitor") or ($action eq "list"))
	{
		# Not sure what to do here.
	}
	else
	{
		record($conf, $log, "Unknown action request: [$action]!\n");
		do_exit($conf, $log, 9);
	}
}

# Read in the config file.
sub read_conf
{
	my ($conf)=@_;
	$conf={} if not $conf;
	
	# I can't call the 'record' method here because I've not read in the
	# log file and thus don't know where to write the log to yet. Comment
	# out or delete 'print' statements before release.
	my $read=IO::Handle->new();
	my $shell_call="$conf->{'system'}{conf_file}";
# 	print "Shell call: [$shell_call]\n";
	open ($read, "<$shell_call") or die "Failed to read: [$shell_call], error was: $!\n";
	while (<$read>)
	{
		chomp;
		my $line=$_;
		next if not $line;
		next if $line !~ /=/;
		$line=~s/^\s+//;
		$line=~s/\s+$//;
		next if $line =~ /^#/;
		next if not $line;
		my ($var, $val)=(split/=/, $line, 2);
		$var=~s/^\s+//;
		$var=~s/\s+$//;
		$val=~s/^\s+//;
		$val=~s/\s+$//;
		next if (not $var);
# 		print "Storing: [$var] = [$val]\n";
		_make_hash_reference($conf, $var, $val);
	}
	$read->close();
	
	return (0);
}

# Read in command line arguments
sub read_cla
{
	my ($conf, $log, $bad)=@_;
	
	# MADI: Remove this before release.
	record($conf, $log, "Got args:\n");
	
	# Loop through the passed arguments, if any.
	my $set_next="";
	foreach my $arg (@ARGV)
	{
		# MADI: Remove this before release.
		record($conf, $log, "[$arg]\n");
		
		# If 'set_next' has a value, push this argument into the 'conf'
		# hash.
		if ($set_next)
		{
			# It's set, use it's contents as the hash key.
			$conf->{node}{$set_next}=$arg;
			
			# MADI: Remove this before release.
			record($conf, $log, "Setting: 'node::$set_next': [$conf->{node}{$set_next}]\n");
			
			# Clear it now for the next go-round.
			$set_next="";
			next;
		}
		if ($arg=~/-h/)
		{
			# Print the help message and then exit.
			help($conf, $log);
		}
		elsif ($arg=~/-[vV]/)
		{
			# Print the version information and then exit.
			$conf->{'system'}{version}=1;
		}
		elsif ($arg=~/-q/)
		{
			# Suppress all non-critical messages from STDOUT.
			$conf->{'system'}{quiet}=1;
		}
		elsif ($arg=~/^-/)
		{
			$arg=~s/^-//;
			
			### These are the switches set by Red Hat.
			if ($set_next eq "a")
			{
				# This is the IP address or hostname of the
				# Node Assassin to call.
				$set_next="ipaddr";
			}
			elsif ($set_next eq "l")
			{
				# This is the login name.
				$set_next="login";
			}
			elsif ($set_next eq "p")
			{
				# This is the password. If it starts with '/'
				# it is interpreted to be a file containing the
				# password which will be read in and it's
				# contents will replace# this value.
				$set_next="passwd";
			}
			elsif ($set_next eq "n")
			{
				# This is the node to work on.
				$set_next="port";
			}
			elsif ($set_next eq "o")
			{
				# This is the action to take. Valid actions
				# are:
				# on      = ##:1		# Release fence
				# off     = ##:0		# Fence
				# reboot  = ##:3 -> ##:2	# Force off then boot.
				# status  = Returns the node's current status.
				# monitor = Returns the status of all nodes.
				$set_next="action";
			}
			elsif ($set_next eq "S")
			{
				# This is the script to run to retrieve the
				# password when it is not stored in
				# 'cluster.conf'. This script should echo/print
				# the password to STDOUT.
				$set_next="passwd_script";
			}
		}
		else
		{
			### MADI: I might want to pick up arguments via multiple lines.
			# Bad argument.
			record($conf, $log, "Argument: [$arg] is not valid!\n");
			record($conf, $log, "Please run './fence_na --help' to see a list of valid arguments.\n");
			$bad=1;
		}
	}
}

# Read arguments from STDIN. This is adapted from the 'fence_brocade' agent.
sub read_stdin
{
	my ($conf, $log, $bad)=@_;
	
	my $option;
	my $line_count=0;
	while(defined (my $option=<>))
	{
		# Get rid of newlines.
		chomp $option;
		
		# Record the line for now, but comment this out before release.
		record ($conf, $log, "Processing option line: [$option]\n");
		
		# strip leading and trailing whitespace
		$option=~s/^\s*//;
		$option=~s/\s*$//;
		
		# skip comments
		next if ($option=~ /^#/);
		
		# Increment my option line count.
		$line_count++;
		
		# Go to the next line if the option line is empty.
		next if not $option;
		
		# Split the option up into the name and the value.
		($name,$value)=split /\s*=\s*/, $option;
		
		# Record the line for now, but comment this out before release.
		record ($conf, $log, "Name: [$name], value: [$value].\n");
		
		# Set my variables depending on the veriable name.
		if ($name eq "agent")
		{
			# This is only used by 'fenced', but I record it for
			# potential debugging.
			$conf->{node}{agent}=$value;
		}
		elsif ($name eq "fm")
		{
			# This is a deprecated argument that should no longer
			# be used. Now 'port' should be used.
			if (not $conf->{node}{port})
			{
				# Port isn't set yet, use this value which may
				# be replaced if 'port' is set later.
				(undef, $value) = split /\s+/,$value;
				$conf->{node}{port}=$value;
				warn "Warning! The argument 'fm' is deprecated, use 'port' instead. Value: [$value] set for 'port'\n";
			}
			else
			{
				# Port was already set, so simply ignore this.
				warn "Warning! The argument 'fm' is deprecated, use 'port' instead. Value: [$value] ignored.\n";
			}
		}
		elsif ($name eq "ipaddr") 
		{
			# Record the IP Address or name of the Node Assassin to
			# use.
			$conf->{node}{ipaddr}=$value;
		} 
		elsif ($name eq "login")
		{
			# Record the login name that was passed.
			$conf->{node}{login}=$value;
		} 
		elsif ($name eq "name")
		{
			# Depricated argument used formerly for login name.
			if (not $conf->{node}{login})
			{
				# Login isn't set yet, use this value which may
				# be replaced if 'login' is seen later.
				$conf->{node}{login}=$value;
				warn "Warning! The argument 'name' is deprecated, use 'login' instead. Value: [$value] set for 'login'.\n";
			}
			else
			{
				# I've already seen the 'login' value so I will
				# ignore this value.
				warn "Warning! The argument 'name' is deprecated, use 'login' instead. Value: [$value] ignored.\n";
			}
		}
		elsif (($name eq "action") or ($name eq "option"))
		{
			# It looks like 'option' is going to be deprecated in
			# favour of 'action'. If/when that happens, add a warn.
			$conf->{node}{action}=$value;
		}
		elsif ($name eq "passwd")
		{
			# This is the login password.
			$conf->{node}{passwd}=$value;
		} 
		elsif ($name eq "passwd_script")
		{
			# This is the path to the script that will return the
			# password to the agent. At this time, this is not
			# implemented.
			$conf->{node}{passwd_script}=$value;
		}
		elsif ($name eq "port")
		{
			# This sets the port number to act on.
			$conf->{node}{port}=$value;
		} 
		else
		{
			warn "Illegal name in option: [$option] at line: [$line_count]\n";
			$bad=1;
		}
	}
	return ($bad);
}

# This function simply prints messages to both the log and to stdout.
sub record
{
	my ($conf, $log, $msg)=@_;
	
	print $log $msg;
	print $msg if not $conf->{'system'}{quiet};
	
	return(0);
}

# When asked to 'monitor' or 'list', do this... whatever 'this' is. All I know
# is that it should not generate output.
sub show_list
{
	my ($conf, $log)=@_;
	
	### MADI: No idea what will be needed here, so here are both queries.
	###       Make them available elsewhere if not used here.
	record($conf, $log, "Checking states:\n");
	my @state_out=$conf->{node}{handle}->cmd("00:0");
	foreach my $line (@state_out)
	{
# 		record($conf, $log, $line);
	}
	record($conf, $log, "Done.\n");

	# Query states and Node Assassin info.
	record($conf, $log, "Checking Node Assassin info:\n");
	my @info_out=$conf->{node}{handle}->cmd("00:1");
	my $node_name="";
	foreach my $line (@info_out)
	{
		record($conf, $log, $line);
		$node_name=$1 if $line=~/- Node Name: ..... (.*)/;
	}
	record($conf, $log, "Node name: [$node_name]\n");
	record($conf, $log, "Done.\n");
	
	do_exit($conf, $log, 0);
}

# This queries the Node Assassin and returns the state of the requested node.
sub show_state
{
	my ($conf, $log)=@_;
	
	my @state_out=$conf->{node}{handle}->cmd("00:0");
	my $state="";
	my $node=$conf->{node}{port};
	foreach my $line (@state_out)
	{
		chomp;
		my $line=$_;
		my ($state)=($line=~/- Node $node: (.*?)/);
		if ($state)
		{
			$state=lc($state)=~/fenced/ ? 2 : 0;
			last;
		}
	}
	# No state means something went wrong while talking to the Node
	# Assassin.
	$state=1 if (($state != 0) && ($state != 2));
	
	# As per: http://sources.redhat.com/cluster/wiki/FenceAgentAPI
	# The exit state must be:
	# 0 = Node is running
	# 1 = Failed to contact fence, unknown state.
	# 2 = Node is fenced.
	do_exit($conf, $log, $state);
}

# This prints the version information of this fence agent and of any configured
# fence devices.
sub version
{
	my ($conf, $log)=@_;
	
	# Print the Fence Agent version first.
	print "Fence Agent: ......... Node Assassin ver. $conf->{'system'}{agent_version}\n";
	print "Configured Nodes: .... $conf->{'system'}{nodes}\n";
	for my $node (1..$conf->{'system'}{nodes})
	{
		print " - Node $node Name: .. $conf->{node}{$node}{name}\n";
		print " - Node $node IP: .... $conf->{node}{$node}{ip}\n";
		print " - Node $node Port: .. $conf->{node}{$node}{port}\n";
		print " - Node $node MAC: ... $conf->{node}{$node}{mac}\n";
		print " - Node $node Netmask: $conf->{node}{$node}{ip}\n";
		print " - Node $node Gateway: $conf->{node}{$node}{ip}\n";
	}
	do_exit($conf, $log, 0);
}


###############################################################################
# Private functions below here.                                               #
###############################################################################

### Contributed by Shaun Fryer and Viktor Pavlenko by way of TPM.
# This is a helper to the above '_add_href' method. It is called each time a
# new string is to be created as a new hash key in the passed hash reference.
sub _add_hash_reference
{
	my $href1=shift;
	my $href2=shift;
	
	for my $key (keys %$href2)
	{
		if (ref $href1->{$key} eq 'HASH')
		{
			_add_hash_reference($href1->{$key}, $href2->{$key});
		}
		else
		{
			$href1->{$key}=$href2->{$key};
		}
	}
}

### Contributed by Shaun Fryer and Viktor Pavlenko by way of TPM.
# This takes a string with double-colon seperators and divides on those
# double-colons to create a hash reference where each element is a hash key.
sub _make_hash_reference
{
	my $href=shift;
	my $key_string=shift;
	my $value=shift;
# 	print "variable: [$key_string], value: [$value]\n";
	
	my $chomp_root=0;
	if ($chomp_root) { $key_string=~s/\w+:://; }
	
	my @keys = split /::/, $key_string;
	my $last_key = pop @keys;
	my $_href = {};
	$_href->{$last_key}=$value;
	while (my $key = pop @keys)
	{
		my $elem = {};
		$elem->{$key} = $_href;
		$_href = $elem;
	}
	_add_hash_reference($href, $_href);
}

1;

 

Input, advice, complaints and meanderings all welcome!
Digimer	digimer@alteeve.ca	https://alteeve.ca/w	legal stuff:
All info is provided "As-Is". Do not use anything here unless you are willing and able to take resposibility for your own actions. © 1997-2013
Naming credits go to Christopher Olah!
In memory of Kettle, Tonia, Josh, Leah and Harvey. In special memory of Hannah, Jack and Riley.