744 lines
22 KiB
Perl
744 lines
22 KiB
Perl
#!/usr/bin/env perl
|
|
# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
|
|
BEGIN
|
|
{
|
|
$::XCATROOT =
|
|
$ENV{'XCATROOT'} ? $ENV{'XCATROOT'}
|
|
: -d '/opt/xcat' ? '/opt/xcat'
|
|
: '/usr';
|
|
}
|
|
use lib "$::XCATROOT/lib/perl";
|
|
use strict;
|
|
use File::Basename;
|
|
use Cwd;
|
|
use Socket;
|
|
|
|
#use Data::Dumper;
|
|
use Getopt::Long;
|
|
require xCAT::MsgUtils;
|
|
require xCAT::DSHCLI;
|
|
use xCAT::Utils;
|
|
use xCAT::TableUtils;
|
|
use xCAT::RemoteShellExp;
|
|
require xCAT::Client;
|
|
my $bname = basename($0);
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
=head1 xdsh/xdcp
|
|
|
|
This program is the client interface for xdsh/xdcp.
|
|
|
|
|
|
xdsh/xdcp command
|
|
|
|
This is the interface to for xdsh/xdsp
|
|
The command can run in client/server mode (default) or in bypass mode
|
|
where it does not use the xcat daemon xcatd.
|
|
Bypass mode is useful, when executing the command on the Management Server
|
|
and in particular if you want to run as a non-root id.
|
|
Call parse_args to verify mode (client/server or bypass)
|
|
and whether to use Env Variables
|
|
Build hash and submit request
|
|
See man page for options
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Main
|
|
|
|
# report unsupported dsh exports
|
|
&check_invalid_exports;
|
|
|
|
my $cmdref;
|
|
my $arg;
|
|
my @SaveARGV = @ARGV;
|
|
$cmdref->{cwd}->[0] = cwd();
|
|
$cmdref->{command}->[0] = $bname; # save my command name
|
|
|
|
my $arg = @SaveARGV[0];
|
|
|
|
if ($arg =~ /^-/) # no noderange
|
|
{
|
|
|
|
# check for help, bypass, other client flags
|
|
if ($bname eq "xdsh")
|
|
{
|
|
&parse_args_xdsh;
|
|
}
|
|
else
|
|
{ # xdcp
|
|
&parse_args_xdcp;
|
|
}
|
|
if ($::ROOTIMG != 1)
|
|
{ # if not running against rootimg then noderange required
|
|
xCAT::MsgUtils->message("I",
|
|
"Node range not specified, see $bname man page for syntax.\n");
|
|
exit 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$cmdref->{noderange}->[0] = $arg; # save noderange
|
|
my $tmp = shift(@SaveARGV); # take if off the argument list
|
|
if (!($cmdref->{noderange}->[0]))
|
|
{
|
|
xCAT::MsgUtils->message("I",
|
|
"Node range not specified, see man page for syntax.\n");
|
|
exit 1;
|
|
}
|
|
@ARGV = @SaveARGV; # noderange removed for parsing
|
|
if ($bname eq "xdsh")
|
|
{
|
|
&parse_args_xdsh($cmdref->{noderange}->[0]);
|
|
}
|
|
else
|
|
{ # xdcp
|
|
&parse_args_xdcp;
|
|
}
|
|
}
|
|
|
|
foreach my $sarg (@SaveARGV)
|
|
{
|
|
push(@{$cmdref->{arg}}, $sarg);
|
|
}
|
|
|
|
# add environment variables, if they have not already been assigned with
|
|
# command line flags
|
|
if (!($::NODE_RSH))
|
|
{
|
|
if ($ENV{'DSH_NODE_RSH'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_NODE_RSH=$ENV{'DSH_NODE_RSH'}");
|
|
|
|
}
|
|
}
|
|
if (!($::NODE_RCP))
|
|
{
|
|
if ($ENV{'DSH_NODE_RCP'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_NODE_RCP=$ENV{'DSH_NODE_RCP'}");
|
|
|
|
}
|
|
}
|
|
if (!($::NODE_OPTS))
|
|
{
|
|
if ($ENV{'DSH_NODE_OPTS'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_NODE_OPTS=$ENV{'DSH_NODE_OPTS'}");
|
|
|
|
}
|
|
}
|
|
if (!($::FANOUT))
|
|
{
|
|
if ($ENV{'DSH_FANOUT'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_FANOUT=$ENV{'DSH_FANOUT'}");
|
|
|
|
}
|
|
}
|
|
if (!($::TIMEOUT))
|
|
{
|
|
if ($ENV{'DSH_TIMEOUT'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_TIMEOUT=$ENV{'DSH_TIMEOUT'}");
|
|
|
|
}
|
|
}
|
|
if ($ENV{'DSH_REMOTE_PASSWORD'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_REMOTE_PASSWORD=$ENV{'DSH_REMOTE_PASSWORD'}");
|
|
}
|
|
|
|
if ($ENV{'DSH_FROM_USERID'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_FROM_USERID=$ENV{'DSH_FROM_USERID'}");
|
|
}
|
|
|
|
if ($ENV{'DSH_TO_USERID'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_TO_USERID=$ENV{'DSH_TO_USERID'}");
|
|
}
|
|
|
|
if ($ENV{'DEVICETYPE'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DEVICETYPE=$ENV{'DEVICETYPE'}");
|
|
}
|
|
|
|
if ($ENV{'DSH_RSYNC_FILE'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_RSYNC_FILE=$ENV{'DSH_RSYNC_FILE'}");
|
|
}
|
|
if ($ENV{'RSYNCSN'})
|
|
{
|
|
push(@{$cmdref->{env}}, "RSYNCSN=$ENV{'RSYNCSN'}");
|
|
}
|
|
if ($ENV{'RSYNCSNONLY'})
|
|
{
|
|
push(@{$cmdref->{env}}, "RSYNCSNONLY=$ENV{'RSYNCSNONLY'}");
|
|
}
|
|
if ($ENV{'DCP_PULL'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DCP_PULL=$ENV{'DCP_PULL'}");
|
|
}
|
|
if ($ENV{'DSHEXECUTE'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSHEXECUTE=$ENV{'DSHEXECUTE'}");
|
|
}
|
|
if ($ENV{'DSH_ENVIRONMENT'})
|
|
{
|
|
push(@{$cmdref->{env}}, "DSH_ENVIRONMENT=$ENV{'DSH_ENVIRONMENT'}");
|
|
}
|
|
|
|
xCAT::Client::submit_request($cmdref, \&xCAT::Client::handle_response);
|
|
exit $xCAT::Client::EXITCODE;
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
=head3 parse_args_xdsh
|
|
|
|
Parses for dsh input
|
|
Check if the command ask for help and display usage
|
|
Need to check only for the -X flag
|
|
Need to check -B flag to determine mode
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub parse_args_xdsh
|
|
{
|
|
my $snodes = shift;
|
|
# test to see if any parameters were entered
|
|
my $arraysize=@ARGV;
|
|
if ($arraysize ==0) {
|
|
my $msg= "No parameters were supplied on the xdsh command. Run xdsh -h";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
exit 1;
|
|
}
|
|
|
|
Getopt::Long::Configure("posix_default");
|
|
Getopt::Long::Configure("no_gnu_compat");
|
|
Getopt::Long::Configure("bundling");
|
|
my %options = ();
|
|
if (
|
|
!GetOptions(
|
|
'e|execute' => \$options{'execute'},
|
|
'f|fanout=i' => \$options{'fanout'},
|
|
'h|help' => \$options{'help'},
|
|
'l|user=s' => \$options{'user'},
|
|
'm|monitor' => \$options{'monitor'},
|
|
'o|node-options=s' => \$options{'node-options'},
|
|
'q|show-config' => \$options{'show-config'},
|
|
'r|node-rsh=s' => \$options{'node-rsh'},
|
|
'i|rootimg=s' => \$options{'rootimg'},
|
|
's|stream' => \$options{'streaming'},
|
|
't|timeout=i' => \$options{'timeout'},
|
|
'v|verify' => \$options{'verify'},
|
|
'z|exit-status' => \$options{'exit-status'},
|
|
'B|bypass' => \$options{'bypass'},
|
|
'c|cleanup' => \$options{'cleanup'},
|
|
'E|environment=s' => \$options{'environment'},
|
|
'I|ignore-sig|ignoresig=s' => \$options{'ignore-signal'},
|
|
'K|keysetup' => \$options{'ssh-setup'},
|
|
'L|no-locale' => \$options{'no-locale'},
|
|
'Q|silent' => \$options{'silent'},
|
|
'S|syntax=s' => \$options{'syntax'},
|
|
'T|trace' => \$options{'trace'},
|
|
'V|version' => \$options{'version'},
|
|
|
|
'devicetype=s' => \$options{'devicetype'},
|
|
'nodestatus|nodestatus' => \$options{'nodestatus'},
|
|
'sudo|sudo' => \$options{'sudo'},
|
|
'command-name|commandName=s' => \$options{'command-name'},
|
|
'command-description|commandDescription=s' =>
|
|
\$options{'command-description'},
|
|
'X:s' => \$options{'ignore_env'}
|
|
|
|
)
|
|
)
|
|
{
|
|
|
|
xCAT::DSHCLI->usage_dsh;
|
|
exit 1;
|
|
}
|
|
if ($options{'help'})
|
|
{
|
|
xCAT::DSHCLI->usage_dsh;
|
|
exit 0;
|
|
}
|
|
|
|
# cleanup the service node temp directory and exit
|
|
# if default to not prompt, if user specified prompt
|
|
if (($options{'cleanup'}) && (!$snodes))
|
|
{
|
|
my $msg = "Service node range must be supplied on the -c command.";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
exit 1;
|
|
|
|
}
|
|
if ($options{'cleanup'})
|
|
{
|
|
|
|
# get the directories on the servicenode to put the files in
|
|
my $defaultsyndir = "/var/xcat/syncfiles";
|
|
my @syndir = xCAT::TableUtils->get_site_attribute("SNsyncfiledir");
|
|
my $synfiledir;
|
|
if ($syndir[0])
|
|
{
|
|
$synfiledir = $syndir[0];
|
|
}
|
|
else
|
|
{
|
|
$synfiledir = "/var/xcat/syncfiles"; # default
|
|
}
|
|
# for append function
|
|
my $defaultnodesyndir = "/var/xcat/node/syncfiles";
|
|
my @syndir2 = xCAT::TableUtils->get_site_attribute("nodesyncfiledir");
|
|
my $synfiledir2;
|
|
if ($syndir2[0])
|
|
{
|
|
$synfiledir2 = $syndir2[0];
|
|
}
|
|
else
|
|
{
|
|
$synfiledir2 = "/var/xcat/node/syncfiles"; # default
|
|
}
|
|
if ($defaultsyndir ne $synfiledir)
|
|
{
|
|
my $answer;
|
|
my $msg =
|
|
"Do you wish to erase $synfiledir,$synfiledir2 and all subdirectories?\n Enter Y or N.";
|
|
xCAT::MsgUtils->message('I', "$msg");
|
|
`stty -echo`;
|
|
chop($answer = <STDIN>);
|
|
`stty echo`;
|
|
$answer =~ tr/a-z/A-Z/; # convert to upper
|
|
if ($answer ne "Y")
|
|
{
|
|
exit 0;
|
|
}
|
|
}
|
|
my $cmd = "xdsh $snodes -v rm -rf $synfiledir/*;xdsh $snodes -v rm -rf $synfiledir2";
|
|
xCAT::Utils->runcmd($cmd, 0);
|
|
if ($::RUNCMD_RC != 0)
|
|
{ # error
|
|
my $msg = "Error from $cmd: to cleanup servicenodes";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
exit 1;
|
|
}
|
|
|
|
exit 0;
|
|
}
|
|
if ($options{'bypass'})
|
|
{
|
|
$ENV{XCATBYPASS} = "yes"; # bypass xcatd
|
|
}
|
|
if ($options{'show-config'})
|
|
{
|
|
xCAT::DSHCLI->show_dsh_config;
|
|
exit 0;
|
|
}
|
|
my $executescript;
|
|
#check for full path to file
|
|
if ($options{execute})
|
|
{
|
|
# this can be a file + parameters
|
|
$executescript = join ' ', @ARGV;
|
|
if ($executescript !~ /^\//) {
|
|
#relative path
|
|
$executescript = xCAT::Utils->full_path($executescript);
|
|
}
|
|
$ENV{'DSHEXECUTE'} = $executescript; # execute script
|
|
}
|
|
# -E <env file> option if not already exported
|
|
|
|
if ($options{environment})
|
|
{
|
|
if (!($ENV{'DSH_ENVIRONMENT'})) { # env variable first
|
|
$ENV{'DSH_ENVIRONMENT'} = $options{environment}; # env file
|
|
}
|
|
}
|
|
|
|
|
|
# find out who is the current user running xdsh
|
|
#my $current_userid = getlogin(); # does not work for su
|
|
my $current_userid = getpwuid($>);
|
|
|
|
$ENV{DSH_FROM_USERID} = $current_userid;
|
|
|
|
# find out who we are going to log on to the node as
|
|
|
|
my $to_userid;
|
|
if ($options{'user'}) # if -l option
|
|
{
|
|
$to_userid = $options{'user'};
|
|
}
|
|
else
|
|
{
|
|
$to_userid = $current_userid;
|
|
}
|
|
$ENV{DSH_TO_USERID} = $to_userid;
|
|
|
|
# if devicetype=Mellanox, xdsh does not setup ssh, rspconfig does
|
|
my $devicepath = $options{'devicetype'};
|
|
$devicepath =~ s/::/\//g;
|
|
if (($options{'ssh-setup'}) && ($devicepath =~ /Mellanox/i)) {
|
|
my $msg =
|
|
"You do not use xdsh -K to setup the Mellanox switch ssh keys. Use rspconfig. See man page for rspconfig option sshcfg={enable|disable}.";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
exit 2;
|
|
}
|
|
# only allow -K with -l if --devicetype defined
|
|
if ( (($options{'user'}) && ($options{'ssh-setup'}))
|
|
&& (!($options{'devicetype'})))
|
|
{
|
|
my $msg =
|
|
"The -K and -l flag may only be used if --devicetype is specified.";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
exit 2;
|
|
}
|
|
if ($options{'ssh-setup'}) # if going to setup ssh keys
|
|
{
|
|
my $msg;
|
|
if (!($ENV{'DSH_REMOTE_PASSWORD'}))
|
|
{ # if not already set
|
|
# prompt for the password for the userid on the node that will be setup
|
|
my $userpw;
|
|
$msg =
|
|
"Enter the password for the userid: $to_userid on the node where the ssh keys \nwill be updated:\n";
|
|
xCAT::MsgUtils->message("I", $msg);
|
|
system("stty -echo"); # turn off keyboard
|
|
chop($userpw = <STDIN>);
|
|
system("stty echo"); # turn on keyboard
|
|
|
|
if ($userpw eq "")
|
|
{ # did not enter a password
|
|
$msg = "Did not enter a password must abort the key exchange";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
exit 2;
|
|
}
|
|
else
|
|
{ # password entered pass to the server
|
|
$ENV{DSH_REMOTE_PASSWORD} = $userpw;
|
|
|
|
}
|
|
}
|
|
|
|
# Get the home directory
|
|
my $home = xCAT::Utils->getHomeDir($current_userid);
|
|
$ENV{'DSH_FROM_USERID_HOME'} = $home;
|
|
#
|
|
# create /.ssh dir if needed
|
|
#
|
|
my $sshdir = "$home/.ssh";
|
|
if (!-d $sshdir)
|
|
{
|
|
my $cmd = "/bin/mkdir -m 700 -p $sshdir";
|
|
my $outref = xCAT::Utils->runcmd("$cmd", 0);
|
|
if ($::RUNCMD_RC != 0)
|
|
{
|
|
xCAT::MsgUtils->message('E', "Could not create $sshdir directory.");
|
|
exit 1;
|
|
}
|
|
}
|
|
|
|
|
|
# add config file with strict host checking no, if not already there
|
|
my $configinfo = "StrictHostKeyChecking no";
|
|
my $configfile= "$home/.ssh/config";
|
|
if (-e $configfile)
|
|
{
|
|
my $cmd = "grep StrictHostKeyChecking $configfile";
|
|
xCAT::Utils->runcmd($cmd, -1);
|
|
if ($::RUNCMD_RC != 0)
|
|
{ # not there
|
|
$cmd = "echo $configinfo >> $configfile";
|
|
my @output = xCAT::Utils->runcmd($cmd, 0);
|
|
if ($::RUNCMD_RC != 0)
|
|
{ # error
|
|
xCAT::MsgUtils->message("E", "Error on $cmd, @output");
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
}
|
|
else # file does not exist
|
|
{
|
|
my $cmd = "echo $configinfo >> $configfile";
|
|
my @output = xCAT::Utils->runcmd($cmd, 0);
|
|
if ($::RUNCMD_RC != 0)
|
|
{ # error
|
|
xCAT::MsgUtils->message("E", "Error on $cmd, @output");
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
chmod 0600, $configfile;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
# if current_userid is not "root", we need to generate the keys
|
|
# here before becoming root while running under xcatd
|
|
#
|
|
if ($current_userid ne "root")
|
|
{
|
|
$::REMOTE_SHELL = "/usr/bin/ssh";
|
|
my $callback = \&xCAT::Client::handle_response;
|
|
# generates new keys for non-root id, if they do not already exist
|
|
my $rc=
|
|
xCAT::RemoteShellExp->remoteshellexp("k",$callback,$::REMOTE_SHELL);
|
|
if ($rc != 0) {
|
|
$msg = "remoteshellexp failed generating keys.";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
}
|
|
|
|
|
|
}
|
|
} # end setup of ssh
|
|
if ($options{'version'})
|
|
{
|
|
my $version = xCAT::Utils->Version();
|
|
$version .= "\n";
|
|
xCAT::MsgUtils->message("N", $version);
|
|
exit 0;
|
|
}
|
|
if ($options{'rootimg'})
|
|
{
|
|
$::ROOTIMG = 1;
|
|
}
|
|
if ($options{'node-rsh'}) # if set on command line, use it
|
|
{
|
|
$::NODE_RSH = 1;
|
|
}
|
|
if ($options{'node-opts'}) # if set on command line, use it
|
|
{
|
|
$::NODE_OPTS = 1;
|
|
}
|
|
if ($options{'fanout'}) # if set on command line, use it
|
|
{
|
|
$::FANOUT = 1;
|
|
}
|
|
if ($options{'timeout'}) # if set on command line, use it
|
|
{
|
|
$::TIMEOUT = 1;
|
|
}
|
|
if (defined $options{'ignore_env'})
|
|
{
|
|
xCAT::DSHCLI->ignoreEnv($options{'ignore_env'});
|
|
}
|
|
|
|
}
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
=head3 parse_args_xdcp
|
|
|
|
Parses for dcp input
|
|
Check if the command ask for help and display usage
|
|
Need to check -X flag to determine how to set Environment Variables
|
|
Need to check -B flag to determine mode
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub parse_args_xdcp
|
|
{
|
|
|
|
my %options = ();
|
|
# test to see if any parameters were entered
|
|
my $arraysize=@ARGV;
|
|
if ($arraysize ==0) {
|
|
my $msg= "No parameters were supplied on the xdcp command. Run xdcp -h";
|
|
xCAT::MsgUtils->message("E", $msg);
|
|
exit 1;
|
|
}
|
|
Getopt::Long::Configure("posix_default");
|
|
Getopt::Long::Configure("no_gnu_compat");
|
|
Getopt::Long::Configure("bundling");
|
|
|
|
if (
|
|
!GetOptions(
|
|
'f|fanout=i' => \$options{'fanout'},
|
|
'F|File=s' => \$options{'File'},
|
|
'h|help' => \$options{'help'},
|
|
'i|rootimg=s' => \$options{'rootimg'},
|
|
'l|user=s' => \$options{'user'},
|
|
'm|monitor' => \$options{'monitor'},
|
|
'o|node-options=s' => \$options{'node-options'},
|
|
'q|show-config' => \$options{'show-config'},
|
|
'p|preserve' => \$options{'preserve'},
|
|
'r|c|node-rcp=s' => \$options{'node-rcp'},
|
|
's' => \$options{'rsyncSN'},
|
|
't|timeout=i' => \$options{'timeout'},
|
|
'v|verify' => \$options{'verify'},
|
|
'B|bypass' => \$options{'bypass'},
|
|
'Q|silent' => \$options{'silent'},
|
|
'P|pull' => \$options{'pull'},
|
|
'R|recursive' => \$options{'recursive'},
|
|
'T|trace' => \$options{'trace'},
|
|
'V|version' => \$options{'version'},
|
|
'nodestatus|nodestatus' => \$options{'nodestatus'},
|
|
'sudo|sudo' => \$options{'sudo'},
|
|
'X:s' => \$options{'ignore_env'}
|
|
)
|
|
)
|
|
{
|
|
xCAT::DSHCLI->usage_dcp;
|
|
exit 1;
|
|
}
|
|
if ($options{'help'})
|
|
{
|
|
xCAT::DSHCLI->usage_dcp;
|
|
exit 0;
|
|
}
|
|
if ($options{'show-config'})
|
|
{
|
|
xCAT::DSHCLI->show_dsh_config;
|
|
exit 0;
|
|
}
|
|
if (defined($options{File}) && ($options{File} !~ /^\//))
|
|
{ #relative path
|
|
$options{File} = xCAT::Utils->full_path($options{File});
|
|
}
|
|
if (defined($options{rootimg}) && ($options{rootimg} !~ /^\//))
|
|
{ #relative path
|
|
$options{rootimg} = xCAT::Utils->full_path($options{rootimg});
|
|
}
|
|
|
|
# rsync only to the service node
|
|
if ($options{'rsyncSN'})
|
|
{
|
|
$ENV{'RSYNCSNONLY'} = "yes"; # rsync file to SN
|
|
}
|
|
|
|
# if Pull function hierarchy must be handled special in plugin
|
|
if ($options{'pull'})
|
|
{
|
|
$ENV{'DCP_PULL'} = "yes";
|
|
}
|
|
|
|
# if rsyncing to a node, not the root image
|
|
# then must sync to service node first, if using hierarchy
|
|
# These env variable are used in xdsh.pm preprocessing
|
|
if ((!($options{'rootimg'})) && ($options{'File'}))
|
|
{
|
|
$ENV{'RSYNCSN'} = "yes"; #rsync file to SN, if exist
|
|
}
|
|
|
|
if ($options{'File'})
|
|
{
|
|
$ENV{'DSH_RSYNC_FILE'} = $options{'File'}; # rsync file
|
|
}
|
|
if ($options{'version'})
|
|
{
|
|
my $version = xCAT::Utils->Version();
|
|
$version .= "\n";
|
|
xCAT::MsgUtils->message("I", $version);
|
|
exit 0;
|
|
}
|
|
if ($options{'rootimg'})
|
|
{
|
|
$::ROOTIMG = 1;
|
|
}
|
|
if (($options{'rootimg'}) && (!($options{'File'})))
|
|
{
|
|
xCAT::MsgUtils->message("E",
|
|
"To use -i flag you must supply the -F flag\n.");
|
|
exit 1;
|
|
}
|
|
if ($options{'node-rcp'}) # if set on command line, use it
|
|
{
|
|
$::NODE_RCP = 1;
|
|
}
|
|
|
|
if ($options{'bypass'})
|
|
{
|
|
$ENV{XCATBYPASS} = "yes"; # bypass xcatd
|
|
}
|
|
}
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
=head3 check_invalid_exports
|
|
Check for unsupported dsh exports and warns
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub check_invalid_exports
|
|
|
|
{
|
|
##
|
|
# Check for unsupported Environment Variables
|
|
# DSH_DEVICE_LIST, DSH_DEVICE_OPTS, DSH_DEVICE_RCP,DSH_DEVICE_RSH,
|
|
# DSH_NODEGROUP_PATH
|
|
# For support Env Variables tell them to use the command line flag
|
|
##
|
|
|
|
if ($ENV{'DSH_CONTEXT'})
|
|
{
|
|
xCAT::MsgUtils->message("I",
|
|
"DSH_CONTEXT is set but is not supported. It will be ignored.\n");
|
|
}
|
|
if ($ENV{'DSH_LIST'}) # if file of nodes input
|
|
{
|
|
xCAT::MsgUtils->message("I",
|
|
"DSH_LIST is set but is not supported. It will be ignored.\n");
|
|
|
|
}
|
|
if ($ENV{'DSH_NODE_LIST'})
|
|
{
|
|
xCAT::MsgUtils->message(
|
|
"I",
|
|
"DSH_NODE_LIST is set but is not supported. It will be ignored.\n"
|
|
);
|
|
}
|
|
if ($ENV{'DSH_DEVICE_LIST'})
|
|
{
|
|
xCAT::MsgUtils->message(
|
|
"I",
|
|
"DSH_DEVICE_LIST is set but is not supported. It will be ignored.\n"
|
|
);
|
|
}
|
|
if ($ENV{'DSH_DEVICE_OPTS'})
|
|
{
|
|
xCAT::MsgUtils->message(
|
|
"I",
|
|
"DSH_DEVICE_OPTS is set but is not supported. It will be ignored.\n"
|
|
);
|
|
}
|
|
if ($ENV{'DSH_DEVICE_RCP'})
|
|
{
|
|
xCAT::MsgUtils->message(
|
|
"I",
|
|
"DSH_DEVICE_RCP is set but is not supported. It will be ignored.\n"
|
|
);
|
|
}
|
|
if ($ENV{'DSH_DEVICE_RSH'})
|
|
{
|
|
xCAT::MsgUtils->message(
|
|
"I",
|
|
"DSH_DEVICE_RSH is set but is not supported. It will be ignored.\n"
|
|
);
|
|
}
|
|
if ($ENV{'DSH_NODEGROUP_PATH'})
|
|
{
|
|
xCAT::MsgUtils->message(
|
|
"I",
|
|
"DSH_NODEGROUP_PATH is set but is not supported. It will be ignored.\n"
|
|
);
|
|
}
|
|
if ($ENV{'RSYNC_RSH'})
|
|
{
|
|
xCAT::MsgUtils->message("I",
|
|
" RSYNC_RSH is set but is not supported. It will be ignored.\n");
|
|
}
|
|
if ($ENV{'DSH_REPORT'})
|
|
{
|
|
xCAT::MsgUtils->message("I",
|
|
" DSH_REPORT is set but is not supported. It will be ignored.\n");
|
|
}
|
|
}
|