Fence na.lib - Revision history

Digimer at 17:02, 25 August 2010

2010-08-25T17:02:32Z

← Older revision		Revision as of 17:02, 25 August 2010
Line 14:		Line 14:
	# Version: 1.1.5		# Version: 1.1.5
	#		#
			# This software is released under the GPL v2. See the LICENSE file for a copy
			# of the GPL v2.

Digimer at 15:36, 18 July 2010

2010-07-18T15:36:39Z

← Older revision		Revision as of 15:36, 18 July 2010
Line 11:		Line 11:
	# Node Assassin - Fence Agent		# Node Assassin - Fence Agent
	# Digimer; digimer@alteeve.com		# Digimer; digimer@alteeve.com
	# ~~Apr~~. 08, 2010.		# Jun. 27, 2010.
	# Version: 1.1.4		# Version: 1.1.5
	#		#

Line 51:		Line 51:

	# Process the orders.		# Process the orders.
			print "Processing: [$conf->{'system'}{call_order}]\n";
	foreach my $order (split/,/, $conf->{'system'}{call_order})		foreach my $order (split/,/, $conf->{'system'}{call_order})
	{		{
Line 330:		Line 331:
	# Fence all ports.		# Fence all ports.
	$conf->{'system'}{call_order}="fence_all";		$conf->{'system'}{call_order}="fence_all";
			}
			elsif ($action eq "boot")
			{
			# Boot the specific node if it is off.
			$states=get_states($conf, $log);

			# Decide how, or if, to proceed based on the current state of
			# each node.
			$node=sprintf("%02d", $node);
			my $power_state=$states->{$node}{power_state};
			my $reset_state=$states->{$node}{reset_state};
			my $feed_state=$states->{$node}{feed_state};
			if (($power_state) \|\| ($reset_state))
			{
			# Node was fenced, release first.
			$conf->{'system'}{call_order}.="$node:0,sleep,";
			}
			if (not $feed_state)
			{
			# Boot the node.
			$conf->{'system'}{call_order}.="$node:2,sleep,";
			}
			else
			{
			record($conf, $log, "WARNING: Node: [$node] seems to be already on, taking no action.\n", 1);
			}
			$conf->{'system'}{call_order}=~s/,$//;
	}		}
	elsif ($action eq "boot_all")		elsif ($action eq "boot_all")
Line 354:		Line 382:
	$conf->{'system'}{call_order}.="$node:2,sleep,";		$conf->{'system'}{call_order}.="$node:2,sleep,";
	}		}
			}
			$conf->{'system'}{call_order}=~s/,$//;
			}
			elsif ($action eq "shutdown")
			{
			# Shutdown a specific node that is on cleanly via ACPI.
			$states=get_states($conf, $log);
			$node=sprintf("%02d", $node);
			my $feed_state=$states->{$node}{feed_state};
			if ($feed_state)
			{
			# shutdown the node.
			$conf->{'system'}{call_order}.="$node:2";
			}
			else
			{
			record($conf, $log, "WARNING: Node: [$node] seems to be already off, taking no action. Is the cable connected?\n", 1);
	}		}
	$conf->{'system'}{call_order}=~s/,$//;		$conf->{'system'}{call_order}=~s/,$//;
Line 372:		Line 417:
	if ($feed_state)		if ($feed_state)
	{		{
	# ~~Boot~~ the node.		# Shutdown the node.
	$conf->{'system'}{call_order}.="$node:2,sleep,";		$conf->{'system'}{call_order}.="$node:2,sleep,";
	}		}
Line 484:		Line 529:
	# Suppress all non-critical messages from STDOUT.		# Suppress all non-critical messages from STDOUT.
	$conf->{'system'}{quiet}=1;		$conf->{'system'}{quiet}=1;
			}
			elsif ($arg=~/-d/)
			{
			# Enable debug mode.
			$conf->{'system'}{debug}=1;
	}		}
	elsif ($arg=~/^-/)		elsif ($arg=~/^-/)
Line 539:		Line 589:
	# Bad argument.		# Bad argument.
	record($conf, $log, "\nERROR: Argument: [$arg] is not valid!\n");		record($conf, $log, "\nERROR: Argument: [$arg] is not valid!\n");
	record($conf, $log, "ERROR: Please run ~~'./~~fence_na ~~--help'~~ to see a list of valid arguments.\n\n");		record($conf, $log, "ERROR: Please run: [man fence_na] to see a list of valid arguments.\n\n");
	$bad=1;		$bad=1;
	}		}
Line 660:		Line 710:
	# This sets the port number to act on.		# This sets the port number to act on.
	$conf->{na}{port}=$value;		$conf->{na}{port}=$value;
	}		}
			elsif ($name eq "nodename")
			{
			# This is passed by 'fenced' via 'cluster.conf' as of
			# cluster version 3, but it's not yet documented.
			$conf->{'system'}{nodename}=$value;
			}
	elsif ($name eq "quiet")		elsif ($name eq "quiet")
	{		{
Line 666:		Line 722:
	# custom argument to supress output to STDOUT.		# custom argument to supress output to STDOUT.
	$conf->{'system'}{quiet}=1;		$conf->{'system'}{quiet}=1;
	}		}
	else		else
	{		{
	record($conf, $log, "\nERROR: Illegal name in option: [$option] at line: [$line_count]\n\n", 1);		record($conf, $log, "\nERROR: Illegal name in option: [$option] at line: [$line_count]\n\n", 1);
	$bad=1;		# 'rohara' from #linux-cluster suggested it's better to
			# simply ignore unknown input, as that is the behaviour
			# the fenced authors expect.
			#$bad=1;
	}		}
	}		}

Digimer at 14:17, 16 April 2010

2010-04-16T14:17:21Z

Show changes

Digimer at 05:30, 7 April 2010

2010-04-07T05:30:27Z

Show changes

Digimer at 19:53, 8 March 2010

2010-03-08T19:53:59Z

Show changes

Digimer at 06:26, 8 March 2010

2010-03-08T06:26:11Z

Show changes

Digimer: Created page with '{{na_header}} '''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 /et…'

2010-03-05T06:43:36Z

Created page with '{{na_header}} '''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 <span class="code">/et…'

Páàjì titun

{{na_header}}

'''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 <span class="code">/etc/na/</span>.

<source lang="perl">
#!/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;
</source>

{{na_footer}}