2
0
mirror of https://github.com/xcat2/xcat-core.git synced 2026-11-21 01:42:15 +00:00
Files
xcat-core/xCAT-server/lib/xcat/plugins/seqdiscovery.pm
T
Daniel Hilst 0373cd6568 fix(xcat-core): discovery cannot resolve an IPv6 findme and never calls an IPv6 node back
A node that sends its findme request over IPv6 is never discovered. Two
steps fail.

seqdiscovery.pm reads the arp(8) table to turn the client address into a MAC
and looks that MAC up in the mac table. arp(8) prints the IPv4 table only, so
the table holds no row for the client and the plugin logs "Could not find mac
of the <address>" and returns. aaadiscovery.pm, profilednodes.pm, blade.pm and
hpblade.pm carry the same parse. All five interpolate the address into a
regular expression as well, so a dot matches any character and 192.168.201.1
matches the row of 192.168.201.120.

nodediscover.pm then opens a TCP connection to the node to send "restart",
and NetworkUtils::send_tcp_msg does the same for its callers. Both build the
socket with IO::Socket::INET, which has no AF_INET6, so the node receives
nothing and Genesis exits on DISCOVERY_TIMEOUT after 36 attempts.

NetworkUtils gains mac_from_neighbour_table, which takes the text of a
neighbour table and the address and returns the MAC; neighbour_table_text,
which reads arp(8) for IPv4 and "ip -6 neigh show" for IPv6; and
mac_of_neighbour, which joins them. The addresses are compared after both
are normalized, so 2001:db8::2 and its full form are one address. The five
plugins call mac_of_neighbour. open_tcp_socket opens the callback through
IO::Socket::INET6 when it is installed and keeps IO::Socket::INET as the
fallback, the way credentials.pm already does; nodediscover.pm and
send_tcp_msg use it.

networkutils_neighbour_mac.t and networkutils_tcp_callback_family.t fail
without this change.

Signed-off-by: Daniel Hilst <392820+dhilst@users.noreply.github.com>
2026-11-05 09:44:41 -03:00

1682 lines
57 KiB
Perl

#!/usr/bin/env perl
## IBM(c) 20013 EPL license http://www.eclipse.org/legal/epl-v10.html
#
# This plugin is used to handle the sequencial discovery. During the discovery,
# the nodes should be powered on one by one, sequencial discovery plugin will
# discover the nodes one by one and define them to xCAT DB.
# For the new discovered node but NOT handled by xCAT plugin,
# it will be recorded to discoverydata table.
#
package xCAT_plugin::seqdiscovery;
BEGIN
{
$::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
}
use strict;
use Getopt::Long;
use XML::Simple;
$XML::Simple::PREFERRED_PARSER = 'XML::Parser';
use lib "$::XCATROOT/lib/perl";
use xCAT::NodeRange;
use xCAT::Table;
use xCAT::NetworkUtils;
use xCAT::MsgUtils;
use xCAT::Utils;
use xCAT::DiscoveryUtils;
use xCAT::NodeRange qw/noderange/;
require xCAT::data::ibmhwtypes;
use Time::HiRes qw(gettimeofday sleep);
sub handled_commands {
return {
findme => 'seqdiscovery',
nodediscoverstart => 'seqdiscovery',
nodediscoverstop => 'seqdiscovery',
nodediscoverls => 'seqdiscovery',
nodediscoverstatus => 'seqdiscovery',
nodediscoverdef => 'seqdiscovery',
}
}
=head3 findme
Handle the request form node to map and define the request to a node
=cut
sub findme {
my $request = shift;
my $callback = shift;
my $subreq = shift;
my @SEQdiscover = xCAT::TableUtils->get_site_attribute("__SEQDiscover");
my @PCMdiscover = xCAT::TableUtils->get_site_attribute("__PCMDiscover");
my @ZVMDiscover = xCAT::TableUtils->get_site_attribute("__ZVMDiscover");
if (defined($request->{discoverymethod}) and defined($request->{discoverymethod}->[0]) and ($request->{discoverymethod}->[0] ne 'undef')) {
# The findme request had been processed by other module, just return
return;
}
unless ($SEQdiscover[0]) {
return;
}
# Get the parameters for the sequential discovery
my %param;
my @params = split(',', $SEQdiscover[0]);
foreach (@params) {
my ($name, $value) = split('=', $_);
$param{$name} = $value;
}
my $mac;
my $ip = $request->{'_xcat_clientip'};
if (defined $request->{nodetype} and $request->{nodetype}->[0] eq 'virtual') {
xCAT::MsgUtils->message("S", "xcat.discovery.seqdiscovery: ($request->{_xcat_clientmac}->[0]) Error: virtual machines is not supported");
return;
}
# arp(8) prints the IPv4 table only, and the address used to be interpolated
# into a regular expression, where every dot matched any character.
$mac = xCAT::NetworkUtils->mac_of_neighbour($ip);
unless ($mac) {
xCAT::MsgUtils->message("S", "xcat.discovery.seqdiscovery: ($request->{_xcat_clientmac}->[0]) Error: Could not find mac of the $ip");
return;
}
# check whether the mac could map to a node
my $mactab = xCAT::Table->new('mac');
unless ($mactab) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: mac.");
}
my $node;
my @macs = $mactab->getAllAttribs('node', 'mac');
# for each entry: 34:40:b5:be:db:b0!*NOIP*|34:40:b5:be:db:b0!*NOIP*
foreach my $macnode (@macs) {
my @macents = split('\|', $macnode->{'mac'});
foreach my $macent (@macents) {
my ($usedmac) = split('!', $macent);
if ($usedmac =~ /$mac/i) {
$node = $macnode->{'node'};
last;
}
}
}
my @allnodes;
unless ($node) {
# get a free node
@allnodes = getfreenodes($param{'noderange'}, "all");
if (@allnodes) {
$node = $allnodes[0];
}
}
my $bmc_node = undef;
my @bmc_nodes = ();
if ($request->{'mtm'}->[0] and $request->{'serial'}->[0]) {
my $mtms = $request->{'mtm'}->[0] . "*" . $request->{'serial'}->[0];
my $tmp_nodes = $::XCATVPDHASH{$mtms};
foreach (@$tmp_nodes) {
if ($::XCATMPHASH{$_}) {
push @bmc_nodes, $_;
}
}
}
if ($request->{'bmcmac'}->[0]) {
my $bmcmac = lc($request->{'bmcmac'}->[0]);
$bmcmac =~ s/\://g;
my $tmp_node = "node-$bmcmac";
push @bmc_nodes, $tmp_node if ($::XCATMPHASH{$tmp_node});
}
$bmc_node = join(",", @bmc_nodes);
if ($node) {
my $skiphostip;
my $skipbmcip;
my $bmcname;
# check the host ip and bmc
my $hosttab = xCAT::Table->new('hosts');
unless ($hosttab) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: hosts.");
}
my $hostip = getpredefips([$node], "host");
foreach (keys %$hostip) {
if ($hostip->{$_} eq "$node") {
$skiphostip = 1;
}
}
my $ipmitab = xCAT::Table->new('ipmi');
unless ($ipmitab) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: ipmi.");
}
# check the bmc definition in the ipmi table
my $ipmient = $ipmitab->getNodeAttribs($node, ['bmc']);
if (defined($ipmient->{'bmc'})) {
$bmcname = $ipmient->{'bmc'};
if ($bmcname =~ /\d+\.\d+\.\d+\.\d+/) {
$skipbmcip = 1;
} else {
my $bmcip = getpredefips([$node], "bmc");
foreach (keys %$bmcip) {
if ($bmcip->{$_} eq $bmcname) {
$skipbmcip = 1;
}
}
}
}
# set the host ip if the node does not have
unless ($skiphostip) {
my $hostip = getfreeips($param{'hostiprange'}, \@allnodes, "host");
unless ($hostip) {
nodediscoverstop($callback, undef, "host ips");
return;
}
$hosttab->setNodeAttribs($node, { ip => $hostip });
$hosttab->commit();
}
# set the bmc ip if the node does not have
unless ($skipbmcip) {
unless ($bmcname) {
# set the default bmc name
$bmcname = $node . "-bmc";
}
my $bmcip = getfreeips($param{'bmciprange'}, \@allnodes, "bmc");
unless ($bmcip) {
nodediscoverstop($callback, undef, "bmc ips");
return;
}
# for auto created bmc, just add it to hosts.otherinterfaces instead of adding a new bmc node
my $otherif = $hosttab->getNodeAttribs($node, ['otherinterfaces']);
my $updateotherif;
if ($otherif && defined($otherif->{'otherinterfaces'})) {
$updateotherif .= ",$bmcname:$bmcip";
} else {
$updateotherif = "$bmcname:$bmcip";
}
$hosttab->setNodeAttribs($node, { otherinterfaces => $updateotherif });
$hosttab->commit();
# set the bmc to the ipmi table
$ipmitab->setNodeAttribs($node, { bmc => $bmcname });
$ipmitab->commit();
}
# update the host ip pair to /etc/hosts, it's necessary for discovered and makedhcp commands
my @newhosts = ($node, $bmcname);
if (@newhosts) {
my $req;
$req->{command} = ['makehosts'];
$req->{node} = \@newhosts;
$subreq->($req);
# run makedns only when -n flag was specified with nodediscoverstart,
# dns=yes in site.__SEQDiscover
if (defined($param{'dns'}) && ($param{'dns'} eq 'yes'))
{
my $req;
$req->{command} = ['makedns'];
$req->{node} = \@newhosts;
$subreq->($req);
}
}
# set the specific attributes from parameters
my $updateparams;
my %setpos;
if (defined($param{'rack'})) {
$setpos{'rack'} = $param{'rack'};
}
if (defined($param{'chassis'})) {
$setpos{'chassis'} = $param{'chassis'};
}
if (defined($param{'height'})) {
$setpos{'height'} = $param{'height'};
}
if (defined($param{'unit'})) {
$setpos{'u'} = $param{'unit'};
if (defined($param{'height'})) {
$param{'unit'} += $param{'height'};
} else {
$param{'unit'} += 1;
}
$updateparams = 1;
}
if (keys %setpos) {
my $postab = xCAT::Table->new('nodepos');
unless ($postab) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: nodepos.");
}
$postab->setNodeAttribs($node, \%setpos);
$postab->close();
}
if ($updateparams) {
my $textparam;
foreach my $name (keys %param) {
$textparam .= "$name=$param{$name},";
}
$textparam =~ s/,\z//;
# Update the discovery parameters to the site.__SEQDiscover which will be used by nodediscoverls/status/stop and findme,
my $sitetab = xCAT::Table->new("site");
$sitetab->setAttribs({ "key" => "__SEQDiscover" }, { "value" => "$textparam" });
$sitetab->close();
}
#set the groups for the node
my $nltab = xCAT::Table->new('nodelist');
unless ($nltab) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: nodelist.");
}
if (defined($param{'groups'})) {
$nltab->setNodeAttribs($node, { groups => $param{'groups'} });
} else {
# just set the groups attribute when there was no groups value was set
my $nlent = $nltab->getNodeAttribs($node, ['groups']);
if (!$nlent || !$nlent->{'groups'}) {
$nltab->setNodeAttribs($node, { groups => "all" });
}
}
# update node groups with pre-defined groups
if (defined($param{'mtm'})) {
my @list = ();
my $tmp_group = xCAT::data::ibmhwtypes::parse_group($param{'mtm'});
if (defined($tmp_group)) {
xCAT::TableUtils->updatenodegroups($node, $nltab, $tmp_group);
}
}
# set the mgt for the node
my $hmtab = xCAT::Table->new('nodehm');
unless ($hmtab) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: nodehm.");
}
my $hment = $hmtab->getNodeAttribs($node, ['mgt']);
if (!$hment || !$hment->{'mgt'}) {
$hmtab->setNodeAttribs($node, { mgt => "ipmi" });
}
my $chaintab = xCAT::Table->new('chain');
# Could not open chain table, but do not fail the discovery process
if (!$chaintab) {
xCAT::MsgUtils->message("S", "Error: could not open chain table");
} else {
my $chainent = $chaintab->getNodeAttribs($node, ['chain']);
my $nodechain = '';
my $origchain = '';
if (defined($chainent->{'chain'})) {
$nodechain = $chainent->{'chain'};
$origchain = $nodechain;
}
# If the bmciprange=xxx is specified with nodediscoverstart command,
# add the runcmd=bmcsetup at the beginning of the chain attribute
# the skipbmcsetup could be used to skip the bmcsetup for the node
if ($param{'bmciprange'} && !$param{'skipbmcsetup'}) {
if (!$nodechain) {
$nodechain = "runcmd=bmcsetup";
} else {
# do not add duplicate runcmd=bmcsetup in the chain attribute
if ($nodechain !~ /runcmd=bmcsetup/) {
$nodechain = "runcmd=bmcsetup," . $nodechain;
}
}
} # end if $param{'bmciprange'}
# Remove the runcmd=bmcsetup from chain if skipbmcsetup is specified
# this is useful for predefined configuration, or attributes inherit from groups
if ($param{'skipbmcsetup'}) {
if ($nodechain =~ /runcmd=bmcsetup/) {
$nodechain =~ s/runcmd=bmcsetup,//;
$nodechain =~ s/runcmd=bmcsetup//;
}
}
# If the osimage=xxx is specified with nodediscoverstart command,
# append the osimage=xxx at the end of the chain attribute
if ($param{'osimage'}) {
if (!$nodechain) {
$nodechain = "osimage=$param{'osimage'}";
} else {
# do not add multiple osimage=xxx in the chain attribute
# replace the old one with the new one
if ($nodechain !~ /osimage=/) {
$nodechain = $nodechain . ",osimage=$param{'osimage'}";
} else {
# Replace the full osimage token up to chain separator.
# Using \w+ corrupts image names containing '.' or '-'.
$nodechain =~ s/osimage=[^,;]+/osimage=$param{'osimage'}/;
}
}
} # end if $param{'osimage'}
# Update the table only when the chain attribute is changed
if ($nodechain ne $origchain) {
$chaintab->setNodeAttribs($node, { chain => $nodechain });
}
$chaintab->close();
}
# call the discovered command to update the discovery request to a node
xCAT::MsgUtils->message("S", "xcat.discovery.seqdiscovery: ($request->{_xcat_clientmac}->[0]) Found node: $node");
$request->{discoverymethod} = ['sequential'];
my $req = {%$request};
$req->{command} = ['discovered'];
$req->{noderange} = [$node];
$req->{bmc_node} = [$bmc_node];
$req->{updateswitch} = ['yes'];
$subreq->($req);
if (defined($req->{error})) {
$request->{error}->[0] = '1';
$request->{error_msg}->[0] = $req->{error_msg}->[0];
}
%{$req} = (); #Clear req structure, it's done..
undef $mactab;
} else {
nodediscoverstop($callback, undef, "node names");
xCAT::MsgUtils->message("S", "xcat.discovery.seqdiscovery: ($request->{_xcat_clientmac}->[0]) Warning: Could not find any nodes using sequential-based discovery");
return;
}
xCAT::MsgUtils->message("S", "Sequential Discovery: Done");
}
=head3 displayver
Display the version information
=cut
sub displayver {
my $callback = shift;
my $version = xCAT::Utils->Version();
my $rsp;
push @{ $rsp->{data} }, $version;
xCAT::MsgUtils->message("I", $rsp, $callback);
}
=head3 nodediscoverstart
Initiate the sequencial discovery process
=cut
sub nodediscoverstart {
my $callback = shift;
my $args = shift;
my $usage = sub {
my $cb = shift;
my $msg = shift;
my $rsp;
if ($msg) {
push @{ $rsp->{data} }, $msg;
xCAT::MsgUtils->message("E", $rsp, $cb, 1);
}
my $usageinfo = "nodediscoverstart: Start a discovery process: Sequential, Profile or z/VM.
Usage:
Common:
nodediscoverstart [-h|--help|-v|--version|-V|--verbose]
Sequential Discovery:
nodediscoverstart noderange=<noderange> [hostiprange=<hostiprange>] [bmciprange=<bmciprange>] [groups=<groups>] [rack=<rack>] [chassis=<chassis>] [height=<height>] [unit=<unit>] [osimage=<osimagename>] [-n|--dns] [-s|--skipbmcsetup] [-V|--verbose]
Profile Discovery:
nodediscoverstart networkprofile=<networkprofile> imageprofile=<imageprofile> hostnameformat=<hostnameformat> [hardwareprofile=<hardwareprofile>] [groups=<groups>] [rack=<rack>] [chassis=<chassis>] [height=<height>] [unit=<unit>] [rank=rank-num]
z/VM Discovery:
nodediscoverstart zvmhost=<noderange> [defineto=both] [groups=<groups>] [ipfilter=<filter>] [openstackoperands=<operands>] [useridfilter=<filter>]
nodediscoverstart zvmhost=<noderange> defineto=xcatonly [groups=<groups>] [ipfilter=<filter>] [nodenameformat=<nodenameformat>] [useridfilter=<filter>]
nodediscoverstart zvmhost=<noderange> defineto=openstackonly [openstackoperands=<operands>]";
$rsp = ();
push @{ $rsp->{data} }, $usageinfo;
xCAT::MsgUtils->message("I", $rsp, $cb);
};
# valid attributes for seqdiscovery
my %validargs = (
'noderange' => 1,
'hostiprange' => 1,
'bmciprange' => 1,
'groups' => 1,
'rack' => 1,
'chassis' => 1,
'height' => 1,
'unit' => 1,
'osimage' => 1,
);
if ($args) {
@ARGV = @$args;
}
my ($help, $ver);
if (!GetOptions(
'h|help' => \$help,
'V|verbose' => \$::VERBOSE,
'-n|dns' => \$::DNS,
'-s|skipbmcsetup' => \$::SKIPBMCSETUP,
'v|version' => \$ver)) {
$usage->($callback);
return;
}
if ($help) {
$usage->($callback);
return;
}
if ($ver) {
&displayver($callback);
return;
}
my %orgargs;
foreach (@ARGV) {
my ($name, $value) = split('=', $_);
$orgargs{$name} = $value;
}
# Check the zvmhost= has been specified which is the flag that this is for z/VM discovery.
# Otherwise, fall thru to handle either sequential or profile discovery.
if ( defined( $orgargs{zvmhost} ) ) {
return;
}
# Check the noderange= has been specified which is the flag that this is for sequential discovery
# Otherwise try to check the whether the networkprofile || hardwareprofile || imageprofile
# has been passed, if yes, return to profile discovery
unless (defined($orgargs{noderange})) {
if (defined($orgargs{networkprofile}) || defined($orgargs{hostnameformat}) || defined($orgargs{imageprofile})) {
# just return that make profile-based discovery to handle it
return;
} else {
$usage->($callback, "For sequential discovery, the \'noderange\' option must be specified.");
$usage->($callback, "For z/VM discovery, the \'zvmhost\' option must be specified.");
return;
}
}
my %param; # The valid parameters
my $textparam; # The valid parameters in 'name=value,name=value...' format
# Check the validate of parameters
foreach my $name (keys %orgargs) {
unless (defined($validargs{$name})) {
$usage->($callback, "Invalid arguement \"$name\".");
return;
}
unless (defined($orgargs{$name})) {
$usage->($callback, "The parameter \"$name\" need a value.");
return;
}
# keep the valid parameters
$param{$name} = $orgargs{$name};
$textparam .= $name . '=' . $param{$name} . ',';
}
# If the -n flag is specified,
# add setupdns=yes into site.__SEQDiscover
if ($::DNS)
{
$textparam .= "dns=yes,";
}
# If the -s flag is specified,
# add skipbmcsetup=yes into site.__SEQDiscover
if ($::SKIPBMCSETUP)
{
$textparam .= "skipbmcsetup=yes,";
}
$textparam =~ s/,\z//;
# Check the running of profile-based discovery
my @PCMdiscover = xCAT::TableUtils->get_site_attribute("__PCMDiscover");
if ($PCMdiscover[0]) {
my $rsp;
push @{ $rsp->{data} }, "Sequentail Discovery cannot be run together with Profile-based discovery";
xCAT::MsgUtils->message("E", $rsp, $callback, 1);
return;
}
# Check the running of sequential discovery
my @SEQdiscover = xCAT::TableUtils->get_site_attribute("__SEQDiscover");
if ($SEQdiscover[0]) {
my $rsp;
push @{ $rsp->{data} }, "Sequentail Discovery is running. If you want to rerun the discovery, stop the running discovery first.";
xCAT::MsgUtils->message("E", $rsp, $callback, 1);
return;
}
# Check that the dynamic range in the dhcpd.conf has been set correctly
# search all the network in the networks table that make sure the dynamic range for the deployment network has been set
# Set the discovery parameters to the site.__SEQDiscover which will be used by nodediscoverls/status/stop and findme,
my $sitetab = xCAT::Table->new("site");
$sitetab->setAttribs({ "key" => "__SEQDiscover" }, { "value" => "$textparam" });
$sitetab->close();
# Clean the entries which discovery method is 'sequential' from the discoverydata table
my $distab = xCAT::Table->new("discoverydata");
$distab->delEntries({ method => 'sequential' });
$distab->commit();
# Calculate the available node name and IPs
my @freenodes = getfreenodes($param{'noderange'}, "all");
my @freehostips = getfreeips($param{'hostiprange'}, \@freenodes, "host", "all");
my @freebmcips = getfreeips($param{'bmciprange'}, \@freenodes, "bmc", "all");
#xCAT::MsgUtils->message("S", "Sequential Discovery: Start");
my $rsp;
push @{ $rsp->{data} }, "Sequential Discovery: Started:";
push @{ $rsp->{data} }, " Number of free node names: " . ($#freenodes + 1);
if ($param{'hostiprange'}) {
if (@freehostips) {
push @{ $rsp->{data} }, " Number of free host ips: " . ($#freehostips + 1);
} else {
push @{ $rsp->{data} }, " No free host ips.";
}
}
if ($param{'bmciprange'}) {
if (@freebmcips) {
push @{ $rsp->{data} }, " Number of free bmc ips: " . ($#freebmcips + 1);
} else {
push @{ $rsp->{data} }, " No free bmc ips.";
}
}
xCAT::MsgUtils->message("I", $rsp, $callback);
if ($::VERBOSE) {
# dispaly the free nodes
# get predefined host ip
my %prehostips;
my $prehosts = getpredefips(\@freenodes, "host"); #pre{ip} = nodename
foreach (keys %$prehosts) {
$prehostips{ $prehosts->{$_} } = $_; #pre{nodename} = ip
}
# get predefined bmc ip
my %prebmcips;
my $prebmcs = getpredefips(\@freenodes, "bmc"); #pre{ip} = bmcname
foreach (keys %$prebmcs) {
$prebmcips{ $prebmcs->{$_} } = $_; #pre{bmcname} = ip
}
# get the bmc of nodes
my $ipmitab = xCAT::Table->new('ipmi');
my $ipmient;
if ($ipmitab) {
$ipmient = $ipmitab->getNodesAttribs(\@freenodes, ['bmc']);
}
my $vrsp;
push @{ $vrsp->{data} }, "\n====================Free Nodes===================";
push @{ $vrsp->{data} }, sprintf("%-20s%-20s%-20s", "NODE", "HOST IP", "BMC IP");
my $index = 0;
foreach (@freenodes) {
my $hostip;
my $bmcip;
# if predefined, use it; otherwise pop out one from the free ip list
if (defined($prehostips{$_})) {
$hostip = $prehostips{$_};
} else {
while (($hostip = shift @freehostips)) {
if (!defined($prehosts->{$hostip})) { last; }
}
unless ($hostip) {
$hostip = "--no free--";
}
}
# if predefined, use it; otherwise pop out one from the free ip list
my $bmcname;
if (defined($ipmient->{$_}->[0]->{'bmc'})) {
$bmcname = $ipmient->{$_}->[0]->{'bmc'};
if ($bmcname =~ /\d+\.\d+\.\d+\.\d+/) {
$bmcip = $bmcname;
} elsif (defined($prebmcips{$bmcname})) {
$bmcip = $prebmcips{$bmcname};
}
}
unless ($bmcip) {
while (($bmcip = shift @freebmcips)) {
if (!defined($prebmcs->{$bmcip})) { last; }
}
unless ($bmcip) {
$bmcip = "--no free--";
}
}
push @{ $vrsp->{data} }, sprintf("%-20s%-20s%-20s", $_, $hostip, $bmcip);
$index++;
}
xCAT::MsgUtils->message("I", $vrsp, $callback);
}
}
=head3 nodediscoverstop
Stop the sequencial discovery process
=cut
sub nodediscoverstop {
my $callback = shift;
my $args = shift;
my $auto = shift;
my $usage = sub {
my $cb = shift;
my $msg = shift;
my $rsp;
if ($msg) {
push @{ $rsp->{data} }, $msg;
xCAT::MsgUtils->message("E", $rsp, $cb, 1);
}
my $usageinfo = "nodediscoverstop: Stop the running discovery: Profile, Sequential and z/VM.
Usage:
Common:
nodediscoverstop [-h|--help|-v|--version]
z/VM discovery:
nodediscoverstop [-z|--zvmhost <noderange>]";
$rsp = ();
push @{ $rsp->{data} }, $usageinfo;
xCAT::MsgUtils->message("I", $rsp, $cb);
};
if ($args) {
@ARGV = @$args;
}
my ($help, $ver);
if (!GetOptions(
'h|help' => \$help,
'V|verbose' => \$::VERBOSE,
'v|version' => \$ver)) {
$usage->($callback);
return;
}
if ($help) {
$usage->($callback);
return;
}
if ($ver) {
&displayver($callback);
return;
}
# Check the running of sequential discovery
my @SEQDiscover = xCAT::TableUtils->get_site_attribute("__SEQDiscover");
my @PCMDiscover = xCAT::TableUtils->get_site_attribute("__PCMDiscover");
my @ZVMDiscover = xCAT::TableUtils->get_site_attribute("__ZVMDiscover");
if ($PCMDiscover[0] or $ZVMDiscover[0]) {
# return directly that the other discovery will handle the stop function.
return;
} elsif (!$SEQDiscover[0]) {
# Neither of profile nor sequential was running
my $rsp;
push @{ $rsp->{data} }, "Sequential Discovery is stopped.";
push @{ $rsp->{data} }, "Profile Discovery is stopped.";
push @{$rsp->{data}}, "z/VM Discovery is stopped.";
xCAT::MsgUtils->message("E", $rsp, $callback, 1);
return;
}
my $DBname = xCAT::Utils->get_DBName; # support for DB2
# Go through discoverydata table and display the sequential discovery entries
my $distab = xCAT::Table->new('discoverydata');
unless ($distab) {
my $rsp;
push @{ $rsp->{data} }, "Discovery Error: Could not open table: discoverydata.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return;
}
my @disdata;
if ($DBname =~ /^DB2/) {
@disdata = $distab->getAllAttribsWhere("\"method\" = 'sequential'", 'node', 'mtm', 'serial');
} else {
@disdata = $distab->getAllAttribsWhere("method='sequential'", 'node', 'mtm', 'serial');
}
my @discoverednodes;
foreach (@disdata) {
push @discoverednodes, sprintf(" %-20s%-10s%-10s", $_->{'node'}, $_->{'mtm'}, substr($_->{'serial'}, 0, 8),);
}
my $rsp;
push @{ $rsp->{data} }, "Discovered " . ($#discoverednodes + 1) . " nodes.";
if (@discoverednodes) {
push @{ $rsp->{data} }, sprintf(" %-20s%-10s%-10s", 'NODE', 'MTM', 'SERIAL');
foreach (@discoverednodes) {
push @{ $rsp->{data} }, "$_";
}
}
xCAT::MsgUtils->message("I", $rsp, $callback);
if ($auto) {
xCAT::MsgUtils->message("S", "Sequential Discovery: Auto Stopped because all $auto in the specified range have been assigned to discovered nodes. Run \'nodediscoverls -t seq\' to display the discovery result.");
} else {
xCAT::MsgUtils->message("S", "Sequential Discovery: Stoped.");
}
# Remove the site.__SEQDiscover
my $sitetab = xCAT::Table->new("site");
$sitetab->delEntries({ key => '__SEQDiscover' });
$sitetab->commit();
}
=head3 nodediscoverls
Display the discovered nodes. This supports sequential and z/VM and partially Profile discovery.
=cut
sub nodediscoverls {
my $callback = shift;
my $args = shift;
my $usage = sub {
my $cb = shift;
my $msg = shift;
my $rsp;
if ($msg) {
push @{ $rsp->{data} }, $msg;
xCAT::MsgUtils->message("E", $rsp, $cb, 1);
}
my $usageinfo = "nodediscoverls: list the discovered nodes.
Usage:
Common:
nodediscoverls
nodediscoverls [-h|--help|-v|--version]
nodediscoverls [-t seq|profile|switch|blade|manual|mtms|undef|zvm|all] [-l]
nodediscoverls [-u uuid] [-l]
z/VM:
nodediscoverls [-t zvm][-z|--zvmhost <noderange>] [-l]";
$rsp = ();
push @{ $rsp->{data} }, $usageinfo;
xCAT::MsgUtils->message("I", $rsp, $cb);
};
if ($args) {
@ARGV = @$args;
}
my ($type, $uuid, $long, $help, $ver, $zvmHost );
if (!GetOptions(
't=s' => \$type,
'u=s' => \$uuid,
'l' => \$long,
'h|help' => \$help,
'V|verbose' => \$::VERBOSE,
'v|version' => \$ver,
'z|zvmhost=s' => \$zvmHost )) {
$usage->($callback);
return;
}
if ($help) {
$usage->($callback);
return;
}
if ($ver) {
&displayver($callback);
return;
}
# If the type is specified, display the corresponding type of nodes
my ( @SEQDiscover, @ZVMDiscover );
if ($type) {
if ($type !~ /^(seq|profile|switch|blade|manual|mtms|undef|zvm|all)$/) {
$usage->($callback, "The discovery type \'$type\' is not supported.");
return;
}
} elsif ($uuid) {
} else {
# Check the running of sequential discovery
@SEQDiscover = xCAT::TableUtils->get_site_attribute("__SEQDiscover");
@ZVMDiscover = xCAT::TableUtils->get_site_attribute("__ZVMDiscover");
my @PCMDiscover = xCAT::TableUtils->get_site_attribute("__PCMDiscover");
if ($SEQDiscover[0]) {
$type = "seq";
} elsif ($PCMDiscover[0]) {
#return directly if profile discovery is running.
return;
} elsif ( $ZVMDiscover[0] ) {
# zvmdiscovery handles requests for a running z/VM discovery.
return;
} else {
# no type, no seq and no profile, then just display all
$type = "all";
}
}
# If a zvmHost was specified then let zvmdiscovery handle it.
# Specifying '-u' will keep processing within seqdiscovery.
if ( !$uuid && ( $zvmHost || ( $type && $type eq 'zvm' )) ) {
# zvmdiscovery handles request specific to z/VM.
return;
}
my $DBname = xCAT::Utils->get_DBName; # support for DB2
# Go through discoverydata table and display the discovery entries
my $distab = xCAT::Table->new('discoverydata');
unless ($distab) {
my $rsp;
push @{ $rsp->{data} }, "Discovery Error: Could not open table: discoverydata.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return;
}
my @disdata;
my @disattrs;
if ($long) {
@disattrs = ('uuid', 'node', 'method', 'discoverytime', 'arch', 'cpucount', 'cputype', 'memory', 'mtm', 'serial', 'nicdriver', 'nicipv4', 'nichwaddr', 'nicpci', 'nicloc', 'niconboard', 'nicfirm', 'switchname', 'switchaddr', 'switchdesc', 'switchport');
} else {
@disattrs = ('uuid', 'node', 'method', 'mtm', 'serial');
}
if ($type) {
if ($type eq "all") {
@disdata = $distab->getAllAttribs(@disattrs);
} else {
$type = "sequential" if ($type =~ /^seq/);
if ($DBname =~ /^DB2/) {
@disdata = $distab->getAllAttribsWhere("\"method\" = '$type'", @disattrs);
} else {
@disdata = $distab->getAllAttribsWhere("method='$type'", @disattrs);
}
}
} elsif ($uuid) {
if ($DBname =~ /^DB2/) {
@disdata = $distab->getAllAttribsWhere("\"uuid\" = '$uuid'", @disattrs);
} else {
@disdata = $distab->getAllAttribsWhere("uuid='$uuid'", @disattrs);
}
}
my $discoverednum = $#disdata + 1;
my @discoverednodes;
foreach my $ent (@disdata) {
if ($long) {
foreach my $attr (@disattrs) {
if ($attr eq "uuid") {
push @discoverednodes, "Object uuid: $ent->{$attr}";
} elsif (defined($ent->{$attr})) {
push @discoverednodes, " $attr=$ent->{$attr}";
}
}
} else {
$ent->{'node'} = 'undef' unless ($ent->{'node'});
$ent->{'method'} = 'undef' unless ($ent->{'method'});
push @discoverednodes, sprintf(" %-40s%-20s%-15s%-10s %-20s", $ent->{'uuid'}, $ent->{'node'}, $ent->{'method'}, $ent->{'mtm'}, substr($ent->{'serial'}, 0, 19));
}
}
my $rsp;
if (($SEQDiscover[0] && $type eq "sequential" ) or
( $type && $type eq "all" )) {
push @{ $rsp->{data} }, "Discovered $discoverednum node.";
}
if (@discoverednodes) {
unless ($long) {
push @{ $rsp->{data} }, sprintf(" %-40s%-20s%-15s%-10s %-20s", 'UUID', 'NODE', 'METHOD', 'MTM', 'SERIAL');
}
foreach (@discoverednodes) {
push @{ $rsp->{data} }, "$_";
}
}
xCAT::MsgUtils->message("I", $rsp, $callback);
}
=head3 nodediscoverstatus
Display the discovery status
=cut
sub nodediscoverstatus {
my $callback = shift;
my $args = shift;
my $usage = sub {
my $cb = shift;
my $msg = shift;
my $rsp;
if ($msg) {
push @{ $rsp->{data} }, $msg;
xCAT::MsgUtils->message("E", $rsp, $cb, 1);
}
my $usageinfo = "nodediscoverstatus: Display the discovery process status.
Usage:
Common:
nodediscoverstatus [-h|--help|-v|--version]
z/VM
nodediscoverstatus [-z|--zvmhost <noderange>]";
$rsp = ();
push @{ $rsp->{data} }, $usageinfo;
xCAT::MsgUtils->message("I", $rsp, $cb);
};
if ($args) {
@ARGV = @$args;
}
my ($type, $uuid, $long, $help, $ver);
if (!GetOptions(
'h|help' => \$help,
'V|verbose' => \$::VERBOSE,
'v|version' => \$ver)) {
$usage->($callback);
return;
}
if ($help) {
$usage->($callback);
return;
}
if ($ver) {
&displayver($callback);
return;
}
# Check the running of sequential discovery
my @SEQDiscover = xCAT::TableUtils->get_site_attribute("__SEQDiscover");
my @PCMDiscover = xCAT::TableUtils->get_site_attribute("__PCMDiscover");
my @ZVMDiscover = xCAT::TableUtils->get_site_attribute("__ZVMDiscover");
if ($SEQDiscover[0]) {
my $rsp;
push @{ $rsp->{data} }, "Sequential discovery is running.";
push @{ $rsp->{data} }, " The parameters used for discovery: " . $SEQDiscover[0];
xCAT::MsgUtils->message("I", $rsp, $callback);
} elsif ($PCMDiscover[0]) {
my $rsp;
push @{ $rsp->{data} }, "Node discovery for all nodes using profiles is running";
xCAT::MsgUtils->message("I", $rsp, $callback);
} elsif ( $ZVMDiscover[0] ) {
# z/VM discovery is a more complex response so we let its handler return the response.
} else {
my $rsp;
push @{ $rsp->{data} }, "Sequential Discovery is stopped.";
push @{ $rsp->{data} }, "Profile Discovery is stopped.";
push @{$rsp->{data}}, "z/VM Discovery is stopped.";
xCAT::MsgUtils->message("I", $rsp, $callback);
}
}
=head3 nodediscoverdef
Define the undefined entry from the discoverydata table to a specific node
Or clean the discoverydata table
=cut
sub nodediscoverdef {
my $callback = shift;
my $subreq = shift;
my $args = shift;
my @inputZvmHosts; # Input list of z/VM host nodes to stop
my $zvmHost; # Small scope variable to temporarily hold a z/VM host node value
# The subroutine used to display the usage message
my $usage = sub {
my $cb = shift;
my $msg = shift;
my $rsp;
if ($msg) {
push @{ $rsp->{data} }, $msg;
xCAT::MsgUtils->message("E", $rsp, $cb, 1);
}
my $usageinfo = "nodediscoverdef: Define the undefined discovery request, or clean the discovery entries in the discoverydata table (Which can be displayed by nodediscoverls command).
Usage:
Common:
nodediscoverdef -u uuid -n node
nodediscoverdef -r -u uuid
nodediscoverdef -r -t {seq|profile|switch|blade|manual|undef|zvm|all}
nodediscoverdef [-h|--help|-v|--version]
z/VM:
nodediscoverdef -r -t zvm [-z|--zvmhost noderange]";
$rsp = ();
push @{ $rsp->{data} }, $usageinfo;
xCAT::MsgUtils->message("I", $rsp, $cb);
};
# Parse arguments
if ($args) {
@ARGV = @$args;
}
my ($type, $uuid, $node, $remove, $help, $ver);
if (!GetOptions(
'u=s' => \$uuid,
'n=s' => \$node,
't=s' => \$type,
'r' => \$remove,
'h|help' => \$help,
'V|verbose' => \$::VERBOSE,
'v|version' => \$ver,
'z|zvmhost=s' => \$zvmHost )) {
$usage->($callback);
return;
}
if ($help) {
$usage->($callback);
return;
}
if ($ver) {
&displayver($callback);
return;
}
my $DBname = xCAT::Utils->get_DBName; # support for DB2
# Put any specified zvmhosts into an array for later use.
if ( $zvmHost ) {
$type = 'zvm' if ( !$type );
if ( $type ne 'zvm' ) {
xCAT::MsgUtils->message("E", {data=>["Discovery Error: Type must be 'zvm' when '-z' or '--zvmhost' is specified."]}, $callback);
return;
}
if ( index( $zvmHost, ',' ) != -1 ) {
# Must have specified multiple host node names
my @hosts = split( /,/, $zvmHost );
foreach $zvmHost ( @hosts ) {
if ( !$zvmHost ) {
# Tolerate zvmhost value beginning with a comma.
# It is wrong but not worth an error message.
next;
}
push( @inputZvmHosts, $zvmHost );
}
} else {
push( @inputZvmHosts, $zvmHost );
}
}
# open the discoverydata table for the subsequent using
my $distab = xCAT::Table->new("discoverydata");
unless ($distab) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: discoverydata.");
return;
}
if ($remove) {
# handle the -r to remove the entries from discoverydata table
if (!($uuid || $type) || $node) {
$usage->($callback);
return;
}
if ($uuid && $type) {
$usage->($callback);
return;
}
if ($uuid) {
# handle the -r -u <uuid>
my @disdata;
if ($DBname =~ /^DB2/) {
@disdata = $distab->getAllAttribsWhere("\"uuid\" = '$uuid'", 'method');
} else {
@disdata = $distab->getAllAttribsWhere("uuid='$uuid'", 'method');
}
unless (@disdata) {
xCAT::MsgUtils->message("E", { data => ["Cannot find discovery entry with uuid equals [$uuid]."] }, $callback);
return;
}
$distab->delEntries({ uuid => $uuid });
$distab->commit();
} elsif ($type) {
# handle the -r -t <...>
if ($type !~ /^(seq|profile|switch|blade|manual|undef|zvm|all)$/) {
$usage->($callback, "The discovery type \'$type\' is not supported.");
return;
}
if ($type eq "all") {
# remove all the entries from discoverydata table
# there's no subroutine to remove all the entries from a table, so just make code to work around
# get all the entries first
my @disdata = $distab->getAllAttribs('uuid', 'method');
my %methodlist;
foreach my $ent (@disdata) {
if ($ent->{'method'}) {
# if the entry has 'method' att set, classify them and remove at once
$methodlist{ $ent->{'method'} } = 1;
} else {
# if 'method' is not set, remove the entry directly
$distab->delEntries({ uuid => $ent->{'uuid'} });
}
}
# remove entries which have method att been set
foreach (keys %methodlist) {
$distab->delEntries({ method => $_ });
}
$distab->commit();
} else {
# remove the specific type of discovery entries
if ($type =~ /^seq/) {
$type = "sequential";
}
# If a noderange of z/VM hosts was specified then delete
# all z/VM discovered systems for those hosts. 'zvm' type
# must be used when z/VM hosts are specified.
if ( @inputZvmHosts ) {
my %keyhash;
$keyhash{'method'} = 'zvm';
foreach $zvmHost ( @inputZvmHosts ) {
$keyhash{'otherdata'} = "zvmhost." . $zvmHost;
$distab->delEntries( \%keyhash );
}
$distab->commit();
} else {
# Otherwise, Delete all systems discovered using the specified method.
$distab->delEntries({ method => $type });
$distab->commit();
}
}
}
xCAT::MsgUtils->message("I", { data => ["Removing discovery entries finished."] }, $callback);
} elsif ($uuid) {
# define the undefined entry to a node
if (!$node) {
$usage->($callback);
return;
}
# make sure the node is valid.
my @validnode = noderange($node);
if ($#validnode != 0) {
xCAT::MsgUtils->message("E", { data => ["The node [$node] should be a valid xCAT node."] }, $callback);
return;
}
$node = $validnode[0];
# to define the a request to a node, reuse the 'discovered' command to update the node
# so the procedure will be that regenerate the request base on the attributes which stored in the discoverydata table
# get all the attributes for the entry from the discoverydata table
my @disattrs = ('uuid', 'node', 'method', 'discoverytime', 'arch', 'cpucount', 'cputype', 'memory', 'mtm', 'serial', 'nicdriver', 'nicipv4', 'nichwaddr', 'nicpci', 'nicloc', 'niconboard', 'nicfirm', 'switchname', 'switchaddr', 'switchdesc', 'switchport', 'otherdata');
my @disdata;
if ($DBname =~ /^DB2/) {
@disdata = $distab->getAllAttribsWhere("\"uuid\" = '$uuid'", @disattrs);
} else {
@disdata = $distab->getAllAttribsWhere("uuid='$uuid'", @disattrs);
}
unless (@disdata) {
xCAT::MsgUtils->message("E", { data => ["Cannot find discovery entry with uuid equals $uuid"] }, $callback);
return;
}
# generate the request which is used to define the node
my $request;
my $ent = @disdata[0];
my $interfaces;
my $otherdata;
foreach my $key (keys %$ent) {
if ($key =~ /(nicdriver|nicfirm|nicipv4|nichwaddr|nicpci|nicloc|niconboard|switchaddr|switchname|switchport)/) {
# these entries are formatted as: eth0!xxx,eth1!xxx. split it and generate the request as eth0 {...}, eth1 {...}
my @ifs = split(/,/, $ent->{$key});
foreach (@ifs) {
my ($if, $value) = split('!', $_);
my $origname = $key;
if ($key eq "nicdriver") {
$origname = "driver";
} elsif ($key eq "nicfirm") {
$origname = "firmdesc";
} elsif ($key eq "nicipv4") {
$origname = "ip4address";
} elsif ($key eq "nichwaddr") {
$origname = "hwaddr";
} elsif ($key eq "nicpci") {
$origname = "pcidev";
} elsif ($key eq "nicloc") {
$origname = "location";
} elsif ($key eq "niconboard") {
$origname = "onboardeth";
}
push @{ $interfaces->{$if}->{$origname} }, $value;
}
} elsif ($key eq "otherdata") {
# this entry is just keep as is, so translate to hash is enough
$otherdata = eval { XMLin($ent->{$key}, SuppressEmpty => undef, ForceArray => 1) };
} elsif ($key eq "switchdesc") {
# just ingore the switchdesc, since it include ','
} else {
# for general attrs which just have one first level
$request->{$key} = [ $ent->{$key} ];
}
}
# add the interface part to the request hash
if ($interfaces) {
foreach (keys %$interfaces) {
$interfaces->{$_}->{'devname'} = [$_];
push @{ $request->{nic} }, $interfaces->{$_};
}
}
# add the untouched part to the request hash
if ($otherdata) {
foreach (keys %$otherdata) {
$request->{$_} = $otherdata->{$_};
}
}
# call the 'discovered' command to update the request to a node
$request->{command} = ['discovered'];
$request->{node} = [$node];
$request->{discoverymethod} = ['manual'];
$request->{updateswitch} = ['yes'];
my $rsp = $subreq->($request);
if (defined($rsp->{errorcode}->[0])) {
xCAT::MsgUtils->message("E", $rsp, $callback);
} else {
xCAT::MsgUtils->message("I", { data => ["Defined [$uuid] to node $node."] }, $callback);
}
} else {
$usage->($callback);
return;
}
}
sub process_request {
my $request = shift;
my $callback = shift;
my $subreq = shift;
my $command = $request->{command}->[0];
my $args = $request->{arg};
if ($command eq "findme") {
findme($request, $callback, $subreq);
} elsif ($command eq "nodediscoverstart") {
nodediscoverstart($callback, $args);
} elsif ($command eq "nodediscoverstop") {
nodediscoverstop($callback, $args);
} elsif ($command eq "nodediscoverls") {
nodediscoverls($callback, $args);
} elsif ($command eq "nodediscoverstatus") {
nodediscoverstatus($callback, $args);
} elsif ($command eq "nodediscoverdef") {
nodediscoverdef($callback, $subreq, $args);
}
}
=head3 getfreenodes
Get the free nodes base on the user specified noderange and defined nodes
arg1 - the noderange
arg2 - "all': return all the free nodes; otherwise just return one.
=cut
sub getfreenodes () {
my $noderange = shift;
my $all = shift;
my @freenodes;
# get all the nodes from noderange
my @nodes = noderange($noderange, 0);
# get all nodes from nodelist and mac table
my $nltb = xCAT::Table->new('nodelist');
unless ($nltb) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: nodelist.");
return;
}
my $mactb = xCAT::Table->new('mac');
unless ($mactb) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: mac.");
return;
}
# if mac address has been set, the node is not free
my $nlent = $nltb->getNodesAttribs(\@nodes, ['groups']);
my $macent = $mactb->getNodesAttribs(\@nodes, ['mac']);
foreach my $node (@nodes) {
if ($nlent->{$node}->[0]) {
unless ($macent->{$node}->[0] && $macent->{$node}->[0]->{'mac'}) {
push @freenodes, $node;
unless ($all) { last; }
}
} else {
push @freenodes, $node;
unless ($all) { last; }
}
}
unless (@freenodes) {
return;
}
if ($all) {
return @freenodes;
} else {
return $freenodes[0];
}
}
=head3 getpredefips
Get the ips which have been predefined to host or bmc
arg1 - a refenrece to the array of nodes
arg2 - type: host, bmc
return: hash {ip} = node
=cut
sub getpredefips {
my $freenode = shift;
my $type = shift; # type: host, bmc
my $hoststb = xCAT::Table->new('hosts');
unless ($hoststb) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: hosts.");
}
my %predefips; # to have the ip which prefined to the nodes
if ($type eq "bmc") {
# Find the bmc name from the ipmi table.
# if ipmi.bmc is an IP address, that means this is the IP of bmc
my @freebmc;
my %node2bmc; # $node2bmc{$node} = $bmc;
my $ipmitab = xCAT::Table->new('ipmi');
if ($ipmitab) {
my $ipmient = $ipmitab->getNodesAttribs($freenode, ['bmc']);
foreach (@$freenode) {
if (defined($ipmient->{$_}->[0]->{'bmc'})) {
if ($ipmient->{$_}->[0]->{'bmc'} =~ /\d+\.\d+\.\d+\.\d+/) {
$predefips{ $ipmient->{$_}->[0]->{'bmc'} } = $_ . "-bmc";
} else {
push @freebmc, $ipmient->{$_}->[0]->{'bmc'};
$node2bmc{$_} = $ipmient->{$_}->[0]->{'bmc'};
}
}
}
}
# check the system resolution first, then host.ip, then host.otherinterfaces
my $freenodeent = $hoststb->getNodesAttribs(\@freebmc, ['ip']);
foreach (@freebmc) {
my $nodeip = xCAT::NetworkUtils->getipaddr($_);
if ($nodeip) {
# handle the bmc which could be resolved to an IP by system
$predefips{$nodeip} = $_;
} else {
# handle the bmc which IP was defined in the hosts.ip
if (defined($freenodeent->{$_}->[0]) && $freenodeent->{$_}->[0]->{'ip'}) {
$predefips{ $freenodeent->{$_}->[0]->{'ip'} } = $_;
}
}
}
# handle the bmcs which bmc has been set in the hosts.otherinterfaces
$freenodeent = $hoststb->getNodesAttribs($freenode, ['otherinterfaces']);
foreach (@$freenode) {
if (defined($node2bmc{$_})) {
# for bmc node, search the hosts.otherinterface to see whether there's perdefined ip for bmc
my $bmcip = getbmcip_otherinterfaces($_, $node2bmc{$_}, $freenodeent->{$_}->[0]->{'otherinterfaces'});
if ($bmcip) {
$predefips{$bmcip} = $node2bmc{$_};
}
}
}
} elsif ($type eq "host") {
# get the predefined node which ip has been set in the hosts.ip
my $freenodeent = $hoststb->getNodesAttribs($freenode, ['ip']);
foreach (@$freenode) {
my $nodeip = xCAT::NetworkUtils->getipaddr($_);
if ($nodeip) {
$predefips{$nodeip} = $_;
} else {
if (defined($freenodeent->{$_}->[0]) && $freenodeent->{$_}->[0]->{'ip'}) {
$predefips{ $freenodeent->{$_}->[0]->{'ip'} } = $_;
}
}
}
}
return \%predefips;
}
=head3 getfreeips
Get the free ips base on the user specified ip range
arg1 - the ip range. Two format are suported: 192.168.1.1-192.168.2.50; 192.168.[1-2].[10-100]
arg2 - all the free nodes
arg3 - type: host, bmc
arg4 - "all': return free ips for all the free nodes; otherwise just return the first one.
return: array of all free ips or one ip base on the arg4
=cut
sub getfreeips {
my $iprange = shift;
my $freenode = shift;
my $type = shift; # type: host, bmc
my $all = shift;
my @freeips;
my %predefips; # to have the ip which prefined to the nodes
my $hoststb = xCAT::Table->new('hosts');
unless ($hoststb) {
xCAT::MsgUtils->message("S", "Discovery Error: Could not open table: hosts.");
}
my @freebmc;
my %usedips = ();
if ($type eq "bmc") {
# get the host ip for all predefind nodes from $freenode
%predefips = %{ getpredefips($freenode, "bmc") };
# get all the used ips, the predefined ip should be ignored
my @hostsent = $hoststb->getAllNodeAttribs([ 'node', 'ip', 'otherinterfaces' ]);
# Find the bmc name from the ipmi table.
# if ipmi.bmc is an IP address, that means this is the IP of bmc
my %node2bmc; # $node2bmc{$node} = $bmc;
my $ipmitab = xCAT::Table->new('ipmi');
if ($ipmitab) {
my @ipmients = $ipmitab->getAllNodeAttribs([ 'node', 'bmc' ]);
foreach my $ipmient (@ipmients) {
if (defined($ipmient->{'bmc'})) {
if ($ipmient->{'bmc'} =~ /\d+\.\d+\.\d+\.\d+/) {
unless ($predefips{ $ipmient->{'bmc'} }) {
$usedips{ $ipmient->{'bmc'} } = 1;
}
} else {
$node2bmc{ $ipmient->{'node'} } = $ipmient->{'bmc'};
}
}
}
}
foreach my $host (@hostsent) {
# handle the case that bmc has an entry in the hosts table
my $nodeip = xCAT::NetworkUtils->getipaddr($host->{'node'});
if ($nodeip) {
unless ($predefips{$nodeip}) {
$usedips{$nodeip} = 1;
}
} else {
if (defined($host->{'ip'}) && !$predefips{ $host->{'ip'} }) {
$usedips{ $host->{'ip'} } = 1;
}
}
# handle the case that the bmc<->ip mapping is specified in hosts.otherinterfaces
if (defined($node2bmc{ $host->{'node'} })) {
my $bmcip = xCAT::NetworkUtils->getipaddr($node2bmc{ $host->{'node'} });
if ($bmcip) {
unless ($predefips{$bmcip}) {
$usedips{$bmcip} = 1;
}
} else {
if (defined($host->{'otherinterfaces'})) {
my $bmcip = getbmcip_otherinterfaces($host->{'node'}, $node2bmc{ $host->{'node'} }, $host->{'otherinterfaces'});
unless ($predefips{$bmcip}) {
$usedips{$bmcip} = 1;
}
}
}
}
}
} elsif ($type eq "host") {
# get the bmc ip for all predefind nodes from $freenode
%predefips = %{ getpredefips($freenode, "host") };
# get all the used ips, the predefined ip should be ignored
my @hostsent = $hoststb->getAllNodeAttribs([ 'node', 'ip' ]);
foreach my $host (@hostsent) {
my $nodeip = xCAT::NetworkUtils->getipaddr($host->{'node'});
if ($nodeip) {
unless ($predefips{$nodeip}) {
$usedips{$nodeip} = 1;
}
} else {
if (defined($host->{'ip'}) && !$predefips{ $host->{'ip'} }) {
$usedips{ $host->{'ip'} } = 1;
}
}
}
}
# to calculate the free IP. free ip = 'ip in the range' - 'used ip'
if ($iprange =~ /(\d+\.\d+\.\d+\.\d+)-(\d+\.\d+\.\d+\.\d+)/) {
# if ip range format is 192.168.1.0-192.168.1.200
my ($startip, $endip) = ($1, $2);
my $startnum = xCAT::NetworkUtils->ip_to_int($startip);
my $endnum = xCAT::NetworkUtils->ip_to_int($endip);
while ($startnum <= $endnum) {
my $ip = xCAT::NetworkUtils->int_to_ip($startnum);
unless ($usedips{$ip}) {
push @freeips, $ip;
unless ($all) { last; }
}
$startnum++;
}
} elsif ($iprange) {
# use the noderange to expand the range
my @ips = noderange($iprange, 0);
foreach my $ip (@ips) {
unless ($usedips{$ip}) {
push @freeips, $ip;
unless ($all) { last; }
}
}
} else {
# only find the ip which mapping to the node
}
unless (@freeips) {
return;
}
if ($all) {
return @freeips;
} else {
return $freeips[0];
}
}
=head3 getbmcip_otherinterfaces
Parse the value in the hosts.otherinterfaces
arg1 - node
arg2 - bmc name
arg3 - value in the hosts.otherinterfaces
return: the ip of the node <node>-bmc
=cut
sub getbmcip_otherinterfaces
{
my $node = shift;
my $bmc = shift;
my $otherinterfaces = shift;
my @itf_pairs = split(/,/, $otherinterfaces);
foreach (@itf_pairs)
{
my ($itf, $ip);
if ($_ =~ /!/) {
($itf, $ip) = split(/!/, $_);
} else {
($itf, $ip) = split(/:/, $_);
}
if ($itf =~ /^-/)
{
$itf = $node . $itf;
}
if ($itf eq $bmc) {
return xCAT::NetworkUtils->getipaddr($ip);
}
}
return;
}
1;