xcat-core/xCAT/postscripts/xcataixpost

#!/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;
}