arif/xcat-core
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
9581e25412
xcat-core/xCAT-server/lib/xcat/plugins/lsslp.pm
yinle b868089ba6 Modify code to support merging slpdiscover to lsslp. 
git-svn-id: https://svn.code.sf.net/p/xcat/code/xcat-core/trunk@14703 8638fb3e-16cb-4fca-ae20-7b5d299a9bcd
2012-12-21 09:15:24 +00:00

1979 lines
71 KiB
Perl
Raw Blame History

# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
package xCAT_plugin::lsslp;
use lib "/opt/xcat/lib/perl";
use strict;
use Getopt::Long;
use Socket;
use xCAT::Usage;
use POSIX "WNOHANG";
use Storable qw(freeze thaw);
use Time::HiRes qw(gettimeofday);
use xCAT::SvrUtils qw/sendmsg/;
use IO::Select;
use XML::Simple;
$XML::Simple::PREFERRED_PARSER='XML::Parser';
use xCAT::PPCdb;
use xCAT::NodeRange;
use xCAT::Utils;
use xCAT::MacMap;
use xCAT::IMMUtils;
use xCAT_plugin::blade;
use xCAT::SLP;
my $mpahash;
my $defaultbladeuser;
my $defaultbladepass;
my $currentbladepass;
my $currentbladeuser;
my %nodebymp;
my $macmap;
my %chassisbyuuid;
my %flexchassisuuid;
my %flexchassismap;
my %passwordmap;
my %doneaddrs;
my %btresult;
#######################################
# Constants
#######################################
use constant {
HARDWARE_SERVICE => "service:management-hardware.IBM",
SOFTWARE_SERVICE => "service:management-software.IBM",
WILDCARD_SERVICE => "service:management-*",
SERVICE_FSP => "cec-service-processor",
SERVICE_BPA => "bulk-power-controller",
SERVICE_CEC => "cec-service-processor",
SERVICE_FRAME => "bulk-power-controller",
SERVICE_HMC => "hardware-management-console",
SERVICE_IVM => "integrated-virtualization-manager",
SERVICE_MM => "management-module",
SERVICE_CMM => "chassis-management-module",
SERVICE_RSA => "remote-supervisor-adapter",
SERVICE_RSA2 => "remote-supervisor-adapter-2",
#SLP_CONF => "/usr/local/etc/slp.conf",
#SLPTOOL => "/usr/local/bin/slptool",
TYPE_MM => "mm",
TYPE_CMM => "cmm",
TYPE_RSA => "rsa",
TYPE_BPA => "bpa",
TYPE_HMC => "hmc",
TYPE_IVM => "ivm",
TYPE_FSP => "fsp",
TYPE_CEC => "cec",
TYPE_FRAME => "frame",
IP_ADDRESSES => 4,
TEXT => 0,
FORMAT => 1,
SUCCESS => 0,
RC_ERROR => 1,
};
#######################################
# Globals
#######################################
my %service_slp = (
@{[ SERVICE_FSP ]} => TYPE_FSP,
@{[ SERVICE_BPA ]} => TYPE_BPA,
@{[ SERVICE_CEC ]} => TYPE_CEC,
@{[ SERVICE_FRAME ]} => TYPE_FRAME,
@{[ SERVICE_HMC ]} => TYPE_HMC,
@{[ SERVICE_IVM ]} => TYPE_IVM,
@{[ SERVICE_MM ]} => TYPE_MM,
@{[ SERVICE_CMM ]} => TYPE_CMM,
@{[ SERVICE_RSA ]} => TYPE_RSA,
@{[ SERVICE_RSA2 ]} => TYPE_RSA
);
#######################################
# SLP display header
#######################################
my @header = (
["device", "%-8s" ],
["type-model", "%-12s"],
["serial-number", "%-15s"],
["side", "%-6s" ],
["ip-addresses", "placeholder"],
["hostname", "%s"]
);
my %headertoattr = (
"device" => "type",
"type-model" => "mtm",
"serial-number" => "serial",
"side" => "side",
"ip-addresses" => "ip",
"hostname" => "hostname",
);
#######################################
# Invalid IP address list
#######################################
my @invalidiplist = (
"192.168.2.144",
"192.168.2.145",
"192.168.2.146",
"192.168.2.147",
"192.168.2.148",
"192.168.2.149",
"192.168.3.144",
"192.168.3.145",
"192.168.3.146",
"192.168.3.147",
"192.168.3.148",
"192.168.3.149",
"169.254.",
"127.0.0.0",
"127",
0,
);
#######################################
# Power methods
#######################################
my %globalopt;
#these globals are only used in mn
my %ip_addr = ();
#my $macmap;
my @filternodes;
my $TRACE = 0;
my $DEBUG_MATCH = 0;
my %globalhwtype = (
fsp => $::NODETYPE_FSP,
bpa => $::NODETYPE_BPA,
lpar => $::NODETYPE_LPAR,
hmc => $::NODETYPE_HMC,
ivm => $::NODETYPE_IVM,
frame => $::NODETYPE_FRAME,
cec => $::NODETYPE_CEC,
cmm => $::NODETYPE_CMM,
);
my %globalnodetype = (
fsp => $::NODETYPE_PPC,
bpa => $::NODETYPE_PPC,
cec => $::NODETYPE_PPC,
frame => $::NODETYPE_PPC,
hmc => $::NODETYPE_PPC,
ivm => $::NODETYPE_PPC,
cmm => $::NODETYPE_MP,
lpar =>"$::NODETYPE_PPC,$::NODETYPE_OSI",
);
my %globalmgt = (
fsp => "fsp",
bpa => "bpa",
cec => "fsp",
frame => "bpa",
mm => "blade",
ivm => "ivm",
rsa => "blade",
cmm => "blade",
hmc => "hmc",
);
my %globalid = (
fsp => "cid",
cec => "cid",
bpa => "fid",
frame => "fid"
);
##########################################################################
# Command handler method from tables
##########################################################################
sub handled_commands {
return( {lsslp=>"lsslp"} );
}
##########################################################################
# Invokes the callback with the specified message
##########################################################################
sub send_msg {
my $request = shift;
my $ecode = shift;
my $msg = shift;
my %output;
#################################################
# Called from child process - send to parent
#################################################
if ( exists( $request->{pipe} )) {
my $out = $request->{pipe};
$output{errorcode} = $ecode;
$output{data} = \@_;
print $out freeze( [\%output] );
print $out "\nENDOFFREEZE6sK4ci\n";
}
#################################################
# Called from parent - invoke callback directly
#################################################
elsif ( exists( $request->{callback} )) {
my $callback = $request->{callback};
$output{errorcode} = $ecode;
$output{data} = $msg;
$callback->( \%output );
}
}
##########################################################################
# Parse the command line options and operands
##########################################################################
sub parse_args {
my $request = shift;
my $args = $request->{arg};
my $cmd = $request->{command};
my %opt;
my %services = (
HMC => SOFTWARE_SERVICE.":".SERVICE_HMC.":",
IVM => SOFTWARE_SERVICE.":".SERVICE_IVM.":",
BPA => HARDWARE_SERVICE.":".SERVICE_BPA,
FSP => HARDWARE_SERVICE.":".SERVICE_FSP,
CEC => HARDWARE_SERVICE.":".SERVICE_CEC,
FRAME => HARDWARE_SERVICE.":".SERVICE_FRAME,
RSA => HARDWARE_SERVICE.":".SERVICE_RSA.":",
CMM => HARDWARE_SERVICE.":".SERVICE_CMM,
MM => HARDWARE_SERVICE.":".SERVICE_MM.":"
);
#############################################
# Responds with usage statement
#############################################
local *usage = sub {
my $usage_string = xCAT::Usage->getUsage($cmd);
return( [$_[0], $usage_string] );
};
#############################################
# No command-line arguments - use defaults
#############################################
if ( !defined( $args )) {
return(0);
}
#############################################
# Checks case in GetOptions, allows opts
# to be grouped (e.g. -vx), and terminates
# at the first unrecognized option.
#############################################
@ARGV = @$args;
$Getopt::Long::ignorecase = 0;
Getopt::Long::Configure( "bundling" );
#############################################
# Process command-line flags
#############################################
if (!GetOptions( \%opt,
qw(h|help V|Verbose v|version i=s x z w r s=s e=s t=s m c n C=s T=s I flexdiscover updatehosts vpdtable))) {
return( usage() );
}
#############################################
# Check for node range
#############################################
if ( scalar(@ARGV) eq 1 ) {
my @nodes = xCAT::NodeRange::noderange( @ARGV );
foreach (@nodes) {
push @filternodes, $_;
}
unless (@filternodes) {
return(usage( "Invalid Argument: $ARGV[0]" ));
}
} elsif ( scalar(@ARGV) > 1 ) {
return(usage( "Invalid flag, please check and retry." ));
}
#############################################
# Option -V for verbose output
#############################################
if ( exists( $opt{V} )) {
$globalopt{verbose} = 1;
}
#############################################
# Check for mutually-exclusive formatting
#############################################
if ( (exists($opt{r}) + exists($opt{x}) + exists($opt{z}) + exists($opt{vpdtable}) ) > 1 ) {
return( usage() );
}
#############################################
# Command tries
#############################################
if ( exists( $opt{t} )) {
$globalopt{maxtries} = $opt{t};
if ( $globalopt{maxtries} !~ /^\d+$/ ) {
return( usage( "Invalid command tries (1-9)" ));
}
}
#############################################
# Check for unsupported service type
#############################################
if ( exists( $opt{s} )) {
if ( !exists( $services{$opt{s}} )) {
return(usage( "Invalid service: $opt{s}" ));
}
$globalopt{service} = $services{$opt{s}};
}
#############################################
# Check the validation of -T option
#############################################
if ( exists( $opt{T} )) {
$globalopt{T} = $opt{T};
if ( $globalopt{T} !~ /^\d+$/ ) {
return( usage( "Invalid timeout value, should be number" ));
}
#if (!exists( $opt{C} )) {
# return ( usage( "-T should be used with -C" ));
#}
}
#############################################
# Check the validation of -C option
#############################################
if ( exists( $opt{C} )) {
$globalopt{C} = $opt{C};
if ( $globalopt{C} !~ /^\d+$/ ) {
return( usage( "Invalid expect entries, should be number" ));
}
if ( !exists($opt{i} )) {
return( usage( "-C should be used with -i" ));
}
}
#############################################
# Check the validation of -i option
#############################################
if ( exists( $opt{i} )) {
foreach ( split /,/, $opt{i} ) {
my $ip = $_;
###################################
# Length for IPv4 addresses
###################################
my (@octets) = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
if ( scalar(@octets) != 4 ) {
return( [1,"Invalid IP address: $ip"] );
}
foreach my $octet ( @octets ) {
if (( $octet < 0 ) or ( $octet > 255 )) {
return( usage( "Invalid IP address: $ip") );
}
}
}
$globalopt{i} = $opt{i};
}
#############################################
# write to the database
#############################################
if ( exists( $opt{w} )) {
$globalopt{w} = 1;
}
#############################################
# list the raw information
#############################################
if ( exists( $opt{r} )) {
$globalopt{r} = 1;
}
#############################################
# list the xml formate data
#############################################
if ( exists( $opt{x} )) {
$globalopt{x} = 1;
}
#############################################
# list the stanza formate data
#############################################
if ( exists( $opt{z} )) {
$globalopt{z} = 1;
}
#############################################
# match vpd table
#############################################
if ( exists( $opt{vpdtable} )) {
$globalopt{vpdtable} = 1;
}
#########################################################
# only list the nodes that discovered for the first time
#########################################################
if ( exists( $opt{n} )) {
$globalopt{n} = 1;
}
##############################################
# warn for no discovered nodes in database
##############################################
if ( exists( $opt{I} )) {
$globalopt{I} = 1;
}
##############################################
# do slp and setup for cmm
##############################################
if ( exists( $opt{flexdiscover} )) {
$globalopt{flexdiscover} = 1;
}
return (0);
}
##########################################################################
# Verbose mode (-V)
##########################################################################
sub trace {
my $request = shift;
my $msg = shift;
my $sig = shift;
if ($sig) {
if ($TRACE) {
my ($sec,$min,$hour,$mday,$mon,$yr,$wday,$yday,$dst) = localtime(time);
my $msg = sprintf "%02d:%02d:%02d %5d %s", $hour,$min,$sec,$$,$msg;
send_msg( $request, 0, $msg );
}
} else {
if ( $globalopt{verbose}) {
my ($sec,$min,$hour,$mday,$mon,$yr,$wday,$yday,$dst) = localtime(time);
my $msg = sprintf "%02d:%02d:%02d %5d %s", $hour,$min,$sec,$$,$msg;
send_msg( $request, 0, $msg );
}
}
}
##########################################################################
# Forks a process to run the slp command (1 per adapter)
##########################################################################
sub fork_cmd {
my $request = shift;
#######################################
# Pipe childs output back to parent
#######################################
my $parent;
my $child;
pipe $parent, $child;
my $pid = xCAT::Utils->xfork();
if ( !defined($pid) ) {
###################################
# Fork error
###################################
send_msg( $request, 1, "Fork error: $!" );
return undef;
}
elsif ( $pid == 0 ) {
###################################
# Child process
###################################
close( $parent );
$request->{pipe} = $child;
invoke_dodiscover($request);
########################################
# Pass result array back to parent
########################################
my @results = ("FORMATDATA6sK4ci");
my $out = $request->{pipe};
print $out freeze( \@results );
print $out "\nENDOFFREEZE6sK4ci\n";
exit(0);
}
else {
###################################
# Parent process
###################################
close( $child );
return( $parent );
}
return(0);
}
##########################################################################
# Run the forked command and send reply to parent
##########################################################################
sub invoke_dodiscover {
my $request = shift;
########################################
# SLP command
########################################
my $services;
my $maxt;
if ($globalopt{service}) {
$services = $globalopt{service};
} else {
$services = [WILDCARD_SERVICE,HARDWARE_SERVICE,SOFTWARE_SERVICE];
}
#efix for hmc bug
if ($services =~ /hardware-management-console/) {
$services = [SOFTWARE_SERVICE];
}
if ($globalopt{maxtries}) {
$maxt = $globalopt{maxtries};
} else {
$maxt = 0;
}
my %arg;
if ($globalopt{flexdiscover}) {
$arg{SrvTypes} = [ qw/service:management-hardware.IBM:chassis-management-module service:management-hardware.IBM:management-module service:management-hardware.IBM:integrated-management-module2/ ];
my ($searchmacsref,$sendcount,$rsp) = xCAT::SLP::dodiscover(SrvTypes=>$arg{SrvTypes},Callback=>\&bt_handle_new_slp_entity);
return ($searchmacsref,$sendcount,$rsp);
}
$arg{SrvTypes} = $services;
#$arg{Callback} = \&handle_new_slp_entity;
$arg{Ip} = $globalopt{i} if($globalopt{i});
$arg{Retry} = $maxt;
$arg{Count} = $globalopt{C} if($globalopt{C});
$arg{Time} = $globalopt{T} if($globalopt{T});
$arg{reqcallback} = $request->{callback} if($request->{callback});
my ($searchmacsref,$sendcount,$rsp) = xCAT::SLP::dodiscover(%arg);
#########################################
## Need to check if the result is enough
#########################################
#if ( $request->{C} != 0) {
# send_msg( $request, 0, "\n Begin to try again, this may takes long time \n" );
# my %val_tmp = %$values;
# my %found_cec;
# for my $v (keys %val_tmp) {
# $v =~ /type=([^\)]+)\)\,\(serial-number=([^\)]+)\)\,\(machinetype-model=([^\)]+)\)\,/;
# if ( $found_cec{$2.'*'.$3} ne 1 and $1 eq SERVICE_FSP) {
# $found_cec{$2.'*'.$3} = 1;
# }
# }
#
# my $rlt;
# my $val;
# my $start_time = Time::HiRes::gettimeofday();
# my $elapse;
# my $found = scalar(keys %found_cec);
# while ( $found < $globalopt{C} ) {
# $rlt = xCAT::SLP::dodiscover(SrvTypes=>$services,Callback=>sub { print Dumper(@_) });
# $val = @$rlt[1];
# for my $v (keys %$val) {
# $v =~ /type=([^\)]+)\)\,\(serial-number=([^\)]+)\)\,\(machinetype-model=([^\)]+)\)\,/;
# if ( $found_cec{$2.'*'.$3} ne 1 and $1 eq SERVICE_FSP) {
# $found_cec{$2.'*'.$3} = 1;
# $val_tmp{$v} = 1;
# }
# }
# $found = scalar(keys %val_tmp);
# $elapse = Time::HiRes::gettimeofday() - $start_time;
# if ( $elapse > $globalopt{time_out} ) {
# send_msg( $request, 0, "Time out, Force return.\n" );
# last;
# }
# }
# send_msg( $request, 0, "Discovered $found nodes \n" );
# $values = \%val_tmp;
#}
return ($searchmacsref,$sendcount,$rsp);
}
##########################################################################
# Formats slp responses
##########################################################################
sub format_output {
my $request = shift;
my $searchmacsref = shift;
my %searchmacs = %$searchmacsref;
my $length = length( $header[IP_ADDRESSES][TEXT] );
my $result;
###########################################
# No responses
###########################################
if ( keys %searchmacs == 0 ){
send_msg( $request, 0, "No responses" );
return;
}
###########################################
# Check -C -T
###########################################
if ($globalopt{C}){
if (scalar(keys %searchmacs) ne $globalopt{C}) {
send_msg( $request, 0, "Timeout...Fource to return" );
}
}
###########################################
# Read table to get exists data
###########################################
unless($globalopt{service} =~ /hardware-management-console/) {
my $errcode = read_from_table();
if ($errcode) {
send_msg( $request, 0, "Can't open $errcode table" );
return;
}
}
###########################################
# Parse responses and add to hash
###########################################
my $outhash = parse_responses( $request, \$length, $searchmacsref );
#hmc bug efix
#my $newouthash;
#if ($globalopt{service} =~ /hardware-management-console/) {
# for my $en ( keys %$outhash ) {
# if (${$outhash->{$en}}{type} eq 'hmc') {
# $newouthash->{$en} = $outhash->{$en};
# }
# }
# $outhash = $newouthash;
#}
###########################################
# filter the result in the same vlan
###########################################
if ( exists( $globalopt{i} )) {
my $outhash1 = filtersamevlan( $outhash );
$outhash = $outhash1;
}
# filter the result and keep the specified nodes
###########################################
if ( scalar(@filternodes)) {
my $outhash1 = filter( $outhash );
$outhash = $outhash1;
}
###########################################
# -w flag for write to xCat database
###########################################
if ( $globalopt{w} ) {
send_msg( $request, 0, "Begin to write into Database, this may change node name" );
xCATdB( $outhash );
}
###########################################
# -r flag for raw response format
###########################################
my %rawhash;
if ( $globalopt{r} ) {
foreach ( keys %$outhash ) {
my $raw = ${$outhash->{$_}}{url};
$rawhash{$raw} = 1;
}
foreach my $en ( keys %rawhash ) {
if ($en =~ /(\(type.*\))/) {
$result .= "$1\n";
}
}
send_msg( $request, 0, $result );
return;
}
###########################################
# -x flag for xml format
###########################################
if ( $globalopt{x} ) {
send_msg( $request, 0, format_xml( $outhash ));
return;
}
###########################################
# -z flag for stanza format
###########################################
if ( $globalopt{z} ) {
send_msg( $request, 0, format_stanza( $outhash ));
return;
}
###########################################
# -T flag for vpd table format
###########################################
if ( $globalopt{vpdtable} ) {
send_msg( $request, 0, format_table( $outhash ) );
return;
}
###########################################
# Get longest IP for formatting purposes
###########################################
my $format = sprintf "%%-%ds", ( $length + 2 );
$header[IP_ADDRESSES][FORMAT] = $format;
###########################################
# Display header
###########################################
foreach ( @header ) {
$result .= sprintf @$_[1], @$_[0];
}
$result .= "\n";
###########################################
# Display response attributes
###########################################
foreach my $nameentry ( sort keys %$outhash ) {
my $hostname= ${$outhash->{$nameentry}}{hostname};
foreach ( @header ) {
my $attr = $headertoattr{@$_[0]};
$result .= sprintf @$_[1], ${$outhash->{$nameentry}}{$attr};
}
$result .= "\n";
}
send_msg( $request, 0, $result );
}
##########################################################################
# Read the table and cache the data that will be used frequently
##########################################################################
sub read_from_table {
my %vpdhash;
my @nodelist;
my %ppchash;
my %iphash;
if ( !(%::OLD_DATA_CACHE))
{
#find out all the existed nodes
my $nodelisttab = xCAT::Table->new('nodelist');
if ( $nodelisttab ) {
my @typeentries = $nodelisttab->getAllNodeAttribs( ['node'] );
for my $typeentry ( @typeentries) {
push @nodelist, $typeentry->{node};
}
} else {
return "nodelist";
}
#find out all the existed nodes
my $hoststab = xCAT::Table->new('hosts');
if ( $hoststab ) {
my @hostsentries = $hoststab->getAllNodeAttribs( ['node','ip'] );
for my $hostsentry ( @hostsentries) {
$iphash{$hostsentry->{node}} = $hostsentry->{ip};
}
} else {
return "hosts";
}
#find out all the existed nodes' type
my $typehashref = xCAT::DBobjUtils->getnodetype(\@nodelist);
# find out all the existed nodes' mtms and side
my $vpdtab = xCAT::Table->new( 'vpd' );
if ( $vpdtab ) {
my @vpdentries = $vpdtab->getAllNodeAttribs(['node','mtm','serial','side']);
for my $entry ( @vpdentries ) {
@{$vpdhash{$entry->{node}}}[0] = $entry->{mtm};
@{$vpdhash{$entry->{node}}}[1] = $entry->{serial};
@{$vpdhash{$entry->{node}}}[2] = $entry->{side};
}
} else {
return "vpd";
}
# find out all the existed nodes' attributes
my $ppctab = xCAT::Table->new('ppc');
if ( $ppctab ) {
my @identries = $ppctab->getAllNodeAttribs( ['node','id','parent'] );
for my $entry ( @identries ) {
next if ($entry->{nodetype} =~ /lpar/);
@{$ppchash{$entry->{node}}}[0] = $entry->{id};#id
@{$ppchash{$entry->{node}}}[1] = $entry->{parent};#parent
}
} else {
return "ppc";
}
foreach my $node (@nodelist) {
my $type = $$typehashref{$node};
my $mtm = @{$vpdhash{$node}}[0];
my $sn = @{$vpdhash{$node}}[1];
my $side = @{$vpdhash{$node}}[2];
my $id = $ppchash{$node}[0];
my $parent = $ppchash{$node}[1];
my $pmtm = @{$vpdhash{$parent}}[0];
my $psn = @{$vpdhash{$parent}}[1];
my $ip = $iphash{$node};
if ($type =~ /frame/){
$::OLD_DATA_CACHE{"frame*".$mtm."*".$sn} = $node if (defined $mtm and defined $sn);
}elsif ($type =~ /cec/) {
$::OLD_DATA_CACHE{"cec*".$mtm."*".$sn} = $node if (defined $mtm and defined $sn);
my $iid = int($id);
$parent = 'Server-'.$pmtm.'-SN'.$psn;
$::OLD_DATA_CACHE{"cec*".$parent."*".$iid} = $node if (defined $parent and defined $id);
}elsif ($type =~ /^fsp|bpa$/) {
$::OLD_DATA_CACHE{$type."*".$mtm."*".$sn."*".$side} = $node if (defined $mtm and defined $sn);;
}elsif ($type =~ /hmc/) {
$::OLD_DATA_CACHE{"hmc*".$ip} = $node if (defined $ip);
}else {
$::OLD_DATA_CACHE{$type."*".$mtm."*".$sn} = $node if (defined $mtm and defined $sn);;
}
}
}
return undef;
}
##########################################################################
# Makesure the ip in SLP URL is valid
# return 1 if valid, 0 if invalid
##########################################################################
sub check_ip {
my $myip = shift;
$myip =~ s/^(\d+)\..*/$1/;
if ($myip >= 224 and $myip <= 239){
return 0;
}
foreach (@invalidiplist){
if ( $myip =~ /^($_)/ ){
return 0;
}
}
return 1;
}
##########################################################################
# Get hostname from SLP URL response
##########################################################################
sub get_host_from_url {
my $request = shift;
my $attr = shift;
my $vip;
my $host;
#######################################
# Extract IP from URL
#######################################
my $nets = xCAT::NetworkUtils::my_nets();
my $inc = $globalopt{i};
my @ips = (exists $attr->{'ip-address'})? @{$attr->{'ip-address'}}: @{$attr->{'ipv4-address'}};
my @ips2 = split /,/, $inc;
my @validip;
if ( $inc) {
for my $net (keys %$nets) {
my $fg = 1;
for my $einc (@ips2) {
if ( $nets->{$net} eq $einc) {
$fg = 0;
}
}
delete $nets->{$net} if ($fg) ;
}
}
#######################################
# Check if valid IP
#######################################
for my $tip (@ips) {
next if ( $tip =~ /:/); #skip IPV6 addresses
for my $net ( keys %$nets) {
my ($n,$m) = split /\//,$net;
if ( #xCAT::NetworkUtils::isInSameSubnet($n, $tip, $m, 1) and
xCAT::NetworkUtils::isPingable($tip) and (length(inet_aton($tip)) == 4)) {
push @validip, $tip;
}
}
}
if (scalar(@validip) == 0) {
trace( $request, "Invalid IP address in URL" );
return undef;
}
#######################################
# Get Factory Hostname
#######################################
if ( ${$attr->{'hostname'}}[0] ) {
$host = ${$attr->{'hostname'}}[0];
} else {
$host = "Server-".${$attr->{'machinetype-model'}}[0]."-SN".${$attr->{'serial-number'}}[0];
foreach my $ip (@validip) {
my $hname = gethostbyaddr( inet_aton($ip), AF_INET );
if($hname) {
$host = $hname;
$vip = $ip;
last;
}
}
foreach my $ip (@validip) {
my $hoststab = xCAT::Table->new( 'hosts' );
my @entries = $hoststab->getAllNodeAttribs(['node','ip']);
foreach my $entry ( @entries ) {
if ( $entry->{ip} and $entry->{ip} eq $ip ) {
$host = $entry->{node};
$vip = $ip;
}
}
}
}
if ( $host =~ /([^\.]+)\./ ) {
$host = $1;
}
return $host;
}
##########################################################################
#
#########################################################################
sub parse_responses {
my $request = shift;
my $length = shift;
my $searchmacsref = shift;
my $matchflag;
my %outhash;
my $host;
my @matchnode;
my %searchmacs = %$searchmacsref;
#get networks information for defining HMC
my %net;
my %addr;
my $nettab = xCAT::Table->new('networks');
my @nets = $nettab->getAllAttribs('netname', 'net','mask','mgtifname');
if (scalar(@nets) == 0) {
send_msg( $request, 0, "Can't get networks information from networks table" );
} else {
foreach my $enet (@nets) {
next if ($enet->{'net'} =~ /:/);
$net{$enet->{'mgtifname'}}{subnet} = $enet->{'net'};
$net{$enet->{'mgtifname'}}{netmask} = $enet->{'mask'};
}
}
my $netref = xCAT::NetworkUtils->get_nic_ip();
for my $entry (keys %$netref) {
$addr{$netref->{$entry}}{subnet} = $net{$entry}{subnet};
$addr{$netref->{$entry}}{netmask} = $net{$entry}{netmask};
}
trace( $request, "Now lsslp begin to parse its response...");
foreach my $rsp ( keys(%searchmacs) ) {
###########################################
# attribute not found
###########################################
if ( !exists(${$searchmacs{$rsp}}{attributes} )) {
trace( $request, "Attribute not found for $rsp" );
next;
}
###########################################
# Valid service-type attribute
###########################################
my $attributes = ${$searchmacs{$rsp}}{attributes};
my $type = ${$attributes->{'type'}}[0] ;
if ( !exists($service_slp{$type} )) {
trace( $request, "Discarding unsupported type $type" );
next;
}
###########################################
# Define nodes
###########################################
my %atthash;
if (( $type eq SERVICE_RSA ) or ( $type eq SERVICE_RSA2 ) or
( $type eq SERVICE_MM )) {
$atthash{type} = $service_slp{$type};
$atthash{mtm} = ${$attributes->{'enclosure-machinetype-model'}}[0];
$atthash{serial} = ${$attributes->{'enclosure-serial-number'}}[0];
$atthash{slot} = int(${$attributes->{'slot'}}[0]);
$atthash{ip} = ${$attributes->{'ip-address'}}[0];
$atthash{mac} = $rsp;
$atthash{hostname} = get_host_from_url($request, $attributes);
$atthash{otherinterfaces} = ${$attributes->{'ip-address'}}[0];
$atthash{url} = ${$searchmacs{$rsp}}{payload};
$outhash{'Server-'.$atthash{mtm}.'-SN'.$atthash{serial}} = \%atthash;
$$length = length( $atthash{ip}) if ( length( $atthash{ip} ) > $$length );
trace( $request, "Discover node $atthash{hostname}: type is $atthash{type}, \
mtm is $atthash{mtm}, sn is $atthash{serial}, slot is $atthash{slot}, \
ip is $atthash{ip}, mac is $atthash{mac}, otherinterfaces is $atthash{otherinterfaces}" );
} elsif ($type eq SERVICE_CMM) {
$atthash{type} = $service_slp{$type};
$atthash{mtm} = ${$attributes->{'enclosure-mtm'}}[0];
$atthash{serial} = ${$attributes->{'enclosure-serial-number'}}[0];
$atthash{side} = int(${$attributes->{'slot'}}[0]);
$atthash{ip} = ${$attributes->{'ipv4-address'}}[0];
$atthash{mac} = $rsp;
$atthash{mname} = ${$attributes->{'mm-name'}}[0];
$atthash{url} = ${$searchmacs{$rsp}}{payload};
$atthash{hostname} = get_host_from_url($request, $attributes);
$atthash{mpa} = $atthash{hostname};
$atthash{otherinterfaces} = ${$attributes->{'ipv4-address'}}[0];
$outhash{'Server-'.$atthash{mtm}.'-SN'.$atthash{serial}} = \%atthash;
$$length = length( $atthash{ip}) if ( length( $atthash{ip} ) > $$length );
trace( $request, "Discover node $atthash{hostname}: type is $atthash{type}, \
mtm is $atthash{mtm}, sn is $atthash{serial}, side is $atthash{side}, \
ip is $atthash{ip}, mac is $atthash{mac}, mname is $atthash{mname},\
mpa is $atthash{mpa}, otherinterfaces is $atthash{otherinterfaces}" );
} elsif ($type eq SERVICE_HMC) {
$atthash{type} = $service_slp{$type};
$atthash{mtm} = ${$attributes->{'machinetype-model'}}[0];
$atthash{serial} = ${$attributes->{'serial-number'}}[0];
$atthash{ip} = ${$attributes->{'ip-address'}}[0];
$atthash{hostname} = get_host_from_url($request, $attributes);
my @ips = @{$attributes->{'ip-address'}};
foreach my $tmpip (@ips) {
if (exists($::OLD_DATA_CACHE{"hmc*".$tmpip})){
$atthash{hostname} = $::OLD_DATA_CACHE{"hmc*".$tmpip};
push @matchnode, 'Server-'.$atthash{mtm}.'-SN'.$atthash{serial};
$atthash{ip} = $tmpip;
}
}
$atthash{mac} = $rsp;
$atthash{url} = ${$searchmacs{$rsp}}{payload};
$atthash{otherinterfaces} = ${$attributes->{'ip-address'}}[0];
$outhash{'Server-'.$atthash{mtm}.'-SN'.$atthash{serial}} = \%atthash;
$$length = length( $atthash{ip}) if ( length( $atthash{ip} ) > $$length );
trace( $request, "Discover node $atthash{hostname}: type is $atthash{type},\
mtm is $atthash{mtm},sn is $atthash{serial}, ip is $atthash{ip},\
mac is $atthash{mac}, otherinterfaces is $atthash{otherinterfaces}" );
}else {
#begin to define fsp and bpa
my %tmphash;
$tmphash{type} = ($type eq SERVICE_BPA) ? TYPE_BPA : TYPE_FSP;
$tmphash{mtm} = ${$attributes->{'machinetype-model'}}[0];
$tmphash{serial} = ${$attributes->{'serial-number'}}[0];
$tmphash{ip} = ${$searchmacs{$rsp}}{peername};
my $loc = ($tmphash{ip} =~ ${$attributes->{'ip-address'}}[0]) ? 0:1; #every entry has two ip-addresses
$tmphash{side} = (int(${$attributes->{'slot'}}[0]) == 0) ? 'B-'.$loc:'A-'.$loc;
$tmphash{mac} = $rsp;
$tmphash{parent} = 'Server-'.$tmphash{mtm}.'-SN'.$tmphash{serial};
$tmphash{hostname} = $tmphash{ip};
$tmphash{otherinterfaces} = ${$searchmacs{$rsp}}{peername};
$tmphash{bpcmtm} = ${$attributes->{'bpc-machinetype-model'}}[0];
$tmphash{bpcsn} = ${$attributes->{'bpc-serial-number'}}[0];
$tmphash{fid} = int(${$attributes->{'frame-number'}}[0]);
$tmphash{cid} = int(${$attributes->{'cage-number'}}[0]);
$outhash{$tmphash{ip}} = \%tmphash;
$$length = length( $tmphash{ip}) if ( length( $tmphash{ip} ) > $$length );
trace( $request, "Discover node $tmphash{hostname}:type is $tmphash{type}, mtm is $tmphash{mtm}, \
sn is $tmphash{serial}, side is $tmphash{side},parent is $tmphash{parent},ip is $tmphash{ip}, \
cec id is $tmphash{cid} , frame id is $tmphash{fid},mac is $tmphash{mac}, \
otherinterfaces is $tmphash{otherinterfaces}" );
#####################################################################
#define another side to fix the issue that the result is imcomplete
#####################################################################
my %tmphash1;
$tmphash1{ip} = (${$searchmacs{$rsp}}{peername} =~ ${$attributes->{'ip-address'}}[0])?${$attributes->{'ip-address'}}[1]:${$attributes->{'ip-address'}}[0];
unless ($outhash{$tmphash1{ip}}) {
my $validflag = 1;
foreach (@invalidiplist){
if ( $tmphash1{ip} =~ /^($_)/ ){
$validflag = 0;
last;
}
}
if ($validflag == 1) {
$tmphash1{type} = ($type eq SERVICE_BPA) ? TYPE_BPA : TYPE_FSP;
$tmphash1{mtm} = ${$attributes->{'machinetype-model'}}[0];
$tmphash1{serial} = ${$attributes->{'serial-number'}}[0];
my $loc = ($tmphash1{ip} =~ ${$attributes->{'ip-address'}}[0]) ? 0:1; #every entry has two ip-addresses
$tmphash1{side} = (int(${$attributes->{'slot'}}[0]) == 0) ? 'B-'.$loc:'A-'.$loc;
$tmphash1{mac} = xCAT::SLP::get_mac_for_addr($tmphash1{ip});
$tmphash1{parent} = 'Server-'.$tmphash1{mtm}.'-SN'.$tmphash1{serial};
$tmphash1{hostname} = $tmphash1{ip};
$tmphash1{otherinterfaces} = ${$searchmacs{$rsp}}{peername};
$tmphash1{bpcmtm} = ${$attributes->{'bpc-machinetype-model'}}[0];
$tmphash1{bpcsn} = ${$attributes->{'bpc-serial-number'}}[0];
$tmphash1{fid} = int(${$attributes->{'frame-number'}}[0]);
$tmphash1{cid} = int(${$attributes->{'cage-number'}}[0]);
$outhash{$tmphash1{ip}} = \%tmphash1;
$$length = length( $tmphash1{ip}) if ( length( $tmphash1{ip} ) > $$length );
trace( $request, "Discover another node $tmphash1{hostname}:type is $tmphash1{type}, mtm is $tmphash1{mtm}, \
sn is $tmphash1{serial}, side is $tmphash1{side},parent is $tmphash1{parent},ip is $tmphash1{ip}, \
cec id is $tmphash1{cid} , frame id is $tmphash1{fid},mac is $tmphash1{mac}, \
otherinterfaces is $tmphash1{otherinterfaces}" );
}
}
# this part of code is used to avoid two messages sent from different ports of fsp give different info. Although this hasn't showed.
#else {
# ${$outhash{$tmphash1{ip}}{fid} = int(${$attributes->{'frame-number'}}[0]) if(int(${$attributes->{'frame-number'}}[0]) != 0);
# ${$outhash{$tmphash1{ip}}{cid} = int(${$attributes->{'cage-number'}}[0]) if(int(${$attributes->{'cage-number'}}[0]) != 0);
# trace( $request, "change frame id to ${$outhash{$tmphash1{ip}}{fid}, change cec id to ${$outhash{$tmphash1{ip}}{cid} \n");
#}
######################################################################
#begin to define frame and cec
$atthash{type} = $service_slp{$type};
$atthash{mtm} = ${$attributes->{'machinetype-model'}}[0];
$atthash{serial} = ${$attributes->{'serial-number'}}[0];
my $name = 'Server-'.$atthash{mtm}.'-SN'.$atthash{serial};
unless (exists $outhash{$name} ){
$atthash{slot} = '';
$atthash{ip} = '';
$atthash{hostname} = 'Server-'.$atthash{mtm}.'-SN'.$atthash{serial};;
$atthash{mac} = "";
$atthash{bpcmtm} = ${$attributes->{'bpc-machinetype-model'}}[0];
$atthash{bpcsn} = ${$attributes->{'bpc-serial-number'}}[0];
$atthash{fid} = int(${$attributes->{'frame-number'}}[0]);
$atthash{cid} = int(${$attributes->{'cage-number'}}[0]);
$atthash{parent} = 'Server-'.$atthash{bpcmtm}.'-SN'.$atthash{bpcsn} if ($type eq SERVICE_FSP);
$atthash{children} = ${$attributes->{'ip-address'}}[0].",".${$attributes->{'ip-address'}}[1];
$atthash{url} = ${$searchmacs{$rsp}}{payload};
$outhash{'Server-'.$atthash{mtm}.'-SN'.$atthash{serial}} = \%atthash;
trace( $request, "Discover node $atthash{hostname}: type is $atthash{type}, mtm is $atthash{mtm},\
sn is $atthash{serial}, mac is $atthash{mac}, children is $atthash{children}, frame id is $atthash{fid}, \
cec id is $atthash{cid}, otherinterfaces is $atthash{otherinterfaces}, parent is $atthash{parent}" );
} else {
#update frameid and cageid to fix the firmware mistake
${$outhash{$name}}{fid} = int(${$attributes->{'frame-number'}}[0]) if(int(${$attributes->{'frame-number'}}[0]) != 0);
${$outhash{$name}}{cid} = int(${$attributes->{'cage-number'}}[0]) if(int(${$attributes->{'cage-number'}}[0]) != 0);
${$outhash{$name}}{bpcmtm} = ${$attributes->{'bpc-machinetype-model'}}[0] if(int(${$attributes->{'bpc-machinetype-model'}}[0]) != 0);
${$outhash{$name}}{bpcsn} = ${$attributes->{'bpc-serial-number'}}[0] if(int(${$attributes->{'bpc-serial-number'}}[0]) != 0);
$atthash{parent} = 'Server-'.${$outhash{$name}}{bpcmtm}.'-SN'.${$outhash{$name}}{bpcsn} if ($type eq SERVICE_FSP);
$outhash{$name}{children} .= ",".${$attributes->{'ip-address'}}[0].",".${$attributes->{'ip-address'}}[1];# at most save 8 ips and have redendant
trace( $request, "adjust frame id to ${$outhash{$name}}{fid}, cec id to ${$outhash{$name}}{cid}, children to $outhash{$name}{children},\
bpcmtm to ${$outhash{$name}}{bpcmtm}, bpcsn to ${$outhash{$name}}{bpcsn}");
}
}
}
###########################################################
# find frame's hostname first, then use find the cec's parent
# until then can begin with finding cec's hostname
# the order of finding PPC nodes' hostname can't be wrong
# and can't be done together
###########################################################
my $newhostname;
trace( $request, "\n\n\nBegin to find find frame's hostname");
foreach my $h ( keys %outhash ) {
if(${$outhash{$h}}{type} eq TYPE_FRAME) {
$newhostname = $::OLD_DATA_CACHE{"frame*".${$outhash{$h}}{mtm}."*".${$outhash{$h}}{serial}};
if ($newhostname) {
${$outhash{$h}}{hostname} = $newhostname ;
trace ( $request, "$h find hostname $newhostname");
push @matchnode, $h;
}
}
}
trace( $request, "\n\n\nBegin to find cec's parent");
foreach my $h ( keys %outhash ) {
next unless (${$outhash{$h}}{type} eq TYPE_CEC);
my $parent;
#find parent in the discovered nodes
foreach my $h1 ( keys %outhash ) {
if (${$outhash{$h1}}{type} eq "frame" and ${$outhash{$h}}{bpcmtm} eq ${$outhash{$h1}}{mtm} and ${$outhash{$h}}{bpcsn} eq ${$outhash{$h1}}{serial} ) {
$parent = ${$outhash{$h1}}{hostname};
last;
}
}
#find parent in database
if (!defined($parent)) {
my $existing_node = $::OLD_DATA_CACHE{"frame*".${$outhash{$h}}{bpcmtm}.'*'.${$outhash{$h}}{bpcsn}};
$parent = $existing_node if ($existing_node);
}
${$outhash{$h}}{parent} = $parent;
trace( $request, "$h find parent $parent") if ($parent);
}
trace( $request, "\n\n\nBegin to find cec hostname");
foreach my $h ( keys %outhash ) {
if(${$outhash{$h}}{type} eq TYPE_CEC) {
my $newhostname1 = $::OLD_DATA_CACHE{"cec*".${$outhash{$h}}{mtm}.'*'.${$outhash{$h}}{serial}};
if ($newhostname1) {
trace( $request, "$h find hostname $newhostname1 with mtms");
${$outhash{$h}}{hostname} = $newhostname1;
push @matchnode, $h;
}
my $tp = 'Server-'.${$outhash{$h}}{bpcmtm}.'-SN'.${$outhash{$h}}{bpcsn} ;
trace( $request, "$h begin to find hostname with parent $tp and id ${$outhash{$h}}{cid}");
my $newhostname2 = $::OLD_DATA_CACHE{"cec*".$tp.'*'.${$outhash{$h}}{cid}};
if ($newhostname2) {
${$outhash{$h}}{hostname} = $newhostname2;
trace( $request, "$h find hostname $newhostname2 with parent and id");
push @matchnode, $h;
}
}
}
trace( $request, "\n\n\nBegin to find fsp/bpa's hostname and parent");
foreach my $h ( keys %outhash ) {
if(${$outhash{$h}}{type} eq TYPE_FSP or ${$outhash{$h}}{type} eq TYPE_BPA) {
$newhostname = $::OLD_DATA_CACHE{${$outhash{$h}}{type}."*".${$outhash{$h}}{mtm}.'*'.${$outhash{$h}}{serial}.'*'.${$outhash{$h}}{side}};
if ($newhostname){
${$outhash{$h}}{hostname} = $newhostname ;
trace( $request, "$h find hostname $newhostname");
push @matchnode, $h;
}
my $ptmp = ${$outhash{$h}}{parent};
${$outhash{$h}}{parent} = ${$outhash{$ptmp}}{hostname};
trace( $request, "$h find parent ${$outhash{$ptmp}}{hostname}");
#check if fsp/bpa's ip is valid
my $vip = check_ip(${$outhash{$h}}{ip});
unless ( $vip ) { #which means the ip is a valid one
delete $outhash{$h};
}
}
}
trace( $request, "\n\n\nBegin to adjust fsp/bpa's id");
foreach my $h ( keys %outhash ) {
if(${$outhash{$h}}{type} eq TYPE_CEC or ${$outhash{$h}}{type} eq TYPE_FRAME) {
my @children = split /,/, ${$outhash{$h}}{children};
foreach my $child (@children) {
${$outhash{$child}}{fid} = ${$outhash{$h}}{fid};
${$outhash{$child}}{cid} = ${$outhash{$h}}{cid};
trace( $request, "child is $child, fid is ${$outhash{$child}}{fid}, cid is ${$outhash{$child}}{cid}");
}
}
}
##########################################################
# If there is -n flag, skip the matched nodes
##########################################################
if (exists($globalopt{n})) {
trace( $request, "\n\n\nThere is -n flag, skip these nodes:\n");
for my $matchednode (@matchnode) {
if ($outhash{$matchednode}) {
trace( $request, "skip the node $matchednode\n");
delete $outhash{$matchednode};
}
}
}
if (exists($globalopt{I})) {
my %existsnodes;
my $nodelisttab = xCAT::Table->new('nodelist');
unless ( $nodelisttab ) {
return( "Error opening 'nodelisttable'" );
}
my @nodes = $nodelisttab->getAllNodeAttribs([qw(node)]);
my $notdisnode;
for my $enode (@nodes) {
for my $mnode (@matchnode) {
if ($enode->{node} eq ${$outhash{$mnode}}{hostname}) {
$existsnodes{$enode->{node}} = 1;
last;
}
}
}
for my $enode (@nodes) {
unless ($existsnodes{$enode->{node}}) {
$notdisnode .= $enode->{node}.",";
}
}
send_msg ( $request, 0, "These nodes defined in database but can't be discovered: $notdisnode \n");
}
return \%outhash;
}
##########################################################################
# Write result to xCat database
##########################################################################
sub xCATdB {
my $outhash = shift;
########################################
# Begin to collect attributes for each node
########################################
my %nodelisthash;
my %ppchash;
my %vpdhash;
my %nodehmhash;
my %nodetypehash;
my %ppcdirecthash;
my %hostshash;
my %machash;
my %mphash;
foreach my $nodeentry ( keys %$outhash ) {
my $type = ${$outhash->{$nodeentry}}{type};
my $model = ${$outhash->{$nodeentry}}{mtm};
my $serial = ${$outhash->{$nodeentry}}{serial};
my $side = ${$outhash->{$nodeentry}}{side};
my $ip = ${$outhash->{$nodeentry}}{ip};
my $frameid = ${$outhash->{$nodeentry}}{fid};
my $cageid = ${$outhash->{$nodeentry}}{cid};
my $parent = ${$outhash->{$nodeentry}}{parent};
my $mac = ${$outhash->{$nodeentry}}{mac};
my $otherif = ${$outhash->{$nodeentry}}{otherinterfaces};
my $hostname = ${$outhash->{$nodeentry}}{hostname};
my $id = ($type =~ /bpa|frame/) ? $frameid:$cageid;
my $hidden = ($type =~ /bpa|fsp/)? 1:0;
########################################
# Write result to every tables,
########################################
if ( $type =~ /^bpa|fsp|cec|frame$/ ) {
$nodelisthash{$hostname} = {groups=>"$type,all", hidden=>$hidden};
$ppchash{$hostname} = {id=>$id, parent=>$parent, hcp=>$hostname, nodetype=>$globalhwtype{$type}};
$vpdhash{$hostname} = {mtm=>$model, serial=>$serial, side=>$side};
$nodehmhash{$hostname} = {mgt=>$globalmgt{$type}};
$nodetypehash{$hostname} = {nodetype=>$globalnodetype{$type}};
$hostshash{$hostname} = {otherinterfaces=>$otherif} if ($type =~ /fsp|bpa/);
$machash{$hostname} = {mac=>$mac} if ($type =~ /^fsp|bpa$/);
} elsif ( $type =~ /^(rsa|mm)$/ ) {
my @data = ($type, $model, $serial, $side, $ip, $frameid, $cageid, $parent, $mac);
xCAT::PPCdb::add_systemX( $type, $hostname, \@data );
} elsif ( $type =~ /^(hmc|ivm)$/ ) {
$nodelisthash{$hostname} = {groups=>"$type,all", hidden=>$hidden};
$ppchash{$hostname} = {nodetype=>$globalhwtype{$type}};
$vpdhash{$hostname} = {mtm=>$model, serial=>$serial};
$nodetypehash{$hostname} = {nodetype=>$globalnodetype{$type}};
$nodehmhash{$hostname} = {mgt=>$globalmgt{$type}};
$hostshash{$hostname} = {ip=>$ip};
$machash{$hostname} = {mac=>$mac};
}elsif ($type =~ /^cmm$/){
$nodelisthash{$hostname} = {groups=>"cmm,all", hidden=>$hidden};
$vpdhash{$hostname} = {mtm=>$model, serial=>$serial};
$nodetypehash{$hostname} = {nodetype=>$globalnodetype{$type}};
$nodehmhash{$hostname} = {mgt=>"blade"};
$mphash{$hostname} = {nodetype=>$globalhwtype{$type}, mpa=>$hostname, id=>$side};
$hostshash{$hostname} = {otherinterfaces=>$otherif};
}
}
########################################
# Update database
########################################
my %dbhash;
$dbhash{nodelist} = \%nodelisthash, if (%nodelisthash);
$dbhash{ppc} = \%ppchash, if (%ppchash);
$dbhash{vpd} = \%vpdhash, if (%vpdhash);
$dbhash{nodehm} = \%nodehmhash, if (%nodehmhash);
$dbhash{nodetype} = \%nodetypehash, if (%nodetypehash);
$dbhash{ppcdirect} = \%ppcdirecthash, if (%ppcdirecthash);
$dbhash{hosts} = \%hostshash, if (%hostshash);
$dbhash{mac} = \%machash, if (%machash);
$dbhash{mp} = \%mphash, if (%mphash);
for my $tab (keys %dbhash) {
my $db = xCAT::Table->new($tab);
if ( !$db ) {
return( "Error opening $db" );
}
$db->setNodesAttribs($dbhash{$tab});
$db->close();
}
}
##########################################################################
# Stanza formatting
##########################################################################
sub format_stanza {
my $outhash = shift;
my $result;
#####################################
# Write attributes
#####################################
foreach my $name ( keys %$outhash ) {
my $hostname = ${$outhash->{$name}}{hostname};
my $ip = ${$outhash->{$name}}{ip};
if ( $hostname =~ /^([^\(]+)\(([^\)]+)\)$/) {
$hostname = $1;
$ip = $2;
}
my $type = ${$outhash->{$name}}{type};
#################################
# Node attributes
#################################
$result .= "$hostname:\n\tobjtype=node\n";
if ($type =~ /^cmm$/){
$result .= "\tmpa=${$outhash->{$name}}{hostname}\n";
}else{
$result .= "\thcp=${$outhash->{$name}}{hostname}\n";
}
$result .= "\tnodetype=$globalnodetype{$type}\n";
$result .= "\tmtm=${$outhash->{$name}}{mtm}\n";
$result .= "\tserial=${$outhash->{$name}}{serial}\n";
if ($type =~ /^fsp|bpa|cmm$/) {
$result .= "\tside=${$outhash->{$name}}{side}\n";
}
$result .= "\tgroups=$type,all\n";
$result .= "\tmgt=$globalmgt{$type}\n";
if ($type =~ /^fsp|bpa|frame|cec$/) {
$result .= "\tid=${$outhash->{$name}}{$globalid{$type}}\n";
}
if ($type =~ /^fsp|bpa|cec$/ and exists(${$outhash->{$name}}{parent})) {
$result .= "\tparent=${$outhash->{$name}}{parent}\n";
}
unless ($type =~ /^frame|cec$/){
$result .= "\tmac=${$outhash->{$name}}{mac}\n";
}
if ($type =~ /^fsp|bpa$/){
$result .= "\thidden=1\n";
}else {
$result .= "\thidden=0\n";
}
#unless ($type =~ /^cmm$/) {
# $result .= "\tip=$ip\n";
#}
if ($type =~ /^fsp|bpa|cmm$/){
$result .= "\totherinterfaces=${$outhash->{$name}}{otherinterfaces}\n";
}
$result .= "\thwtype=$globalhwtype{$type}\n";
}
return( $result );
}
##########################################################################
# XML formatting
##########################################################################
sub format_xml {
my $outhash = shift;
my $xml;
my $result = format_stanza($outhash);
my @nodeentry = split 'objtype=', $result;
foreach my $entry (@nodeentry) {
my $href = {
Node => { }
};
my @attr = split '\\n\\t', $entry;
$href->{Node}->{node} = $attr[0];
for (my $i = 1; $i < scalar(@attr); $i++ ){
if( $attr[$i] =~ /(\w+)\=(.*)/){
$href->{Node}->{$1} = $2;
}
}
$xml.= XMLout($href,
NoAttr => 1,
KeyAttr => [],
RootName => undef );
}
return( $xml );
}
##########################################################################
# VPD table formatting
##########################################################################
sub format_table {
my $outhash = shift;
my $result;
#####################################
# Create XML formatted attributes
#####################################
foreach my $name ( keys %$outhash ) {
my $type = ${$outhash->{$name}}{type};
next if ($type =~ /^(fsp|bpa)$/);
$result .= "${$outhash->{$name}}{hostname}:\n";
$result .= "\tobjtype=node\n";
$result .= "\tmtm=${$outhash->{$name}}{mtm}\n";
$result .= "\tserial=${$outhash->{$name}}{serial}\n";
}
return( $result );
}
##########################################################################
# Collect output from the child processes
##########################################################################
sub child_response {
my $callback = shift;
my $fds = shift;
my @ready_fds = $fds->can_read(1);
foreach my $rfh (@ready_fds) {
my $data = <$rfh>;
#################################
# Read from child process
#################################
if ( defined( $data )) {
while ($data !~ /ENDOFFREEZE6sK4ci/) {
$data .= <$rfh>;
}
my $responses = thaw($data);
#############################
# Formatted SLP results
#############################
if ( @$responses[0] =~ /^FORMATDATA6sK4ci$/ ) {
my $result = @$responses[1];
foreach ( keys %$result ) {
#$slp_result{$_} = 1;
}
next;
}
#############################
# Message or verbose trace
#############################
foreach ( @$responses ) {
$callback->( $_ );
}
next;
}
#################################
# Done - close handle
#################################
$fds->remove($rfh);
close($rfh);
}
}
#############################################################################
# Preprocess request from xCAT daemon and send request to service nodes
#############################################################################
sub preprocess_request {
my $req = shift;
if ($req->{_xcatpreprocessed}->[0] == 1) { return [$req]; }
my $callback=shift;
my @requests;
my $command = $req->{command}->[0];
my $extrargs = $req->{arg};
my @exargs=($req->{arg});
if (ref($extrargs)) {
@exargs=@$extrargs;
}
my $usage_string=xCAT::Usage->parseCommand($command, @exargs);
if ($usage_string) {
$callback->({data=>[$usage_string]});
$req = {};
return;
}
###########################################
# find all the service nodes for xCAT cluster
# build an individual request for each service node
###########################################
my %sv_hash=();
#my @all = xCAT::Utils::getAllSN();
#foreach (@all) {
# $sv_hash{$_}=1;
#}
###########################################
# build each request for each service node
###########################################
my @result = ();
my $mncopy = {%$req};
push @result, $mncopy;
#foreach my $sn (keys (%sv_hash)) {
# my $reqcopy = {%$req};
# $reqcopy->{_xcatdest} = $sn;
# $reqcopy->{_xcatpreprocessed}->[0] = 1;
# push @result, $reqcopy;
#}
return \@result;
}
##########################################################################
# Process request from xCat daemon
##########################################################################
sub process_request {
my $req = shift;
my $callback = shift;
#unless ($macmap) { $macmap = xCAT::MacMap->new(); }
###########################################
# Build hash to pass around
###########################################
my %request;
$request{arg} = $req->{arg};
$request{callback} = $callback;
$request{command} = $req->{command}->[0];
####################################
# Process command-specific options
####################################
my $result = parse_args( \%request );
####################################
# Return error
####################################
if ( ref($result) eq 'ARRAY' ) {
send_msg( \%request, 1, @$result );
return(1);
}
#######################################
# Write header for trace
#######################################
my $tm = localtime( time );
my $msg = "\n-------- $tm\nTime PID";
trace( \%request, $msg );
###########################################
# Record begin time
###########################################
my $start = Time::HiRes::gettimeofday();
############################################
## Fork one process per adapter
############################################
#my $children = 0;
#$SIG{CHLD} = sub {
# my $rc_bak = $?;
# while (waitpid(-1, WNOHANG) > 0) { $children--; }
# $? = $rc_bak;
#};
#my $fds = new IO::Select;
#
#foreach ( keys %ip_addr ) {
# my $pipe = fork_cmd( $req, $_);
# if ( $pipe ) {
# $fds->add( $pipe );
# $children++;
# }
#}
############################################
## Process slp responses from children
############################################
#while ( $children > 0 ) {
# child_response( $callback, $fds );
#}
#while (child_response($callback,$fds)) {}
my ($searchmacsref,$sendcount,$rspc) = invoke_dodiscover(\%request);
if ($globalopt{flexdiscover}) {
bt_process($req, $callback, $searchmacsref);
return ( SUCCESS );
}
###########################################
# Record ending time
###########################################
my $elapsed = Time::HiRes::gettimeofday() - $start;
my $msg2 = sprintf( "Total SLP Time: %.3f sec\n", $elapsed );
trace( \%request, $msg2 );
###########################################
# Combined responses from all children
###########################################
my $num = keys %$searchmacsref;
my $min;
if ($num < 500) {
$min = "0-1";
} elsif (500 < $num and $num < 1000) {
$min = "1-2";
} else {
$min = "more than 2";
}
#my $start1 = Time::HiRes::gettimeofday();
send_msg( \%request, 0, "$sendcount requests with $rspc responses. Now processing responses. This will take $min minutes...");
format_output( \%request, $searchmacsref);
#my $elapsed1 = Time::HiRes::gettimeofday() - $start1;
#send_msg( \%request, 0, "$num nodes takes $elapsed1");
return( SUCCESS );
}
##########################################################################
# Filter nodes the user specified
##########################################################################
sub filter {
my $oldhash = shift;
my $newhash;
# find HMC/CEC/Frame that the user want to find
foreach my $n(@filternodes) {
for my $foundnode ( keys %$oldhash ) {
if ( ${$oldhash->{$foundnode}}{hostname} =~ /^(\w+)\(.*\)/ ) {
if ( $1 eq $n ) {
$newhash->{$foundnode} = $oldhash->{$foundnode};
if (${$oldhash->{$foundnode}}{type} eq TYPE_CEC or ${$oldhash->{$foundnode}}{type} eq TYPE_FRAME) {
my @ips = split /,/, ${$oldhash->{$foundnode}}{children};
for (my $i=0; $i<scalar(@ips); $i++) {
$newhash->{$ips[$i]} = $oldhash->{$ips[$i]};
}
}
}
} elsif ( ${$oldhash->{$foundnode}}{hostname} eq $n ) {
$newhash->{$foundnode} = $oldhash->{$foundnode};
if (${$oldhash->{$foundnode}}{type} eq TYPE_CEC or ${$oldhash->{$foundnode}}{type} eq TYPE_FRAME) {
my @ips = split /,/, ${$oldhash->{$foundnode}}{children};
for (my $i=0; $i<scalar(@ips); $i++) {
$newhash->{$ips[$i]} = $oldhash->{$ips[$i]};
}
}
}
}
}
return $newhash;
}
##########################################################################
# Filter nodes not in the user specified vlan
##########################################################################
sub filtersamevlan {
my $oldhash = shift;
my $newhash;
my $nets = xCAT::NetworkUtils::my_nets();
my $validnets;
for my $net ( keys %$nets) {
for my $nic ( split /,/, $globalopt{i} ) {
if ( $nets->{$net} eq $nic ) {
$validnets->{$net} = $nic;
}
}
}
foreach my $name ( keys %$oldhash ) {
if (${$oldhash->{$name}}{type} =~ /^(fsp|bpa)$/) {
my $ip = ${$oldhash->{$name}}{ip};
for my $net ( keys %$validnets){
my ($n,$m) = split /\//,$net;
if ( xCAT::NetworkUtils::isInSameSubnet( $n, $ip, $m, 1)) {#and xCAT::NetworkUtils::isPingable( $ip)) {
$newhash->{$name} = $oldhash->{$name};
}
}
} else {
$newhash->{$name} = $oldhash->{$name};
}
}
return $newhash;
}
##########################################################################
# This is the function that merged in from slpdiscover
##########################################################################
sub bt_process {
my $request = shift;
my $callback = shift;
my $searef = shift;
my $mpatab=xCAT::Table->new("mpa",-create=>0);
my @mpaentries;
$mpahash={};
if (ref $request->{environment} and ref $request->{environment}->[0]->{XCAT_CURRENTPASS}) {
$currentbladepass=$request->{environment}->[0]->{XCAT_CURRENTPASS}->[0];
} else {
$currentbladepass="PASSW0RD";
}
if (ref $request->{environment} and ref $request->{environment}->[0]->{XCAT_CURRENTUSER}) {
$currentbladeuser=$request->{environment}->[0]->{XCAT_CURRENTUSER}->[0];
} else {
$currentbladeuser="USERID";
}
if ($mpatab) {
@mpaentries = $mpatab->getAllNodeAttribs([qw/mpa username password/]);
foreach (@mpaentries) {
$mpahash->{$_->{mpa}}=$_;
}
}
my $passwdtab=xCAT::Table->new("passwd",-create=>0);
$defaultbladeuser="USERID";
$defaultbladepass="";
if ($passwdtab) {
my @ents = $passwdtab->getAttribs({key=>'blade'},'username','password');
foreach (@ents) {
if ($_->{username} eq "HMC") { next; }
if ($_->{username}) { $defaultbladeuser=$_->{username}; }
if ($_->{password}) { $defaultbladepass=$_->{password}; }
}
}
my $mactab = xCAT::Table->new("mac");
my %machash;
my %node2machash;
my %macuphash;
my @maclist = $mactab->getAllNodeAttribs([qw/node mac/]);
foreach (@maclist) {
$machash{$_->{node}}=$_->{mac};
$node2machash{$_->{mac}} = $_->{node};
}
my $mptab = xCAT::Table->new('mp');
my $nodecandidates;
if ($mptab) {
my @mpents = $mptab->getAllNodeAttribs(['node','mpa','id']);
foreach (@mpents) {
$nodebymp{$_->{mpa}}->{$_->{id}}=$_->{node};
}
}
$macmap = xCAT::MacMap->new();
$macmap->refresh_table();
my @toconfig;
foreach my $mac (keys(%btresult)) {
my $node = $macmap->find_mac($mac,1);
unless ($node) {
if (defined $node2machash{$mac}) {
$node = $node2machash{$mac};
} else {
next;
}
}
my $data = $btresult{$mac};
$data->{nodename}=$node;
$data->{macaddress}=$mac;
$chassisbyuuid{$data->{attributes}->{"enclosure-uuid"}->[0]}=$node;
push @toconfig,$data;
}
foreach my $data (@toconfig) {
my $mac = $data->{macaddress};
my $nodename = $data->{nodename};
my $addr = $data->{peername}; #todo, use sockaddr and remove the 427 port from it instead?
if ($addr =~ /^fe80/) { #Link local address requires scope index
$addr .= "%".$data->{scopeid};
}
$flexchassisuuid{$nodename}=$data->{attributes}->{"enclosure-uuid"}->[0];
if ($data->{SrvType} eq "service:management-hardware.IBM:chassis-management-module") {
sendmsg(":Found ".$data->{SrvType}." at address $addr",$callback,$nodename);
setup_cmm_pass($nodename);
if ($machash{$nodename} =~ /$mac/i) { #ignore prospects already known to mac table
configure_hosted_elements($nodename, $callback);
next;
}
unless (do_blade_setup($data,$callback,curraddr=>$addr)) {
next;
}
configure_hosted_elements($nodename, $callback);
unless (do_blade_setup($data,$callback,curraddr=>$addr,pass2=>1)) {
next;
}
sendmsg(":Configuration complete, configuration may take a few minutes to take effect",$callback,$nodename);
$macuphash{$nodename} = { mac => $mac };
}
}
$mactab->setNodesAttribs(\%macuphash);
}
sub configure_hosted_elements {
my $cmm = shift;
my $callback = shift;
my $uuid=$flexchassisuuid{$cmm};
my $node;
my $immdata;
my $slot;
my $user = $passwordmap{$cmm}->{username};
my $pass = $passwordmap{$cmm}->{password};
foreach $immdata (values %{$flexchassismap{$uuid}}) {
$slot=$immdata->{attributes}->{slot}->[0];
if ($node = $nodebymp{$cmm}->{$slot}) {
my $addr = $immdata->{peername}; #todo, use sockaddr and remove the 427 port from it instead?
if ($addr =~ /^fe80/) { #Link local address requires scope index
$addr .= "%".$immdata->{scopeid};
}
if ($doneaddrs{$node}) { next; }
$doneaddrs{$node}=1;
xCAT::IMMUtils::setupIMM($node,nodedata=>$immdata,curraddr=>$addr,cliusername=>$user,clipassword=>$pass,callback=>$callback);
} else {
sendmsg(": Ignoring target in bay $slot, no node found with mp.mpa/mp.id matching",$callback,$cmm);
}
}
while (wait() > 0) {}
}
sub setup_cmm_pass {
my $nodename = shift;
my $localuser=$defaultbladeuser;
my $localpass=$defaultbladepass;
if ($mpahash->{$nodename}) {
if ($mpahash->{$nodename}->{username}) {
$localuser = $mpahash->{$nodename}->{username};
}
if ($mpahash->{$nodename}->{password}) {
$localpass = $mpahash->{$nodename}->{password};
}
}
$passwordmap{$nodename}->{username}=$localuser;
$passwordmap{$nodename}->{password}=$localpass;
}
sub do_blade_setup {
my $data = shift;
my $callback = shift;
my %args = @_;
my $addr = $args{curraddr};
my $nodename = $data->{nodename};
my $localuser=$passwordmap{$nodename}->{username};
my $localpass=$passwordmap{$nodename}->{password};
if (not $localpass or $localpass eq "PASSW0RD") {
sendmsg([1,":Password for blade must be specified in either mpa or passwd tables, and it must not be PASSW0RD"],$callback,$nodename);
return 0;
}
require xCAT_plugin::blade;
my @cmds;
my %exargs;
if ($args{pass2}) {
@cmds = qw/initnetwork=*/;
%exargs = ( nokeycheck=>1 ); #still not at the 'right' ip, so the known hosts shouldn't be bothered
} else {
@cmds = qw/snmpcfg=enable sshcfg=enable textid=*/; # initnetwork=*/; defer initnetwork until after chassis members have been configured
%exargs = ( curruser=>$currentbladeuser, currpass=>$currentbladepass );
}
my $result;
$@="";
my $rc = eval { $result = xCAT_plugin::blade::clicmds(
$nodename,
$localuser,
$localpass,
$nodename,
0,
curraddr=>$addr,
%exargs,
cmds=>\@cmds );
1;
};
my $errmsg=$@;
if ($errmsg) {
if ($errmsg =~ /Incorrect Password/) {
sendmsg([1,"Failed to set up Management module due to Incorrect Password (You may try the environment variables XCAT_CURRENTUSER and/or XCAT_CURRENTPASS to try a different value)"],$callback,$nodename);
}else {
sendmsg([1,"Failed to set up Management module due to $errmsg"],$callback,$nodename);
}
return 0;
}
if ($result) {
if ($result->[0]) {
if ($result->[2] =~ /Incorrect Password/) {
sendmsg([1,"Failed to set up Management module due to Incorrect Password (You may try the environment variables XCAT_CURRENTUSER and/or XCAT_CURRENTPASS to try a different value)"],$callback,$nodename);
return 0;
}
my $errors = $result->[2];
if (ref $errors) {
foreach my $error (@$errors) {
sendmsg([$result->[0],$error],$callback,$nodename);
}
} else {
sendmsg([$result->[0],$result->[2]],$callback,$nodename);
}
return 0;
}
}
return $rc;
}
sub bt_handle_new_slp_entity {
my $data = shift;
delete $data->{sockaddr}; #won't need it
my $mac = xCAT::SLP::get_mac_for_addr($data->{peername});
if ($data->{SrvType} eq "service:management-hardware.IBM:integrated-management-module2" and $data->{attributes}->{"enclosure-form-factor"}->[0] eq "BC2") {
$data->{macaddress}=$mac;
#this is a Flex ITE, don't go mac searching for it, but remember the chassis UUID for later
if ($flexchassismap{$data->{attributes}->{"chassis-uuid"}->[0]}->{$mac} and $data->{peername} !~ /fe80/) {
return;
}
$flexchassismap{$data->{attributes}->{"chassis-uuid"}->[0]}->{$mac}=$data;
return;
}
unless ($mac) { return; }
$btresult{$mac} = $data;
}
1;
Reference in New Issue View Git Blame Copy Permalink