476 lines
16 KiB
Perl
476 lines
16 KiB
Perl
package xCAT_plugin::genimage;
|
|
BEGIN
|
|
{
|
|
$::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
|
|
}
|
|
use lib "$::XCATROOT/lib/perl";
|
|
use xCAT::Utils;
|
|
use xCAT::TableUtils;
|
|
use xCAT::SvrUtils;
|
|
use xCAT::Table;
|
|
#use Data::Dumper;
|
|
use File::Path;
|
|
use File::Copy;
|
|
use Getopt::Long;
|
|
Getopt::Long::Configure("bundling");
|
|
Getopt::Long::Configure("pass_through");
|
|
|
|
|
|
sub handled_commands {
|
|
return {
|
|
genimage => "genimage",
|
|
saveimgdata => "genimage",
|
|
}
|
|
}
|
|
|
|
sub process_request {
|
|
my $request = shift;
|
|
my $callback = shift;
|
|
my $doreq = shift;
|
|
my $command = $request->{command}->[0];
|
|
|
|
@ARGV = @{$request->{arg}};
|
|
|
|
#saveimg
|
|
if ($command eq "saveimgdata") { #it is called by /opt/xcat/bin/genimage with interactive mode
|
|
my $tempfile1=$ARGV[0];
|
|
return save_image_data($callback, $doreq, $tempfile1);
|
|
}
|
|
|
|
#my $rsp;
|
|
#$rsp->{data}->[0]="genimage plugin gets called with ARGV=@ARGV" ;
|
|
#$callback->($rsp);
|
|
|
|
#now handle genimage
|
|
my $installroot = "/install";
|
|
$installroot = xCAT::TableUtils->getInstallDir();
|
|
my $prinic; #TODO be flexible on node primary nic
|
|
my $othernics; #TODO be flexible on node primary nic
|
|
my $netdriver;
|
|
my $arch;
|
|
my $profile;
|
|
my $osver;
|
|
my $rootlimit;
|
|
my $tmplimit;
|
|
my $kerneldir;
|
|
my $kernelver = "";
|
|
my $imagename;
|
|
my $pkglist;
|
|
my $srcdir;
|
|
my $destdir;
|
|
my $srcdir_otherpkgs;
|
|
my $otherpkglist;
|
|
my $postinstall_filename;
|
|
my $rootimg_dir;
|
|
my $mode;
|
|
my $permission; #the permission works only for statelite mode currently
|
|
my $krpmver;
|
|
my $interactive;
|
|
my $onlyinitrd;
|
|
my $tempfile;
|
|
my $dryrun;
|
|
my $ignorekernelchk;
|
|
my $noupdate;
|
|
|
|
GetOptions(
|
|
'a=s' => \$arch,
|
|
'p=s' => \$profile,
|
|
'o=s' => \$osver,
|
|
'n=s' => \$netdriver,
|
|
'i=s' => \$prinic,
|
|
'r=s' => \$othernics,
|
|
'l=s' => \$rootlimit,
|
|
't=s' => \$tmplimit,
|
|
'k=s' => \$kernelver,
|
|
'g=s' => \$krpmver,
|
|
'm=s' => \$mode,
|
|
'kerneldir=s' => \$kerneldir,
|
|
'permission=s' => \$permission,
|
|
'interactive' => \$interactive,
|
|
'onlyinitrd' => \$onlyinitrd,
|
|
'tempfile=s' => \$tempfile,
|
|
'dryrun' => \$dryrun,
|
|
'ignorekernelchk' => \$ignorekernelchk,
|
|
'noupdate' => \$noupdate,
|
|
);
|
|
|
|
my $osimagetab;
|
|
my $linuximagetab;
|
|
my $ref_linuximage_tab;
|
|
my $ref_osimage_tab;
|
|
my %keyhash = ();
|
|
my %updates_os = (); # the hash for updating osimage table
|
|
my %updates_linux = (); # the hash for updating linuximage table
|
|
|
|
#always save the input values to the db
|
|
if ($arch) { $updates_os{'osarch'}=$arch; }
|
|
if ($profile) { $updates_os{'profile'} = $profile; }
|
|
if ($osver) { $updates_os{'osvers'} = $osver; }
|
|
|
|
if ($netdriver) { $updates_linux{'netdrivers'} = $netdriver; }
|
|
if ($prinic) { $updates_linux{'nodebootif'} = $prinic; }
|
|
if ($othernics) { $updates_linux{'otherifce'} = $othernics; }
|
|
if ($kernelver) { $updates_linux{'kernelver'} = $kernelver; }
|
|
if ($krpmver) { $updates_linux{'krpmver'} = $krpmver; }
|
|
if ($kerneldir) { $updates_linux{'kerneldir'} = $kerneldir; }
|
|
if ($permission){ $updates_linux{'permission'} = $permission; }
|
|
|
|
# get the info from the osimage and linuximage table
|
|
$osimagetab = xCAT::Table->new('osimage', -create=>1);
|
|
unless ($osimagetab) {
|
|
$callback->({error=>["The osimage table cannot be open."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
$linuximagetab = xCAT::Table->new('linuximage', -create=>1);
|
|
unless($linuximagetab) {
|
|
$callback->({error=>["The linuximage table cannot be open."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
|
|
if (@ARGV > 0) {
|
|
$imagename=$ARGV[0];
|
|
if ($arch or $osver or $profile) {
|
|
$callback->({error=>["-o, -p and -a options are not allowed when a image name is specified."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
(my $ref_osimage_tab) = $osimagetab->getAttribs({imagename => $imagename}, 'osvers', 'osarch', 'profile', 'provmethod');
|
|
unless ($ref_osimage_tab) {
|
|
$callback->({error=>["Cannot find image \'$imagename\' from the osimage table."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
(my $ref_linuximage_tab) = $linuximagetab->getAttribs({imagename => $imagename}, 'pkglist', 'pkgdir', 'otherpkglist', 'otherpkgdir', 'postinstall', 'rootimgdir', 'kerneldir', 'krpmver', 'nodebootif', 'otherifce', 'kernelver', 'netdrivers', 'permission','driverupdatesrc');
|
|
unless ($ref_linuximage_tab) {
|
|
$callback->({error=>["Cannot find $imagename from the linuximage table."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
$osver=$ref_osimage_tab->{'osvers'};
|
|
$arch=$ref_osimage_tab->{'osarch'};
|
|
$profile=$ref_osimage_tab->{'profile'};
|
|
my $provmethod=$ref_osimage_tab->{'provmethod'}; # TODO: not necessary, and need to update both statelite and stateless modes
|
|
|
|
unless ($osver and $arch and $profile and $provmethod) {
|
|
$callback->({error=>["osimage.osvers, osimage.osarch, osimage.profile and osimage.provmethod must be specified for the image $imagename in the database."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
unless ($provmethod eq 'netboot' || $provmethod eq 'statelite') {
|
|
$callback->({error=>["\'$imagename\' cannot be used to build diskless image. Make sure osimage.provmethod is 'netboot'."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
unless ( $ref_linuximage_tab->{'pkglist'}) {
|
|
$callback->({error=>["A .pkglist file must be specified for image \'$imagename\' in the linuximage table."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
$pkglist = $ref_linuximage_tab->{'pkglist'};
|
|
|
|
$srcdir = $ref_linuximage_tab->{'pkgdir'};
|
|
$srcdir_otherpkgs = $ref_linuximage_tab->{'otherpkgdir'};
|
|
$otherpkglist = $ref_linuximage_tab->{'otherpkglist'};
|
|
$postinstall_filename = $ref_linuximage_tab->{'postinstall'};
|
|
$destdir = $ref_linuximage_tab->{'rootimgdir'};
|
|
$rootimg_dir = $ref_linuximage_tab->{'rootimgdir'};
|
|
$driverupdatesrc = $ref_linuximage_tab->{'driverupdatesrc'};
|
|
|
|
# TODO: how can we do if the user specifies one wrong value to the following attributes?
|
|
# currently, one message is output to indicate the users there will be some updates
|
|
|
|
if ($prinic) {
|
|
if ($prinic ne $ref_linuximage_tab->{'nodebootif'}) {
|
|
$callback->({info=>["The primary nic is different from the value in linuximage table, will update it."]});
|
|
$updates{'nodebootif'} = $prinic;
|
|
}
|
|
} else {
|
|
$prinic = $ref_linuximage_tab->{'nodebootif'};
|
|
}
|
|
if ($othernics) {
|
|
if ($othernics ne $ref_linuximage_tab->{'otherifce'}) {
|
|
$callback->({info=>["The other ifces are different from the value in linuximage table, will update it."]});
|
|
$updates{'otherifce'} = $othernics;
|
|
}
|
|
} else {
|
|
$othernics = $ref_linuximage_tab->{'otherifce'};
|
|
}
|
|
if ($kernelver) {
|
|
if ($kernelver ne $ref_linuximage_tab->{'kernelver'}) {
|
|
$callback->({info=>["The kernelver is different from the value in linuximage table, will update it."]});
|
|
$updates{'kernelver'} = $kernelver;
|
|
}
|
|
} else {
|
|
$kernelver = $ref_linuximage_tab->{'kernelver'};
|
|
}
|
|
|
|
if ($krpmver) {
|
|
if ($krpmver ne $ref_linuximage_tab->{'krpmver'}) {
|
|
$callback->({info=>["The krpmver is different from the value in linuximage table, will update it."]});
|
|
$updates{'krpmver'} = $krpmver;
|
|
}
|
|
} else {
|
|
$krpmver = $ref_linuximage_tab->{'krpmver'};
|
|
}
|
|
|
|
if ($kerneldir) {
|
|
if ($kerneldir ne $ref_linuximage_tab->{'kerneldir'}) {
|
|
print "The kerneldir is different from the value in linuximage table, will update it\n";
|
|
$updates{'kerneldir'} = $kerneldir;
|
|
}
|
|
} else {
|
|
$kerneldir = $ref_linuximage_tab->{'kerneldir'};
|
|
}
|
|
if ($netdriver) {
|
|
if ($netdriver ne $ref_linuximage_tab->{'netdrivers'}) {
|
|
$callback->({info=>["The netdrivers is different from the value in linuximage table, will update it."]});
|
|
$updates{'netdrivers'} = $netdriver;
|
|
}
|
|
} else {
|
|
$netdriver = $ref_linuximage_tab->{'netdrivers'};
|
|
}
|
|
|
|
if ($permission) {
|
|
if ($permission ne $ref_linuximage_tab->{'permission'}) {
|
|
$callback->({info=>["The permission is different from the value in linuximage table, will update it."]});
|
|
$updates{'permission'} = $permission;
|
|
}
|
|
} else {
|
|
$permission = $ref_linuximage_tab->{'permission'};
|
|
}
|
|
}
|
|
|
|
|
|
### Get the Profile ####
|
|
my $osfamily = $osver;
|
|
$osfamily =~ s/\d+//g;
|
|
$osfamily =~ s/\.//g;
|
|
if($osfamily =~ /rh/){
|
|
$osfamily = "rh";
|
|
}
|
|
|
|
# OS version on s390x can contain 'sp', e.g. sles11sp1
|
|
# If the $osfamily contains 'sles' and 'sp', the $osfamily = sles
|
|
if ($osfamily =~ /sles/ && $osfamily =~ /sp/) {
|
|
$osfamily = "sles";
|
|
}
|
|
|
|
$osfamily =~ s/ //g;
|
|
|
|
#-m flag is used only for ubuntu, debian and ferdora12, for others genimage will create
|
|
#initrd.gz for both netboot and statelite, no -m is needed.
|
|
if ($mode) {
|
|
if (($osfamily ne "ubuntu") && ($osfamily ne "debian") && ($osver !~ /fedora12/)) {
|
|
$mode="";
|
|
$callback->({error=>["-m flag is valid for Ubuntu, Debian and Fedora12 only."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
$profDir = "$::XCATROOT/share/xcat/netboot/$osfamily";
|
|
unless(-d $profDir){
|
|
$callback->({error=>["Unable to find genimage script in $profDir."],errorcode=>[1]});
|
|
return 1;
|
|
}
|
|
|
|
my $cmd="cd $profDir; ./genimage";
|
|
if ($arch) { $cmd .= " -a $arch";}
|
|
if ($osver) { $cmd .= " -o $osver";}
|
|
if ($profile) { $cmd .= " -p $profile";}
|
|
|
|
if ($netdriver) { $cmd .= " -n $netdriver";}
|
|
if ($prinic) { $cmd .= " -i $prinic";}
|
|
if ($othernics) { $cmd .= " -r $othernics";}
|
|
if ($rootlimit) { $cmd .= " -l $rootlimit";}
|
|
if ($tmplimit) { $cmd .= " -t $tmplimit";}
|
|
if ($kernelver) { $cmd .= " -k $kernelver";}
|
|
if ($krpmver) { $cmd .= " -g $krpmver";}
|
|
if ($mode) { $cmd .= " -m $mode";}
|
|
if ($permission) { $cmd .= " --permission $permission"; }
|
|
if ($kerneldir) { $cmd .= " --kerneldir $kerneldir"; }
|
|
if ($interactive) { $cmd .= " --interactive" }
|
|
if ($onlyinitrd) { $cmd .= " --onlyinitrd" }
|
|
|
|
if ($srcdir) { $cmd .= " --srcdir $srcdir";}
|
|
if ($pkglist) { $cmd .= " --pkglist $pkglist";}
|
|
if ($srcdir_otherpkgs) { $cmd .= " --otherpkgdir \"$srcdir_otherpkgs\""; }
|
|
if ($otherpkglist) { $cmd .= " --otherpkglist $otherpkglist"; }
|
|
if ($postinstall_filename) { $cmd .= " --postinstall $postinstall_filename"; }
|
|
if ($destdir) { $cmd .= " --rootimgdir $destdir"; }
|
|
if ($tempfile) {
|
|
if (!$dryrun) { $cmd .= " --tempfile $tempfile"; }
|
|
}
|
|
if ($driverupdatesrc) { $cmd .= " --driverupdatesrc $driverupdatesrc"; }
|
|
if ($ignorekernelchk) { $cmd .= " --ignorekernelchk $ignorekernelchk"; }
|
|
if ($noupdate) { $cmd .= " --noupdate $noupdate"; }
|
|
|
|
if($osfamily eq "sles") {
|
|
my @entries = xCAT::TableUtils->get_site_attribute("timezone");
|
|
my $tz = $entries[0];
|
|
if($tz) { $cmd .= " --timezone $tz"; }
|
|
}
|
|
|
|
if ($imagename) {
|
|
$cmd.= " $imagename";
|
|
}
|
|
|
|
|
|
$callback->({info=>["$cmd"]});
|
|
$::CALLBACK=$callback;
|
|
|
|
if ($tempfile) {
|
|
#first print the command
|
|
open(FILE, ">$tempfile");
|
|
print FILE "$cmd\n\n";
|
|
#then print the update info for osimage and linuximage table
|
|
|
|
if (keys(%updates_os) > 0) {
|
|
print FILE "The output for table updates starts here\n";
|
|
print FILE "table::osimage\n";
|
|
print FILE "imagename::aaaaa_not_known_yet_aaaaa\n"; #special image name
|
|
my @a=%updates_os;
|
|
print FILE join('::',@a) . "\n";
|
|
print FILE "The output for table updates ends here\n";
|
|
}
|
|
|
|
if (keys(%updates_linux) > 0) {
|
|
print FILE "The output for table updates starts here\n";
|
|
print FILE "table::linuximage\n";
|
|
print FILE "imagename::aaaaa_not_known_yet_aaaaa\n"; #special image name
|
|
my @a=%updates_linux;
|
|
print FILE join('::',@a) . "\n";
|
|
print FILE "The output for table updates ends here\n";
|
|
}
|
|
close File;
|
|
} else {
|
|
$callback->({error=>["NO temp file provided to store the genimage command."]});
|
|
return;
|
|
}
|
|
|
|
#it only shows the underlying command without actually running the command
|
|
if ($dryrun) { return; }
|
|
|
|
|
|
if ($interactive) {
|
|
return; #back to the client, client will run
|
|
} else {
|
|
#my $output = xCAT::Utils->runcmd("$cmd", 0, 1); # non-stream
|
|
my $output = xCAT::Utils->runcmd("$cmd", 0, 1, 1); # stream output
|
|
#open(FILE, ">>$tempfile");
|
|
#foreach my $entry (@$output) {
|
|
# print FILE $entry;
|
|
# print FILE "\n";
|
|
#}
|
|
#close FILE;
|
|
|
|
# update the generated initrd to /tftpboot/xcat so that don't need to rerun nodeset to update them
|
|
if (($::RUNCMD_RC == 0) && $imagename) {
|
|
my $tftpdir = "/tftpboot";
|
|
my @siteents = xCAT::TableUtils->get_site_attribute("tftpdir");
|
|
if ($#siteents >= 0)
|
|
{
|
|
$tftpdir = $siteents[0];
|
|
}
|
|
my $tftppath = "$tftpdir/xcat/osimage/$imagename";
|
|
|
|
my $installdir = "/install";
|
|
@siteents = xCAT::TableUtils->get_site_attribute("installdir");
|
|
if ($#siteents >= 0)
|
|
{
|
|
$installdir = $siteents[0];
|
|
}
|
|
|
|
unless (-d $tftppath) {
|
|
mkpath $tftppath;
|
|
}
|
|
copy("$rootimg_dir/initrd-stateless.gz", "$tftppath");
|
|
copy("$rootimg_dir/initrd-statelite.gz", "$tftppath");
|
|
copy("$rootimg_dir/kernel", "$tftppath");
|
|
}
|
|
|
|
#parse the output and save the image data to osimage and linuximage table
|
|
save_image_data($callback, $doreq, $tempfile);
|
|
}
|
|
}
|
|
|
|
sub save_image_data {
|
|
my $callback=shift;
|
|
my $doreq=shift;
|
|
my $filename=shift;
|
|
#updates_os and updates_linux are defined at the top of the given file with imagename::aaaaa_not_known_yet_aaaaa
|
|
my %updates_os=();
|
|
my %updates_linux=();
|
|
|
|
my $cmd="cat $filename";
|
|
my $output = xCAT::Utils->runcmd("$cmd", 0, 1);
|
|
|
|
if ($output && (@$output > 0)) {
|
|
my $i=0;
|
|
while ($i < @$output) {
|
|
if ( $output->[$i] =~ /The output for table updates starts here/) {
|
|
#print "----got here $i\n";
|
|
my $tn;
|
|
my $imgname;
|
|
my %keyhash;
|
|
my %updates;
|
|
my $s1=$output->[$i +1];
|
|
my $s2=$output->[$i +2];
|
|
my $s3=$output->[$i +3];
|
|
if ($s1 =~ /^table::(.*)$/) {
|
|
$tn=$1;
|
|
}
|
|
if ($s2 =~ /^imagename::(.*)$/) {
|
|
$imgname=$1;
|
|
$keyhash{'imagename'} = $imgname;
|
|
}
|
|
|
|
if ($tn eq 'osimage') {
|
|
%updates=%updates_os;
|
|
} elsif ($tn eq 'linuximage') {
|
|
%updates=%updates_linux;
|
|
}
|
|
|
|
|
|
my @a=split("::", $s3);
|
|
for (my $j=0; $j < @a; $j=$j+2) {
|
|
$updates{$a[$j]} = $a[$j+1];
|
|
}
|
|
splice(@$output, $i, 5);
|
|
|
|
if ($imgname eq "aaaaa_not_known_yet_aaaaa") {
|
|
#the file contains updates_os and updates_linux at the begining of the file. So read them out and save the to the variables, do not commit yet because the real image name will be provided later in the file.
|
|
if (($tn) && (keys(%updates) > 0)) {
|
|
if ($tn eq 'osimage') {
|
|
%updates_os=%updates;
|
|
} elsif ($tn eq 'linuximage') {
|
|
%updates_linux=%updates;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
if (($tn) && (keys(%keyhash) > 0) && (keys(%updates) > 0)) {
|
|
my $tab= xCAT::Table->new($tn, -create=>1);
|
|
if ($tab) {
|
|
$tab->setAttribs(\%keyhash, \%updates);
|
|
#print "table=$tn,%keyhash,%updates\n";
|
|
#print "*** keyhash=" . Dumper(%keyhash);
|
|
#print "*** updates=" . Dumper(%updates);
|
|
}
|
|
}
|
|
}
|
|
} else { # if ( $output->[$i] =~ ....)
|
|
$i++;
|
|
}
|
|
} #if ($output && (@$output > 0))
|
|
|
|
# remove tmp file
|
|
#`rm /tmp/genimageoutput`;
|
|
#remove the database upgrade section
|
|
# runcmd_S displays the output
|
|
#$callback->({info=>$output});
|
|
}
|
|
}
|
|
|
|
1;
|