mirror of
https://github.com/xcat2/xcat-core.git
synced 2025-10-31 19:32:31 +00:00
b145a34062
git-svn-id: https://svn.code.sf.net/p/xcat/code/xcat-core/trunk@16617 8638fb3e-16cb-4fca-ae20-7b5d299a9bcd
778 lines
24 KiB
Perl
Executable File
778 lines
24 KiB
Perl
Executable File
#!/usr/bin/env perl -w
|
|
# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
|
|
#####################################################
|
|
#
|
|
# xCAT post script for AIX nodes
|
|
#
|
|
# This script is run from the /etc/inittab file on both
|
|
# diskless and diskfull AIX nodes as setup by xcataixscript
|
|
#
|
|
# It is run by the updatenode cmd -P by calling xcatdsklspost 1 -m/-M (mode 1)
|
|
# updatenode cmd -k by calling xcatdsklspost 5 (mode 5)
|
|
# moncfg command (-c 3) option c means refresh /xcatpost
|
|
# For full install called from aixinstall.pm plugin with no parameters
|
|
#
|
|
#####################################################
|
|
|
|
# if AIX - make sure we include perl 5.8.2 in INC path.
|
|
# Needed to find perl dependencies shipped in deps tarball.
|
|
if ($^O =~ /^aix/i) {
|
|
unshift(@INC, qw(/usr/opt/perl5/lib/5.8.2/aix-thread-multi /usr/opt/perl5/lib/5.8.2 /usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi /usr/opt/perl5/lib/site_perl/5.8.2));
|
|
}
|
|
|
|
use strict;
|
|
use File::Path;
|
|
use IO::Socket;
|
|
my $useSocketSSL=eval { require IO::Socket::SSL; };
|
|
use Getopt::Long;
|
|
use XML::Simple;
|
|
use Sys::Hostname;
|
|
|
|
# since we don't have syslog set up yet we'll
|
|
# just save msgs in a local log file
|
|
my $logdir = "/var/log/xcat";
|
|
|
|
if (!-d $logdir) {
|
|
mkpath($logdir);
|
|
}
|
|
$::NOERROR=0; # used to control whether to display an error
|
|
$::sdate = `/bin/date`;
|
|
chomp $::sdate;
|
|
my $logfile = $logdir . "/xcat.log";
|
|
`logger -t xcat -p local4.info "my logfile is $logfile"`;
|
|
|
|
# this log should not contain much so it might be ok to let it grow?
|
|
# at least we'll have the errors preserved
|
|
open(LOGFILE,">>",$logfile);
|
|
$::LOG_FILE = \*LOGFILE;
|
|
|
|
unless ($useSocketSSL) {
|
|
`logger -t xcat -p local4.info "xcataixpost: Error: cannot load necessary library IO::Socket::SSL."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Error: cannot load necessary library IO::Socket::SSL.\n";
|
|
|
|
exit 1;
|
|
}
|
|
|
|
#
|
|
# Process the command line...
|
|
#
|
|
# the -c means get a fresh copy of the postscripts from the server
|
|
# -m means we are updating the node
|
|
# -M means we are updating the service node /etc/xcatinfo file
|
|
my $idir;
|
|
my $nfsv4;
|
|
Getopt::Long::Configure("no_pass_through");
|
|
$Getopt::Long::ignorecase = 0;
|
|
if (!GetOptions('copy|c' => \$::opt_c,
|
|
'm=s' => \$::opt_m,
|
|
'M=s' => \$::opt_M,
|
|
'tftp=s'=> \$::opt_tftpdir,
|
|
'installdir=s'=> \$idir,
|
|
'nfsv4=s'=> \$nfsv4))
|
|
{ # Gather options
|
|
exit 1;
|
|
}
|
|
my $mode;
|
|
if (@ARGV<1) { # not running updatenode
|
|
|
|
sleep int(rand(10)); # installing don't hit daemon with too many requests
|
|
} else {
|
|
|
|
$mode= $ARGV[0];
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Running mode=$mode"`;
|
|
}
|
|
my $TFTPDIR=$::opt_tftpdir;
|
|
my $servnode;
|
|
|
|
# create new xcatinfo file if -M value is provided
|
|
if ($::opt_M) {
|
|
if(-f "/etc/xcatinfo") {
|
|
# backup the old file - or remove ???
|
|
my $cpcmd = "cp /etc/xcatinfo /etc/xcatinfo.orig 2>/dev/null";
|
|
if (&runcmd($cpcmd) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not copy /etc/xcatinfo file."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not copy /etc/xcatinfo file.\n";
|
|
}
|
|
}
|
|
|
|
# put the new server in the file
|
|
my $xcatinfo="/etc/xcatinfo";
|
|
open(XCATINFO,">",$xcatinfo);
|
|
print XCATINFO "XCATSERVER=$::opt_M\n";
|
|
close(XCATINFO);
|
|
|
|
chomp $::opt_M;
|
|
$servnode = $::opt_M;
|
|
$servnode =~ s/^\s*//;
|
|
}
|
|
|
|
if ($::opt_m) {
|
|
chomp $::opt_m;
|
|
$servnode = $::opt_m;
|
|
$servnode =~ s/^\s*//;
|
|
}
|
|
|
|
unless ($servnode) {
|
|
|
|
if (-f "/etc/xcatinfo") {
|
|
# if this file exists assume it has the correct server name
|
|
my $cmd = "cat /etc/xcatinfo | grep 'XCATSERVER'";
|
|
&runcmd($cmd);
|
|
my $SNline = $::outref;
|
|
my $junk;
|
|
($junk, $servnode) = split(/=/, $SNline);
|
|
chomp $servnode;
|
|
$servnode =~ s/^\s*//;
|
|
} elsif (-f "/etc/niminfo") {
|
|
# get the name of my service node (NIM master) from /etc/niminfo
|
|
my $cmd = "cat /etc/niminfo | grep 'NIM_NAME'";
|
|
&runcmd($cmd);
|
|
my $line = $::outref;
|
|
my $junk;
|
|
my $myname;
|
|
($junk, $myname) = split(/=/, $line);
|
|
chomp $myname;
|
|
if ($myname ne "master") {
|
|
$cmd = "cat /etc/niminfo | grep 'NIM_MASTER_HOSTNAME'";
|
|
&runcmd($cmd);
|
|
my $SNline = $::outref;
|
|
($junk, $servnode) = split(/=/, $SNline);
|
|
if ($servnode) {
|
|
chomp $servnode;
|
|
$servnode =~ s/^\s*//;
|
|
# save the servnode from niminfo in xcatinfo
|
|
my $xcatinfo="/etc/xcatinfo";
|
|
open(XCATINFO,">",$xcatinfo);
|
|
print XCATINFO "XCATSERVER=$servnode\n";
|
|
close(XCATINFO);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
unless ($servnode) {
|
|
`logger -t xcat -p local4.info " $::sdate xcataixpost: Could not determine server name."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not determine server name.\n
|
|
";
|
|
exit 1;
|
|
}
|
|
|
|
# create the xcatpost dir
|
|
my $cmd = "mkdir -p /xcatpost";
|
|
if (&runcmd($cmd) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not create the /xcatpost directory."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not create the /xcatpost directory.\n";
|
|
exit 1;
|
|
}
|
|
|
|
# get the xCAT hostname and the mypostscript file
|
|
if (&getxcatname($servnode) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not determine xCAT node name."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not determine xCAT node name.\n";
|
|
exit 1;
|
|
}
|
|
my $xcatname=$::XCATNAME;
|
|
my $scriptname=$::SCRIPTNAME;
|
|
|
|
# get the installdir to use
|
|
my $installdir;
|
|
my $usenfsv4;
|
|
if (-f $scriptname) {
|
|
# set the timezone
|
|
my $cmd = "cat $scriptname | grep 'INSTALLDIR='";
|
|
&runcmd($cmd);
|
|
my $dline = $::outref;
|
|
my ($junk, $installdir) = split(/=/, $dline);
|
|
if ($installdir) {
|
|
chomp $installdir;
|
|
$installdir =~ s/^(\'|\")(.*)(\"|\')$/$2/; # remove any surrounding quotes
|
|
}
|
|
$cmd = "cat $scriptname | grep 'USENFSV4ONAIX='";
|
|
&runcmd($cmd);
|
|
$dline = $::outref;
|
|
($junk, $usenfsv4) = split(/=/, $dline);
|
|
if ($usenfsv4)
|
|
{
|
|
chomp $usenfsv4;
|
|
}
|
|
}
|
|
if (!$installdir) {
|
|
$installdir = "/install";
|
|
}
|
|
|
|
# if the /xcatpost dir has not been populated or the -c option is
|
|
# specified then do the mount and copy of /install/postscripts
|
|
if ( !(-f "/xcatpost/xcataixpost") || $::opt_c ) {
|
|
|
|
# get the contents of the /install/postscripts dir on the server
|
|
# - mount dir from server and copy files
|
|
my $mcmd;
|
|
if ($usenfsv4 && ($usenfsv4 =~ /1|Yes|yes|YES|Y|y/))
|
|
{
|
|
$mcmd = "mkdir -p /xcatmnt; mount -o vers=4 $servnode:$installdir/postscripts /xcatmnt";
|
|
} else {
|
|
$mcmd = "mkdir -p /xcatmnt; mount $servnode:$installdir/postscripts /xcatmnt";
|
|
}
|
|
if (&runcmd($mcmd) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not mount $installdir/postscripts from $servnode."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not mount $installdir/postscripts from $servnode.\n";
|
|
}
|
|
|
|
my $cpcmd;
|
|
|
|
if ((@ARGV==0) || ($ARGV[0] != 2)) {
|
|
#$cpcmd = "cp -p -R /xcatmnt/* /xcatpost 2>/dev/null";
|
|
$cpcmd = "/usr/bin/rsync -Lprogtz /xcatmnt/* /xcatpost 2>/dev/null";
|
|
} else {
|
|
# when argv[1]=2, there is only one postscript file,
|
|
# user wants only download it to save time
|
|
$cpcmd= "cp /xcatmnt/$ARGV[1] /xcatpost >/dev/null 2>&1";
|
|
}
|
|
|
|
if (&runcmd($cpcmd) != 0) {
|
|
# print "$::sdate xcataixpost: Could not copy postscripts to /xcatpost.\n";
|
|
# print $::LOG_FILE "$::sdate xcataixpost: Could not copy postscripts to /xcatpost.\n";
|
|
}
|
|
|
|
my $ucmd = "umount /xcatmnt; rmdir /xcatmnt";
|
|
if (&runcmd($ucmd) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not unmount $installdir."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not unmount $installdir/postscripts.\n";
|
|
}
|
|
|
|
} # end recopy postscripts
|
|
|
|
# make sure all are executable
|
|
my $chcmd = "chmod +x /xcatpost/*";
|
|
if (&runcmd($chcmd) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not change /xcatpost file permissions."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not change /xcatpost file permissions.\n";
|
|
}
|
|
# set TZ only on install
|
|
if (@ARGV==0) {
|
|
if (-f $scriptname) {
|
|
# set the timezone
|
|
my $cmd = "cat $scriptname | grep 'TIMEZONE='";
|
|
&runcmd($cmd);
|
|
my $TZline = $::outref;
|
|
my ($junk, $tz) = split(/=/, $TZline);
|
|
if ($tz) {
|
|
chomp $tz;
|
|
my $tzcmd = qq~/usr/bin/chtz $tz >/dev/null 2>&1~;
|
|
if (&runcmd($tzcmd) != 0) {
|
|
my $msg = "$::sdate xcataixpost: Could not set timezone.\n";
|
|
`logger -t xcat -p local4.warning $msg`;
|
|
} else {
|
|
&runcmd("export TZ=$tz");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# check & run the postscript
|
|
my $nodesetstat="standalone";
|
|
if (-f $scriptname)
|
|
{
|
|
# when called by the updatenode command,
|
|
# modify the UPDATENODE flag to 1
|
|
if (@ARGV > 0) {
|
|
if ($ARGV[0] == 1 || $ARGV[0] == 2) {
|
|
my $TMP=`sed -e 's/UPDATENODE=0/UPDATENODE=1/g' $scriptname`;
|
|
`echo "$TMP" > $scriptname`;
|
|
} elsif ($ARGV[0] == 5) {
|
|
my $TMP=`sed -e 's/UPDATENODE=0/UPDATENODE=1\\\nUPDATESECURITY=1\\\nexport UPDATESECURITY/g' $scriptname`;
|
|
`echo "$TMP" > $scriptname`;
|
|
}
|
|
}
|
|
# see if any arguments and if there are script on the argument list
|
|
my $lengtharg1=0;
|
|
if (defined ($ARGV[1])) {
|
|
$lengtharg1= length ($ARGV[1]);
|
|
}
|
|
if ((@ARGV>1) && ($lengtharg1 != 0)) { # no postscript list
|
|
my $scripts=$ARGV[1];
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: ARGV > 1."`;
|
|
my $POSTS=join('\n', split(',', $scripts));
|
|
#print "scripts=$scripts\n";
|
|
#remove all the postbootscripts
|
|
my $PSTMP=`sed "/# postbootscripts-start-here/,/# postbootscripts-end-here/ d" $scriptname`;
|
|
`echo "$PSTMP" > $scriptname`;
|
|
#remove all the postscripts
|
|
my $TMP=`sed "/# postscripts-start-here/,/# postscripts-end-here/ d" $scriptname`;
|
|
`echo "$TMP" > $scriptname`;
|
|
`echo "# postscripts-start-here" >> $scriptname`;
|
|
#add requested postscripts in
|
|
`echo "$POSTS" | tr "," "\n" >> $scriptname`;
|
|
`echo "# postscripts-end-here" >> $scriptname`;
|
|
}
|
|
|
|
# use the run_ps subroutine to run the postscripts
|
|
my $TMP1=`sed "/# postscripts-start-here/,/# postscripts-end-here/ s/\\(.*\\)/run_ps \\1/;s/run_ps *#/#/;s/run_ps *\$//" $scriptname`;
|
|
`echo "$TMP1" > $scriptname`;
|
|
my $TMP2=`sed "/# postbootscripts-start-here/,/# postbootscripts-end-here/ s/\\(.*\\)/run_ps \\1/;s/run_ps *#/#/;s/run_ps *\$//" $scriptname`;
|
|
`echo "
|
|
# subroutine used to run postscripts
|
|
run_ps () {
|
|
logdir=\\"/var/log/xcat\\"
|
|
mkdir -p \\\$logdir
|
|
logfile=\\"/var/log/xcat/xcat.log\\"
|
|
|
|
if [[ -f \\\$1 ]]; then
|
|
echo \\"\\\`date\\\` Running postscript: \\\$@\\" | tee -a \\\$logfile
|
|
./\\\$@ 2>&1 | tee -a \\\$logfile
|
|
else
|
|
echo \\"\\\`date\\\` Postscript \\\$1 does NOT exist.\\" | tee -a \\\$logfile
|
|
fi
|
|
}
|
|
# subroutine end
|
|
|
|
" > $scriptname`;
|
|
`echo "$TMP2" >> $scriptname`;
|
|
|
|
$nodesetstat=`grep "NODESETSTATE=" $scriptname|awk -F \= '{print \$2}'`;
|
|
chomp($nodesetstat);
|
|
$ENV{PATH}="/xcatpost:$ENV{PATH}";
|
|
&runcmd("cd /xcatpost;$scriptname");
|
|
if ($::outref) {
|
|
print "$::sdate xcataixpost: run: $cmd - $::outref\n";
|
|
print $::LOG_FILE "$::sdate xcataixpost: run: $cmd - $::outref\n";
|
|
} else {
|
|
print "$::sdate xcataixpost: run: $cmd \n";
|
|
print $::LOG_FILE "$::sdate xcataixpost: run: $cmd \n";
|
|
}
|
|
} else {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not find post script for $xcatname."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not find post script for $xcatname.\n";
|
|
}
|
|
|
|
if (@ARGV<1) { # not running updatenode
|
|
my $update=1;
|
|
if (-f $scriptname) {
|
|
my $CNS=`grep NODESTATUS= $scriptname`;
|
|
if ((!$?) && ($CNS =~ /\'0\'|\'N\'|\'n\'/)) { $update=0;} #only update is nonodestatus is not set in the site table
|
|
}
|
|
if ($update) {
|
|
my $keywd="installstatus";
|
|
my $state="booted";
|
|
if (&updateflag($keywd, $state) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Failed to update the xCAT server."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Failed to update the xCAT server..\n";
|
|
}
|
|
}
|
|
} else {
|
|
#called by updatenode, tell user it is done
|
|
`logger -t xcat -p local4.info "xcataixpost finished running postscripts"`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: returned from postscript.\n";
|
|
}
|
|
|
|
if (-f $scriptname) {
|
|
|
|
if ($::ROOTPW) {
|
|
chomp $::ROOTPW;
|
|
my $pwcmd;
|
|
|
|
if ($::CRYPTMETHOD) {
|
|
$pwcmd = qq~echo "root:$::ROOTPW" | /bin/chpasswd -e -c >/dev/null 2>&1~;
|
|
} else {
|
|
$pwcmd = qq~echo "root:$::ROOTPW" | /bin/chpasswd -c >/dev/null 2>&1~;
|
|
}
|
|
if (&runcmd($pwcmd) != 0) {
|
|
my $msg = "$::sdate xcataixpost: Could not set root password.\n";
|
|
`logger -t xcat -p local4.warning $msg`;
|
|
}
|
|
}
|
|
}
|
|
|
|
# If this is a diskfull node then remove the xcat entry in the inittab file
|
|
$nodesetstat =~ s/'|"//g;
|
|
if ($nodesetstat eq 'standalone') {
|
|
# see if it is already there
|
|
my $lsicmd = "/usr/sbin/lsitab xcat > /dev/null 2>&1";
|
|
if (&runcmd($lsicmd, 0) == 0) {
|
|
# ok - remove the entry
|
|
my $rmitab_cmd = 'rmitab "xcat" > /dev/null 2>&1';
|
|
if (&runcmd($rmitab_cmd) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not remove xcataixpost from /etc/inittab."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not remove xcataixpost from /etc/inittab.\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($nodesetstat eq 'diskless') {
|
|
# see if BASECUST_REMOVAL is set in /etc/niminfo
|
|
if (-f "/etc/niminfo") {
|
|
$::NOERROR=1;
|
|
$cmd = "cat /etc/niminfo | grep 'BASECUST_REMOVAL'";
|
|
&runcmd($cmd);
|
|
my $line = $::outref;
|
|
my ($junk, $torm) = split(/=/, $line);
|
|
|
|
$::NOERROR=0;
|
|
$cmd = "cat /etc/niminfo | grep 'NIM_HOSTNAME'";
|
|
&runcmd($cmd);
|
|
$line = $::outref;
|
|
my ($junkn, $hostn) = split(/=/, $line);
|
|
|
|
if ($torm) {
|
|
chomp $hostn;
|
|
$hostn =~ s/^\s*//;
|
|
|
|
# notify the xcatd on nim master to remove this value
|
|
# so that it will not be present in the subsequent reboots
|
|
my $keywd = "basecustremv";
|
|
if (&updateflag($keywd, $hostn) != 0) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Failed to update the xCAT server."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Failed to update the xCAT server.\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
my $cleanupxcatpost = `grep "CLEANUPXCATPOST=" $scriptname|awk -F \= '{print \$2}'`;
|
|
if ((!$?) && ($cleanupxcatpost =~ /\'1\'|\'yes\'/i)) {
|
|
&runcmd("cd /; rm -rf /xcatpost/*");
|
|
}
|
|
close($::LOG_FILE);
|
|
|
|
exit 0;
|
|
|
|
#####################################################
|
|
# This routine downloads the mypostscript from /tftpboot/mypostscripts
|
|
# First try and tftp the file
|
|
# If that does not get it, then connect to getpostscript.pm to send the
|
|
# data
|
|
# input xcatname - nodename as in the database
|
|
# scriptname is /xcatpost/mypostscript_<xcatname>
|
|
#
|
|
#####################################################
|
|
|
|
sub getmypost {
|
|
my $xcatname=shift;
|
|
my $scriptname=shift;
|
|
|
|
# If the tftpdir is not /tftpboot,
|
|
# should use the -s flag to specify the tftpdir.
|
|
# using gettab to get the tftpdir from MN/SN is not efficient
|
|
# and has problem with sending multiple commands through one socket connection
|
|
if( !defined($TFTPDIR) ) {
|
|
$TFTPDIR="/tftpboot";
|
|
}
|
|
|
|
# remove the mypostscript file, so make sure we get a new one
|
|
|
|
&runcmd("rm -rf $scriptname");
|
|
|
|
# try to get the file with tftp first it is normal the file is not available, do not report
|
|
# error
|
|
`tftp -o $scriptname $servnode $TFTPDIR/mypostscripts/mypostscript.$xcatname 2>&1`;
|
|
if ((-e $scriptname) && (! (-z $scriptname))) { # got the file and it is not empty
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: tftp got $scriptname."`;
|
|
|
|
my $content;
|
|
if (!open($content, "<", $scriptname) ) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not open $scriptname."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not open $scriptname.\n";
|
|
close $content;
|
|
return 1;
|
|
}
|
|
while (<$content>) {
|
|
my $line = $_;
|
|
$line =~ s/^\s+//;
|
|
if ($line =~ /=/) {
|
|
my ($attr, $val) = $line =~ /^\s*(\S+?)\s*=\s*(\S*.*)$/;
|
|
if( defined( $attr ) ) {
|
|
if ($attr eq 'ROOTPW') {
|
|
$::ROOTPW=$val;
|
|
}
|
|
if ($attr eq 'CRYPTMETHOD') {
|
|
$::CRYPTMETHOD=$val;
|
|
}
|
|
}
|
|
}
|
|
} # end while
|
|
close $content;
|
|
|
|
}
|
|
if (-z $scriptname) { # file is empty , get rid of it
|
|
&runcmd("rm -rf $scriptname");
|
|
}
|
|
|
|
|
|
# if could not get the file, then ask for the data
|
|
|
|
if(!( -f $scriptname)) {
|
|
my $port = "3001";
|
|
# open a socket to request credentials
|
|
my $remote = IO::Socket::SSL->new(
|
|
PeerAddr => $servnode,
|
|
PeerPort => $port,
|
|
Proto => 'tcp',
|
|
);
|
|
# get ready to create the file
|
|
if (!open(POSTSCRIPT, ">$scriptname") ) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not open $scriptname."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not open $scriptname.\n"
|
|
;
|
|
close $remote;
|
|
return 1;
|
|
}
|
|
# setup the perl library path for xcat-dep packages
|
|
# this is necessary for AIX 5.3V/61H and beyond
|
|
# but does not hurt old AIX versions
|
|
print POSTSCRIPT "PERL5LIB='/usr/opt/perl5/lib/5.8.2:/usr/opt/perl5/lib/5.8.2/aix-thread-multi:/usr/opt/perl5/lib/site_perl/5.8.2:/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi'\n";
|
|
print POSTSCRIPT "export PERL5LIB\n";
|
|
|
|
|
|
unless ($remote) {
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Cannot connect to host \'$servnode\'"`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Cannot connect to host \'$servnode\'\n";
|
|
return 1;
|
|
}
|
|
|
|
# request must be in XML format
|
|
print $remote "<xcatrequest>\n";
|
|
print $remote " <command>getpostscript</command>\n";
|
|
print $remote "</xcatrequest>\n";
|
|
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: calling getpostscript to get the data"`;
|
|
# get reponse in XML format
|
|
my $response='';
|
|
my $rsp;
|
|
while (<$remote>) {
|
|
$response .= $_;
|
|
if ($response =~ m/<\/xcatresponse>/) {
|
|
$rsp = eval { XMLin($response,SuppressEmpty=>undef,ForceArray=>1) };
|
|
if ($rsp->{serverdone}) {
|
|
last;
|
|
}
|
|
# now create the mypostscript* files from the sent data
|
|
foreach my $line (@{$rsp->{data}}) {
|
|
$line =~ s/^\s+//;
|
|
if ($line =~ /=/) {
|
|
my ($attr, $val) = $line =~ /^\s*(\S+?)\s*=\s*(\S*.*)$/;
|
|
if ($attr eq 'ROOTPW') {
|
|
$::ROOTPW=$val;
|
|
}
|
|
if ($attr eq 'CRYPTMETHOD') {
|
|
$::CRYPTMETHOD=$val;
|
|
}
|
|
}
|
|
if (($line =~ /ROOTPW/) || ($line =~ /CRYPTMETHOD/)) {
|
|
next;
|
|
}
|
|
print POSTSCRIPT "$line";
|
|
}
|
|
$response='';
|
|
|
|
}
|
|
} # end while
|
|
|
|
close(POSTSCRIPT);
|
|
close $remote;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
############################################################
|
|
#
|
|
# updateflag
|
|
# Tells xCAT on the server that the post scripts is done.
|
|
#
|
|
############################################################
|
|
sub updateflag {
|
|
my $keywd=shift;
|
|
my $state=shift;
|
|
|
|
my $port = "3002";
|
|
my $servip = `host $servnode | awk '{print \$3}'`;
|
|
chomp($servip);
|
|
$servip =~ s/,$//; # remove trailing comma
|
|
my $remote = IO::Socket::INET->new( Proto => "tcp", PeerAddr => $servip, PeerPort => $port, Timeout => 0);
|
|
|
|
my $try = 10;
|
|
while (!$remote && $try-- > 0) {
|
|
sleep 1;
|
|
$remote = IO::Socket::INET->new( Proto => "tcp", PeerAddr => $servip, PeerPort => $port, Timeout => 0);
|
|
print $::LOG_FILE "$::sdate xcataixpost: Cannot connect to host \'$servip\'\n";
|
|
}
|
|
unless ($remote) {
|
|
print "$::sdate xcataixpost: Cannot connect to host \'$servip\'\n";
|
|
print $::LOG_FILE "$::sdate xcataixpost: Cannot connect to host \'$servip\'\n";
|
|
return 1;
|
|
}
|
|
$remote->autoflush(1);
|
|
|
|
my $line;
|
|
while (defined ($line = <$remote>)) {
|
|
chomp $line;
|
|
if ($line eq "ready") {
|
|
print $remote "$keywd $state\n";
|
|
} elsif ($line eq "done") {
|
|
last;
|
|
}
|
|
}
|
|
close $remote;
|
|
return 0;
|
|
}
|
|
|
|
#####################################################
|
|
#
|
|
# run the command
|
|
# the first argument is the command string
|
|
# the second argument is the log flag,
|
|
# 0 - does NOT log error message
|
|
# 1 - log error message
|
|
# if it is not specified, it equals to 1
|
|
#
|
|
#####################################################
|
|
sub runcmd
|
|
{
|
|
my ($cmd, $logerr) = @_;
|
|
|
|
if(! defined($logerr)) {
|
|
$logerr = 1;
|
|
}
|
|
my $rc=0;
|
|
$cmd .= ' 2>&1' ;
|
|
$::outref = [];
|
|
$::outref = `$cmd`;
|
|
if ($?)
|
|
{
|
|
$rc = $? >> 8;
|
|
if ($rc > 0 && $logerr)
|
|
{
|
|
if ($::NOERROR == 0) { # print the error message
|
|
if ($::outref) {
|
|
print "$::sdate xcataixpost: run: $cmd - $::outref\n";
|
|
print $::LOG_FILE "$::sdate xcataixpost: run: $cmd - $::outref\n";
|
|
} else {
|
|
print "$::sdate xcataixpost: run: $cmd \n";
|
|
print $::LOG_FILE "$::sdate xcataixpost: run: $cmd \n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $rc;
|
|
}
|
|
|
|
############################################################
|
|
#
|
|
# getxcatname
|
|
# determines the name of this node as it is know by xCAT
|
|
# request the node mypostscript_* file from the server
|
|
#
|
|
############################################################
|
|
sub getxcatname
|
|
{
|
|
my $servnode=shift;
|
|
|
|
my $xcatname;
|
|
my $scriptname;
|
|
my $xcatshort;
|
|
my $xcatlong;
|
|
# updatenode will input the nodename as an ENV variable NODE
|
|
# if we have this name, need not try anything else.
|
|
if ($ENV{NODE} ) {
|
|
$xcatname=$ENV{NODE};
|
|
|
|
# put the nodename in /etc/xcatinfo TODO, need logic not to
|
|
# wipe out XCATSERVER or add multiple entries
|
|
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost:name=$xcatname"`;
|
|
$scriptname = "/xcatpost/myxcatpost_" . $xcatname;
|
|
if (&getmypost($xcatname,$scriptname) == 0) {
|
|
$::XCATNAME=$xcatname;
|
|
$::SCRIPTNAME=$scriptname;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
# find out what interface we use to contact the server
|
|
my $NIP;
|
|
my $tcmd=qq~/bin/traceroute $servnode~;
|
|
if (&runcmd($tcmd) != 0) {
|
|
print "$::sdate xcataixpost: Could not run traceroute.\n";
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not run traceroute\n";
|
|
} else {
|
|
my @lines = ( split(/\n/, $::outref));
|
|
foreach my $l (@lines)
|
|
{
|
|
if ($l =~ /^source should be/) {
|
|
my ($n1, $n2, $n3, $nip) = split(/\s+/, $l);
|
|
chomp $l;
|
|
$l =~ s/^\s+//;
|
|
$NIP=$nip;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($NIP) {
|
|
# traceroute gave us an ip
|
|
$xcatname=gethostbyaddr(inet_aton($NIP), AF_INET);
|
|
if ($xcatname =~ /\./) {
|
|
$xcatlong=$xcatname;
|
|
($xcatshort = $xcatname) =~ s/\..*//;
|
|
} else {
|
|
$xcatlong="";
|
|
$xcatshort=$xcatname;
|
|
}
|
|
|
|
# try short name
|
|
if ($xcatshort) {
|
|
$scriptname = "/xcatpost/myxcatpost_" . $xcatshort;
|
|
if (&getmypost($xcatshort,$scriptname) == 0) {
|
|
$::XCATNAME=$xcatshort;
|
|
$::SCRIPTNAME=$scriptname;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
# try long name - if any
|
|
if ($xcatlong) {
|
|
$scriptname = "/xcatpost/myxcatpost_" . $xcatlong;
|
|
if (&getmypost($xcatlong,$scriptname) == 0) {
|
|
$::XCATNAME=$xcatlong;
|
|
$::SCRIPTNAME=$scriptname;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
# couldn't find NIP so try the primary hostname
|
|
$xcatname=hostname();
|
|
if ($xcatname =~ /\./) {
|
|
$xcatlong=$xcatname;
|
|
($xcatshort = $xcatname) =~ s/\..*//;
|
|
} else {
|
|
$xcatlong="";
|
|
$xcatshort=$xcatname;
|
|
}
|
|
|
|
# try short hostname
|
|
if ($xcatshort) {
|
|
$scriptname = "/xcatpost/myxcatpost_" . $xcatshort;
|
|
if (&getmypost($xcatshort,$scriptname) == 0) {
|
|
$::XCATNAME=$xcatshort;
|
|
$::SCRIPTNAME=$scriptname;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
# try long hostname - if any
|
|
if ($xcatlong) {
|
|
$scriptname = "/xcatpost/myxcatpost_" . $xcatlong;
|
|
if (&getmypost($xcatlong,$scriptname) == 0) {
|
|
$::XCATNAME=$xcatlong;
|
|
$::SCRIPTNAME=$scriptname;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
# if we get here we've exhaused all possibilities
|
|
`logger -t xcat -p local4.info "$::sdate xcataixpost: Could not get the xCAT post script for this node."`;
|
|
print $::LOG_FILE "$::sdate xcataixpost: Could not get the xCAT post script for this node.\n";
|
|
|
|
return 1;
|
|
}
|