arif/xcat-core
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
16f0f19fab
xcat-core/perl-xCAT/xCAT/InstUtils.pm
lissav 8ddf863e48 Comment out use/require Data:Dumper 
git-svn-id: https://svn.code.sf.net/p/xcat/code/xcat-core/trunk@9270 8638fb3e-16cb-4fca-ae20-7b5d299a9bcd
2011-04-11 13:49:13 +00:00

1273 lines
33 KiB
Perl
Raw Blame History

#!/usr/bin/env perl
# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
package xCAT::InstUtils;
BEGIN
{
$::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
}
# 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)
{
use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
use lib "/usr/opt/perl5/lib/5.8.2";
use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
}
use lib "$::XCATROOT/lib/perl";
require xCAT::Table;
use POSIX qw(ceil);
use Socket;
use Sys::Hostname;
use File::Basename;
use File::Path;
use strict;
require xCAT::Schema;
use xCAT::NetworkUtils;
#require Data::Dumper;
#use Data::Dumper;
require xCAT::NodeRange;
require DBI;
#-------------------------------------------------------------------------------
=head1 xCAT::InstUtils
=head2 Package Description
This program module file, is a set of utilities used by xCAT install
related commands.
=cut
#-------------------------------------------------------------
#----------------------------------------------------------------------------
=head3 getnimprime
Get the name of the primary AIX NIM master
Returns:
hostname - short hostname of primary NIM master
undef - could not find primary NIM master
Example:
my $nimprime = xCAT::InstUtils->getnimprime();
Comments:
=cut
#-----------------------------------------------------------------------------
sub getnimprime
{
# the primary NIM master is either specified in the site table
# or it is the xCAT management node.
my $nimprime = xCAT::Utils->get_site_Master();
my $sitetab = xCAT::Table->new('site');
(my $et) = $sitetab->getAttribs({key => "NIMprime"}, 'value');
if ($et and $et->{value})
{
$nimprime = $et->{value};
}
my $hostname;
if ($nimprime)
{
if (($nimprime =~ /\d+\.\d+\.\d+\.\d+/) || ($nimprime =~ /:/))
{
$hostname = xCAT::NetworkUtils->gethostname($nimprime);
}
else
{
$hostname = $nimprime;
}
my $shorthost;
($shorthost = $hostname) =~ s/\..*$//;
chomp $shorthost;
return $shorthost;
}
return undef;
}
#----------------------------------------------------------------------------
=head3 myxCATname
Gets the name of the node I'm running on - as known by xCAT
(Either the management node or a service node)
=cut
#-----------------------------------------------------------------------------
sub myxCATname
{
my ($junk, $name);
# make sure xcatd is running - & db is available
# this routine is called during initial install of xCAT
my $cmd="lsxcatd -d > /dev/null 2>&1";
my $outref = [];
@$outref = `$cmd`;
my $rc = $? >> 8;
if ($rc == 0)
{
if (xCAT::Utils->isMN())
{
# read the site table, master attrib
my $hostname = xCAT::Utils->get_site_Master();
if (($hostname =~ /\d+\.\d+\.\d+\.\d+/) || ($hostname =~ /:/))
{
$name = xCAT::NetworkUtils->gethostname($hostname);
}
else
{
$name = $hostname;
}
}
elsif (xCAT::Utils->isServiceNode())
{
# the myxcatpost_<nodename> file should exist on all nodes!
my $catcmd = "cat /xcatpost/myxcatpost_* | grep '^NODE='";
# - can't use runcmd because this routine is called by runcmd
my $output = `$catcmd`;
if ($::RUNCMD_RC == 0)
{
($junk, $name) = split('=', $output);
}
}
}
if (!$name) {
$name = hostname();
}
my $shorthost;
($shorthost = $name) =~ s/\..*$//;
chomp $shorthost;
return $shorthost;
}
#----------------------------------------------------------------------------
=head3 is_me
returns 1 if the hostname is the node I am running on
Gets all the interfcaes defined on this node and sees if
any of them match the IP of the hostname passed in
Arguments:
none
Returns:
1 - this is the node I am running on
0 - this is not the node I am running on
Globals:
none
Error:
none
Example:
if (xCAT::InstUtils->is_me(&somehostname)) { blah; }
Comments:
none
=cut
#-----------------------------------------------------------------------------
sub is_me
{
my ($class, $name) = @_;
# convert to IP
my $nameIP = xCAT::NetworkUtils->getipaddr($name);
chomp $nameIP;
# split into octets
#my ($b1, $b2, $b3, $b4) = split /\./, $nameIP;
# get all the possible IPs for the node I'm running on
my $ifcmd = "ifconfig -a | grep 'inet'";
my $result = xCAT::Utils->runcmd($ifcmd, 0, 1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
# push @{$rsp->{data}}, "Could not run $ifcmd.\n";
# xCAT::MsgUtils->message("E", $rsp, $callback);
return 0;
}
foreach my $int (@$result)
{
my ($inet, $myIP, $str) = split(" ", $int);
chomp $myIP;
$myIP =~ s/\/.*//; # ipv6 address 4000::99/64
$myIP =~ s/\%.*//; # ipv6 address ::1%1/128
if ($myIP eq $nameIP)
{
return 1;
}
}
return 0;
}
#----------------------------------------------------------------------------
=head3 get_nim_attrs
Use the lsnim command to get the NIM attributes and values of
a resource.
Arguments:
Returns:
hash ref - OK
undef - error
Globals:
Error:
Example:
$attrvals = xCAT::InstUtils->
get_nim_attrs($res, $callback, $nimprime, $subreq);
Comments:
=cut
#-----------------------------------------------------------------------------
sub get_nim_attrs
{
my $class = shift;
my $resname = shift;
my $callback = shift;
my $target = shift;
my $sub_req = shift;
my %attrvals = undef;
if (!$target)
{
$target = xCAT::InstUtils->getnimprime();
}
chomp $target;
my $cmd = "/usr/sbin/lsnim -l $resname 2>/dev/null";
my @nout = xCAT::InstUtils->xcmd($callback, $sub_req, "xdsh", $target, $cmd, 1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not run lsnim command: \'$cmd\'.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return undef;
}
foreach my $line (@nout) {
chomp $line;
my $junk;
my $attrval;
if ($line =~ /.*$target:(.*)/) {
($junk, $attrval) = split(/:/, $line);
} else {
$attrval = $line;
}
if ($attrval =~ /=/) {
my ($attr, $val) = $attrval =~ /^\s*(\S+?)\s*=\s*(\S*.*)$/;
if ($attr && $val) {
# $attrvals{$resname}{$attr} = $val;
$attrvals{$attr} = $val;
}
}
}
if (%attrvals) {
return \%attrvals;
} else {
return undef;
}
}
#----------------------------------------------------------------------------
=head3 get_nim_attr_val
Use the lsnim command to find the value of a resource attribute.
Arguments:
Returns:
0 - OK
1 - error
Globals:
Error:
Example:
xCAT::InstUtils->get_nim_attr_val
Comments:
=cut
#-----------------------------------------------------------------------------
sub get_nim_attr_val
{
my $class = shift;
my $resname = shift;
my $attrname = shift;
my $callback = shift;
my $target = shift;
my $sub_req = shift;
if (!$target)
{
$target = xCAT::InstUtils->getnimprime();
}
chomp $target;
my $cmd = "/usr/sbin/lsnim -a $attrname -Z $resname 2>/dev/null";
my $nout =
xCAT::InstUtils->xcmd($callback, $sub_req, "xdsh", $target, $cmd, 0);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not run lsnim command: \'$cmd\'.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return undef;
}
# The command output may have the xdsh prefix "target:"
#my ($junk, $junk, $junk, $loc) = split(/:/, $nout);
#chomp $loc;
my $loc;
if ($nout =~ /.*$resname:(.*):$/)
{
$loc = $1;
}
return $loc;
}
#-------------------------------------------------------------------------------
=head3 xcmd
Run command either locally or on a remote system.
Calls either runcmd or runxcmd and does either xdcp or xdsh.
Arguments:
Returns:
Output of runcmd or runxcmd or undef.
Comments:
ex. xCAT::InstUtils->xcmd($callback, $sub_req, "xdcp", $nimprime, $doarray, $cmd);
=cut
#-------------------------------------------------------------------------------
sub xcmd
{
my $class = shift;
my $callback = shift;
my $sub_req = shift;
my $xdcmd = shift; # xdcp or xdsh
my $target = shift; # the node to run it on
my $cmd = shift; # the actual cmd to run
my $doarray = shift; # should the return be a string or array ptr?
my $returnformat = 0; # default is to return string
my $exitcode = -1; # don't display error
if ($doarray)
{
$returnformat = $doarray;
}
# runxcmd uses global
$::CALLBACK = $callback;
my $output;
if (!ref($target))
{ # must be node name
if (xCAT::InstUtils->is_me($target))
{
$output = xCAT::Utils->runcmd($cmd, $exitcode, $returnformat);
}
else
{
my @snodes;
push(@snodes, $target);
$output =
xCAT::Utils->runxcmd(
{
command => [$xdcmd],
node => \@snodes,
arg => ["-s", $cmd]
},
$sub_req,
$exitcode,
$returnformat
);
}
}
else
{
# it is an array ref
my @snodes;
@snodes = @{$target};
$output =
xCAT::Utils->runxcmd(
{
command => [$xdcmd],
node => \@snodes,
arg => ["-s", $cmd]
},
$sub_req,
$exitcode,
$returnformat
);
}
if ($returnformat == 1)
{
return @$output;
}
else
{
return $output;
}
return undef;
}
#----------------------------------------------------------------------------
=head3 readBNDfile
Get the contents of a NIM installp_bundle file based on the name
of the NIM resource.
=cut
#-----------------------------------------------------------------------------
sub readBNDfile
{
my ($class, $callback, $BNDname, $nimprime, $sub_req) = @_;
my $junk;
my @pkglist, my $pkgname;
# get the location of the file from the NIM resource definition
my $bnd_file_name =
xCAT::InstUtils->get_nim_attr_val($BNDname, 'location', $callback,
$nimprime, $sub_req);
# The boundle file may be on nimprime
my $ccmd = qq~cat $bnd_file_name~;
my $output=xCAT::InstUtils->xcmd($callback, $sub_req, "xdsh", $nimprime, $ccmd, 0);
if ($::RUNCMD_RC != 0) {
my $rsp;
push @{$rsp->{data}}, "Command: $ccmd failed.";
xCAT::MsgUtils->message("E", $rsp, $callback);
}
# get the names of the packages
#$output =~ s/$nimprime:\s+//g;
foreach my $line (split(/\n/, $output))
{
#May include xdsh prefix $nimprime:
$line =~ s/$nimprime:\s+//;
# skip blank and comment lines
next if ($line =~ /^\s*$/ || $line =~ /^\s*#/);
push(@pkglist, $line);
}
return (0, \@pkglist, $bnd_file_name);
}
#----------------------------------------------------------------------------
=head3 restore_request
Restores an xcatd request from a remote management server
into the proper format by removing arrays that were added by
XML and removing tags that were added to numeric hash keys.
Arguments:
Returns:
ptr to hash
undef
Globals:
Example:
Comments:
=cut
#-----------------------------------------------------------------------------
sub restore_request
{
my $class = shift;
my $in_struct = shift;
my $callback = shift;
my $out_struct;
if (ref($in_struct) eq "ARRAY")
{
# flatten the array it it has only one element
# otherwise leave it alone
if (scalar(@$in_struct) == 1)
{
return (xCAT::InstUtils->restore_request($in_struct->[0]));
}
else
{
return ($in_struct);
}
}
if (ref($in_struct) eq "HASH")
{
foreach my $struct_key (keys %{$in_struct})
{
my $stripped_key = $struct_key;
$stripped_key =~ s/^xxXCATxx(\d)/$1/;
# do not flatten the arg or node arrays
if (($stripped_key =~ /^arg$/) || ($stripped_key =~ /^node$/))
{
$out_struct->{$stripped_key} = $in_struct->{$struct_key};
}
else
{
$out_struct->{$stripped_key} =
xCAT::InstUtils->restore_request($in_struct->{$struct_key});
}
}
return $out_struct;
}
if ((ref($in_struct) eq "SCALAR") || (ref(\$in_struct) eq "SCALAR"))
{
return ($in_struct);
}
print "Unsupported data reference in restore_request().\n";
return undef;
}
#----------------------------------------------------------------------------
=head3 taghash
Add a non-numeric tag to any hash keys that are numeric.
Arguments:
Returns:
0 - OK
1 - error
Globals:
Example:
Comments:
XML will choke on numeric values. This happens when including
a hash in a request to a remote service node.
=cut
#-----------------------------------------------------------------------
sub taghash
{
my ($class, $hash) = @_;
if (ref($hash) eq "HASH")
{
foreach my $k (keys %{$hash})
{
if ($k =~ /^(\d)./)
{
my $tagged_key = "xxXCATxx" . $k;
$hash->{$tagged_key} = $hash->{$k};
delete($hash->{$k});
}
}
return 0;
}
else
{
return 1;
}
}
#-------------------------------------------------------------------------------
=head3 getOSnodes
Split a noderange into arrays of AIX and Linux nodes.
Arguments:
\@noderange - reference to onde list array
Returns:
$rc -
1 - yes, all the nodes are AIX
0 - no, at least one node is not AIX
\@aixnodes - ref to array of AIX nodes
\@linuxnodes - ref to array of Linux nodes
Comments:
Based on "os" attr of node definition. If attr is not set,
defaults to OS of current system.
Example:
my ($rc, $AIXnodes, $Linuxnodes)
= xCAT::InstUtils->getOSnodes(\@noderange)
=cut
#-------------------------------------------------------------------------------
sub getOSnodes
{
my ($class, $nodes) = @_;
my @nodelist = @$nodes;
my $rc = 1; # all AIX nodes
my @aixnodes;
my @linuxnodes;
my $nodetab = xCAT::Table->new('nodetype');
my $os = $nodetab->getNodesAttribs(\@nodelist, ['node', 'os']);
foreach my $n (@nodelist)
{
my $osname;
if (defined($os->{$n}->[0]->{os})) {
$osname = $os->{$n}->[0]->{os};
} else {
$osname = $^O;
}
if (($osname ne "AIX") && ($osname ne "aix"))
{
push(@linuxnodes, $n);
$rc = 0;
}
else
{
push(@aixnodes, $n);
}
}
$nodetab->close;
return ($rc, \@aixnodes, \@linuxnodes);
}
#-------------------------------------------------------------------------------
=head3 get_server_nodes
Determines the server node names as known by a lists of nodes.
Arguments:
A list of node names.
Returns:
A hash ref of arrays, the key is the service node pointing to
an array of nodes that are serviced by that service node
Example
my %servernodes = &get_server_nodes($callback, \@$AIXnodes);
Comments:
- Code runs on MN or SNs
=cut
#-------------------------------------------------------------------------------
sub get_server_nodes
{
my $class = shift;
my $callback = shift;
my $nodes = shift;
my @nodelist;
if ($nodes)
{
@nodelist = @$nodes;
}
#
# get the server name for each node - as known by node
#
my $noderestab = xCAT::Table->new('noderes');
my $xcatmasters = $noderestab->getNodesAttribs(\@nodelist, ['node', 'xcatmaster']);
$noderestab->close;
my %servernodes;
foreach my $node (@nodelist)
{
my $serv;
if ($xcatmasters->{$node}->[0]->{xcatmaster})
{
# get ip of node xcatmaster attribute
my $xcatmaster = $xcatmasters->{$node}->[0]->{xcatmaster};
$serv = xCAT::NetworkUtils->getipaddr($xcatmaster);
}
else
{
# get ip facing node
$serv = xCAT::Utils->my_ip_facing($node);
}
chomp $serv;
if (xCAT::Utils->validate_ip($serv)) {
push (@{$servernodes{$serv}}, $node);
}
}
return \%servernodes;
}
#----------------------------------------------------------------------------
=head3 dolitesetup
Update a spot with the statelite configuration
Arguments:
Returns:
0 - OK
1 - error
Globals:
Example:
Comments:
=cut
#-----------------------------------------------------------------------
sub dolitesetup
{
my $class = shift;
my $imagename = shift;
my $imagehash = shift;
my $nodes = shift;
my $callback = shift;
my $subreq = shift;
my @litefiles; # lists of entries in the litefile table
my %imghash;
if ($imagehash)
{
%imghash = %$imagehash;
}
my @nodelist;
my @nodel;
my @nl;
if ($nodes) {
@nl = @$nodes;
foreach my $n (@nl) {
push(@nodel, xCAT::NodeRange::noderange($n));
}
}
#
# Need to set the "provmethod" attr of the node defs or the litetree
# cmd wil not get the info we need
#
my %nodeattrs;
foreach my $node (@nodel)
{
chomp $node;
$nodeattrs{$node}{objtype} = 'node';
$nodeattrs{$node}{os} = "AIX";
$nodeattrs{$node}{profile} = $imagename;
$nodeattrs{$node}{provmethod} = $imagename;
}
if (xCAT::DBobjUtils->setobjdefs(\%nodeattrs) != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not set the \'provmethod\' attribute for nodes.\n";
xCAT::MsgUtils->message("W", $rsp, $::callback);
}
# the node list is always "all" nodes. There is only one version of the
# statelite, litefile and litetree files in an image and these files
# must always contain all the info from the corresponding database
# table.
@nodelist= xCAT::DBobjUtils->getObjectsOfType('node');
my $noderange;
if (scalar(@nodelist) > 0)
{
$noderange = join(',',@nodelist);
} else {
my $rsp;
push @{$rsp->{data}}, "Could not get list of xCAT nodes. No statelite configuration will be done.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 2;
}
# get spot inst_root loc
my $spotloc = xCAT::InstUtils->get_nim_attr_val($imghash{$imagename}{spot}, 'location', $callback, "", $subreq);
my $instrootloc = $spotloc . "/lpp/bos/inst_root";
# get the statelite info - put each table into it's own file
my $statelitetab = xCAT::Table->new('statelite', -create=>1);
my $litefiletab = xCAT::Table->new('litefile');
my $litetreetab = xCAT::Table->new('litetree');
# these will wind up in the root dir on the node ("/")
my $statelitetable = "$instrootloc/statelite.table";
my $litefiletable = "$instrootloc/litefile.table";
my $litetreetable = "$instrootloc/litetree.table";
# get rid of any old files
if (-e $statelitetable) {
my $rc = xCAT::Utils->runcmd("rm $statelitetable", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not remove existing $statelitetable file.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
if (-e $litefiletable) {
my $rc = xCAT::Utils->runcmd("rm $litefiletable", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not remove existing $litefiletable file.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
if (-e $litetreetab) {
my $rc = xCAT::Utils->runcmd("rm $litetreetab", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not remove existing $litetreetab file.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
#
# create files for each statelite table. add them to the SPOT.
# use the "|" as a separator, remove all blanks from the entries.
# put them in $instrootloc location. they will be available as soon
# as the root dir is mounted during the boot process.
my $foundstatelite=0;
unless (open(STATELITE, ">$statelitetable"))
{
my $rsp;
push @{$rsp->{data}}, "Could not open $statelitetable.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
#
# Check the statelite table for duplicate node entries
#
my $recs=$statelitetab->getAllEntries();
my @SLnodes;
foreach my $entry (@$recs) {
# get the "node" value
my $node = $entry->{node};
# run it through noderange
my @newnodes = xCAT::NodeRange::noderange($node);
# for each node - see if it's already in the list
foreach my $n (@newnodes) {
if (!grep (/^$n$/, @SLnodes) ) {
push(@SLnodes, $n);
} else {
# if it's already in the list then this is an error
my $rsp;
push @{$rsp->{data}}, "The node \'$n\' is included in multiple statelite entries.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
}
# create the statelite table file
my $stateHash = $statelitetab->getNodesAttribs(\@nodelist, ['statemnt']);
foreach my $node (@nodelist) {
# process statelite entry
# add line to file for each node
# note: if statement is xcatmn:/nodedata
# /nodedata is mounted to /.statelite/persistent
# then - on node - a nodename subdir is created
my $statemnt="";
if (exists($stateHash->{$node})) {
$statemnt = $stateHash->{$node}->[0]->{statemnt};
my ($server, $dir) = split(/:/, $statemnt);
#if server is blank, then its the directory
unless($dir) {
$dir = $server;
$server = '';
}
$dir = xCAT::SvrUtils->subVars($dir, $node, 'dir', $callback);
$dir =~ s/\/\//\//g;
if($server) {
$server = xCAT::SvrUtils->subVars($server, $node, 'server', $callback);
$server =~ s/\///g; # remove "/" - bug in subVars??
my $serverIP = xCAT::NetworkUtils->getipaddr($server);
$statemnt = $serverIP . "|" . $dir;
} else {
$statemnt = $dir;
}
}
my $entry = qq~$node|$statemnt~;
$entry =~ s/\s*//g; #remove blanks
if ($statemnt) {
print STATELITE $entry . "\n";
}
}
close(STATELITE);
unless (open(LITEFILE, ">$litefiletable"))
{
my $rsp;
push @{$rsp->{data}}, "Could not open $litefiletable.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
my @filelist = xCAT::Utils->runcmd("/opt/xcat/bin/litefile $noderange", -1);
foreach my $l (@filelist) {
$l =~ s/://g; # remove ":"'s
$l =~ s/\s+/|/g; # change separator to "|"
print LITEFILE $l . "\n";
push (@litefiles, $l);
$foundstatelite++;
}
close(LITEFILE);
unless (open(LITETREE, ">$litetreetable"))
{
my $rsp;
push @{$rsp->{data}}, "Could not open $litetreetable.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
my @treelist = xCAT::Utils->runcmd("/opt/xcat/bin/litetree $noderange", -1);
foreach my $l (@treelist) {
my ($p, $serv, $dir) = split (/:/, $l);
$p =~ s/\s*//g;
$serv =~ s/\s*//g;
$dir =~ s/\s*//g;
my $serverIP = xCAT::NetworkUtils->getipaddr($serv);
my $entry = "$p|$serverIP|$dir";
print LITETREE $entry . "\n";
$foundstatelite++;
}
close(LITETREE);
# if there is no statelite info then just return
if (!$foundstatelite) {
if ($::VERBOSE)
{
my $rsp;
push @{$rsp->{data}}, "Please update statlite,litefile,litetree tables if you want to use AIX statelite support.\n";
xCAT::MsgUtils->message("I", $rsp, $callback);
}
return 2;
}
#
# ok - do more statelite setup
#
# create some local directories in the SPOT
# create .default, .statelite,
if ( ! -d "$instrootloc/.default" ) {
my $mcmd = qq~/bin/mkdir -m 644 -p $instrootloc/.default ~;
my $output = xCAT::Utils->runcmd("$mcmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not create $instrootloc/.default.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
if ( ! -d "$instrootloc/.statelite" ) {
my $mcmd = qq~/bin/mkdir -m 644 -p $instrootloc/.statelite ~;
my $output = xCAT::Utils->runcmd("$mcmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not create $instrootloc/.statelite.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
# populate the .defaults dir with files and dirs from the image - if any
my $default="$instrootloc/.default";
# read the litefile and try to copy into $default
# everything in the litefile command output should be processed
foreach my $line (@litefiles) {
# $file could be full path file name or dir name
# ex. /foo/bar/ or /etc/lppcfg
my ($node, $option, $file) = split (/\|/, $line);
# ex. .../inst_root/foo/bar/ or .../inst_root/etc/lppcfg
my $instrootfile = $instrootloc . $file;
# there's one scenario to be handled firstly
# in litefile table, there's one entry: /path/to/file, which is one file
# however, there's already one directory named "/path/to/file/"
#
# Or:
# the entry in litefile is "/path/to/file/", which is one directory
# however, there's already one file named "/path/to/file"
#
# in these cases,
# need to indicate the user there's already one existing file/directory in the spot
# then, exit
if ($file =~ m/\/$/ and -f $instrootfile) {
my $rsp;
push @{$rsp->{data}}, qq{there is already one file named "$file", but the entry in litefile table is set to one directory, please check it};
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
if ($file !~ m/\/$/ and -d $instrootfile) {
my $rsp;
push @{$rsp->{data}}, qq{there is already one directory named "$file", but the entry in litefile table is set to one file, please check it};
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
my @copiedfiles;
foreach my $line (@litefiles) {
# $file could be full path file name or dir name
# ex. /foo/bar/ or /etc/lppcfg
my ($node, $option, $file) = split (/\|/, $line);
# entry must be an absolute path
unless ($file =~ m{^/}) {
my $rsp;
push @{$rsp->{data}}, "The litefile entry \'$file\' is not an absolute path name.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
# ex. /foo or /etc
my $filedir = dirname($file);
# ex. .../inst_root/foo/bar/ or .../inst_root/etc/lppcfg
my $instrootfile = $instrootloc . $file;
my $cpcmd;
my $mkdircmd;
my $output;
if (!grep (/^$instrootfile$/, @copiedfiles)) {
# don't copy same file twice
push (@copiedfiles, $instrootfile);
if (-e $instrootfile) {
if (-d $instrootfile) {
# it's a dir so copy everything in it
# ex. mkdir -p ../inst_root/.default/foo/bar
# ex. cp -r .../inst_root/foo/bar/ ../inst_root/.default/foo/bar
if ( ! -e "$default$file" ) { # do mkdir
$mkdircmd = qq~mkdir -p $default$file 2>/dev/null~;
$output = xCAT::Utils->runcmd("$mkdircmd", -1);
if ($::RUNCMD_RC != 0) {
my $rsp;
push @{$rsp->{data}}, "Could not copy create $default$file.";
if ($::VERBOSE)
{
push @{$rsp->{data}}, "$output\n";
}
xCAT::MsgUtils->message("E", $rsp, $callback);
}
}
# ok - do copy
$cpcmd = qq~cp -p -r $instrootfile* $default$file 2>/dev/null~;
$output = xCAT::Utils->runcmd("$cpcmd", -1);
} else {
# copy file
# ex. mkdir -p ../inst_root/.default/etc
# ex. cp .../inst_root/etc/lppcfg ../inst_root/.default/etc
$cpcmd = qq~mkdir -p $default$filedir; cp -p $instrootfile $default$filedir 2>/dev/null~;
$output = xCAT::Utils->runcmd("$cpcmd", -1);
}
} else {
# could not find file or dir in ../inst_root (spot dir)
# so create empty file or dir
my $mkcmd;
# check if it's a dir
if(grep /\/$/, $file) {
# create dir in .default
if ( ! -d "$default$file" ) {
$mkcmd = qq~mkdir -p $default$file~;
$output = xCAT::Utils->runcmd("$mkcmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not create $default$file.\n";
if ($::VERBOSE)
{
push @{$rsp->{data}}, "$output\n";
}
}
}
} else {
# create dir and touch file in .default
my $dir = dirname($file);
if ( ! -d "$default$dir" ) {
$mkcmd = qq~mkdir -p $default$dir~;
$output = xCAT::Utils->runcmd("$mkcmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not create $default$dir.";
if ($::VERBOSE)
{
push @{$rsp->{data}}, "$output\n";
}
}
}
# touch the file
my $tcmd = qq~touch $default$file~;
$output = xCAT::Utils->runcmd("$tcmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not create $default$file.\n";
if ($::VERBOSE)
{
push @{$rsp->{data}}, "$output\n";
}
xCAT::MsgUtils->message("E", $rsp, $callback);
}
}
} # end - if not exist in spot
} # end - if not already copied
} # end - for each line in litefile
# add aixlitesetup to ..inst_root/aixlitesetup
# this will wind up in the root dir on the node ("/")
my $install_dir = xCAT::Utils->getInstallDir();
my $cpcmd = "/bin/cp $install_dir/postscripts/aixlitesetup $instrootloc/aixlitesetup; chmod +x $instrootloc/aixlitesetup";
my $out = xCAT::Utils->runcmd("$cpcmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not copy aixlitesetup.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
# if this is an update then we need to copy the new files to
# the shared_root location
# ??? - maybe we should try this all the time????
if (1) {
# if we have a shared_root resource
if ($imghash{$imagename}{shared_root} ) {
my $nimprime = xCAT::InstUtils->getnimprime();
chomp $nimprime;
# get the location of the shared_root directory
my $SRloc = xCAT::InstUtils->get_nim_attr_val($imghash{$imagename}{shared_root}, 'location', $callback, $nimprime, $subreq);
# copy the statelite table file to the shared root location
# this will not effect any running nodes that are using
# this shared_root resource. However the new table will
# include any info need for existing nodes - for when they
# need to be rebooted
if (-d $SRloc) {
my $ccmd = "/bin/cp $statelitetable $litefiletable $litetreetable $instrootloc/aixlitesetup $SRloc";
my $out = xCAT::Utils->runcmd("$ccmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not copy statelite files to $SRloc.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
# also copy $instrootloc/.default contents
$ccmd = "/usr/bin/cp -p -r $instrootloc/.default $SRloc";
$out = xCAT::Utils->runcmd("$ccmd", -1);
if ($::RUNCMD_RC != 0)
{
my $rsp;
push @{$rsp->{data}}, "Could not copy $instrootloc/.default to $SRloc.";
xCAT::MsgUtils->message("E", $rsp, $callback);
return 1;
}
}
}
}
return 0;
}
1;
Reference in New Issue View Git Blame Copy Permalink