# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html

package xCAT::PPCrflash;
use strict;
use Getopt::Long;
use xCAT::PPCcli qw(SUCCESS EXPECT_ERROR RC_ERROR NR_ERROR);
use xCAT::Usage;
use xCAT::PPCinv;
use xCAT::DSHCLI;
use Getopt::Long;
use File::Spec;
use POSIX qw(tmpnam);



my $packages_dir= ();
my $activate	= ();
my $verbose	= 0;
$::POWER_DEST_DIR               = "/tmp";
my $release_level;
my $active_level;
my @dirlist;

#######################################
# This flag tracks the operation to be performed.  If set, it means we need
# to commit a previously applied update or else recover from one.
#######################################
my $housekeeping = undef;

#####################################
#For -V|--verbose,put the $msg into @value
###################################
sub dpush {
	my $value = shift;
	my $msg = shift;

	if($verbose == 1) {
		push(@$value,$msg);
	}
}


##########################################################################
# Parse the command line for options and operands 
##########################################################################

sub parse_args {

   	my $request = shift;
    	my %opt     = ();
    	my $cmd     = $request->{command};
    	my $args    = $request->{arg};


    	#############################################
    	# Responds with usage statement
    	#############################################
    	local *usage = sub {
       		 my $usage_string = xCAT::Usage->getUsage($cmd);
       	 	return( [ $_[0], $usage_string] );
   	 };
    	#############################################
    	# Process command-line arguments
    	#############################################
    	if ( !defined( $args )) {
        	return(usage( "No command specified" ));
    	}

    	#############################################
    	# Checks case in GetOptions, allows opts
    	# to be grouped (e.g. -vx), and terminates
    	# at the first unrecognized option.
    	#############################################
    	@ARGV = @$args;
    	$Getopt::Long::ignorecase = 0;
    	Getopt::Long::Configure( "bundling" );

    	if ( !GetOptions( \%opt, qw(h|help v|version V|verbose p=s activate=s commit recover) )) {
   	     return( usage() );
    	}
    	
	####################################
    	# Option -v for version
    	####################################
	if ( exists( $opt{v} )) {
        	return( \$::VERSION );
	}
		
	#################################
	#Option --activate not valid with --commit or --recover
	#################################
	if( exists( $opt{activate} ) && (exists( $opt{commit}) || exists( $opt{recover}))) {
		return( usage("Option --activate not valid with --commit or --recover ") );
	}	

	#################################
        #Option -p not valid with --commit or --recover
        #################################
        if( exists( $opt{p} ) && (exists( $opt{commit}) || exists( $opt{recover} ))) {
               return( usage("Option -p not valid with --commit or --recover ") );
        }
	

	#################################
	#Option -p required
	#################################
	if( exists( $opt{p} ) && (!exists( $opt{activate}) )) {
		return( usage("Option -p must be used with --activate ") );
	}	
	
	###############################
	#--activate's value only can be concurrent and disruptive
	################################
	if(exists($opt{activate})) {
		if( ($opt{activate} ne "concurrent") && ($opt{activate} ne "disruptive")) {
			return (usage("--activate's value can only be concurrent or disruptive"));
		}
	}
	
	####################################
   	 # Check for "-" with no option
    	####################################
    	if ( grep(/^-$/, @ARGV )) {
  	      return(usage( "Missing option: -" ));
    	}
    
   	####################################
    	# Check for an extra argument
    	####################################
    	if ( defined( $ARGV[0] )) {
	        return(usage( "Invalid Argument: $ARGV[0]" ));
	}
	
	
	#check to see if we are housekeeping or updating
	#
	if( defined( $opt{commit}) ) {
		print "commit flag\n";
		$housekeeping = "commit";
	} elsif( defined( $opt{ recover }) ) {
		print "recover flag\n";
		$housekeeping = "recover";
	} else {
		print "no housekeeping - update mode\n";
		$housekeeping = undef;
	}

	#############################################
    	# Option -V for verbose output
    	#############################################
    	if ( exists( $opt{V} )) {
        	$verbose = 1;
    	}

		
	####################################
  	# No operands - add command name 
 	####################################
	$request->{method} = $cmd;
	return( \%opt );
}

sub print_var {
	my $j = shift;
	my $msg = shift;
	
	my $var = "+++++++++$msg start--++++\n";
	if(ref($j) eq "ARRAY") {
	     my $t;
	     foreach $t(@$j) {
                if(ref($t) eq "ARRAY") {
                        my $t0 = join(" ", @$t);
		#	if(ref($t0) eq "SCALAR") {
                     	   $var = $var."\t$t0(array)\n";
		#	} else {
		#	   &print_var($t0);
		#	}
                } elsif( ref($t) eq "HASH" ) {
                        my $t12;
                        my $t23;
                        while(($t12, $t23) = each(%$t)) {
                                $var = $var. "\t$t12 => \n";	
		#		if(ref($t23) eq "SCALAR") {
                     			$var = $var. "\t$t23(hash)\n";
		#		} else {
		#	   		&print_var($t23);
		#		}
                        }

                }else {
                        $var = $var. "$t\n";
                }
	    }
        } elsif (ref($j) eq "HASH") {
		 my $t1;
		  my $t2;
      	  while(($t1, $t2) =each (%$j)) {
        	        $var = $var. "$t1 =>";
                if(ref($t2) eq "HASH") {
                        my $t12;
                        my $t23;
                        while(($t12, $t23) = each(%$t2)) {
                                $var = $var. "\t$t12 => $t23\n";
                        }
                } elsif(ref($t2) eq "ARRAY") {
                        my $t = join(" ", @$t2);
                        $var = $var. "$t (array)\n";
                } else {
                        $var = $var. "$t2\n";
                }
	   }
        } else {
		$var = $var. "$j(scalar)\n";
	}


	$var = $var. "+++++++++++$msg end+++++++++++\n";
	
	return $var;
}

#-------------------------------------------------------------------------#
# get_lic_filenames - construct and validate the lup filenames for each   #
# each node                                                               #
#-------------------------------------------------------------------------#
#
sub get_lic_filenames {
	my $mtms = shift;
	my $upgrade_required = 0;	
	my $msg = undef;
	my $filename;

	if(! -d $packages_dir) {
              $msg = "The directory $packages_dir doesn't exist!";
              return ("","","", $msg, -1);
        }
        
	#print "opening directory and reading names\n";
        opendir DIRHANDLE, $packages_dir;
        @dirlist= readdir DIRHANDLE;
        closedir DIRHANDLE;

        @dirlist = File::Spec->no_upwards( @dirlist );

        # Make sure we have some files to process
        #
        if( !scalar( @dirlist ) ) {
        	$msg = "directory $packages_dir is empty";
                return ("","","",$msg, -1);
        }

        $release_level =~/(\w{4})(\d{3})/;
        my $pns = $1;
	my $fff = $2;
		
	#Find the latest version lic file
        @dirlist = grep /\.rpm$/, @dirlist;
        @dirlist = grep /$1/, @dirlist;
        if( !scalar( @dirlist ) ) {
		$msg = "There isn't a package suitable for $mtms";
                return ("","","",$msg, -1);
	}
        if( scalar(@dirlist) > 1) {
         # Need to find the latest version package.
        	@dirlist =reverse sort(@dirlist);
                my $t = "\n";
                foreach $t(@dirlist) {
                       $msg =$msg."$t\t";
                }
         }

         $filename = File::Spec->catfile( $packages_dir, $dirlist[0] );
         $dirlist[0] =~ /(\w(4)(\d(3))_(\w(3))_(\d(3).rpm$))/;
         if(($pns eq $2) && ($4 < $active_level)) {
		$msg = $msg. "Upgrade $mtms concurrently!";
		if($activate ne "concurrent") {
			$msg = "Option --actviate's value should be disruptive";
			return ("", "","", $msg, -1);
		}
	} else {
		$msg = $msg . "Upgrade $mtms disruptively!";
                if($activate ne "disruptive") {
			$msg = "Option --actviate's value should be concurrent ";
			return ("", "","", $msg, -1);
		}
        }
        #print "filename is $filename\n";
	##############
	#If the release levels are different, it will be upgrade_required.
	#############	
	if($fff ne $2) {
		$upgrade_required = 1;
	}
	my $xml_file_name = $filename;
	$xml_file_name =~ s/(.+\.)rpm/\1xml/;
	#print "check_licdd_update: source xml file is $xml_file_name\n";

	if( ( -z $filename)|| ( -z $xml_file_name) ) {
		$msg = "The package $filename or xml $xml_file_name is empty" ;
		return ("", "", "", $msg, -1);
	}
		
	return ($filename, $xml_file_name ,$upgrade_required, $msg, 0);

}

##########################
#Performs Licensed Internal Code (LIC) update support for HMC-attached POWER5 and POWER6 Systems
###########################
sub rflash {

    	my $request = shift;
    	my $hash    = shift;
    	my $exp     = shift;
    	my $hwtype  = @$exp[2];
    	my @result;
	
	$packages_dir = $request->{opt}->{p};
	$activate = $request->{opt}->{activate};	

	my $hmc;
	my $mtms;
	my $component; # system or power
	my $h;
	my $user;
	
	my $tmp_file; #the file handle of the stanza
	my $rpm_file;
	my $xml_file;
	my @rpm_files;
	my @xml_files;
	my $upgrade_required;
	my $stanza = undef;
	
	my @value;

	$hmc = @$exp[3];
	dpush(\@value, [$hmc, "In rflash()"]);
	dpush(\@value,[$hmc, print_var($request, "request")]);
	dpush(\@value,[$hmc, print_var($hash, "hash")]);
	dpush(\@value,[$hmc, print_var($exp, "exp")]);
	#	print_var($t);
	########################
	# Now build a temporary file containing the stanzas to be run on the HMC
	###################
	my $tmp_file = tmpnam();# the file handle of the stanza
	##############################
	# Open the temp file
	##########################
	
	dpush(\@value,[$hmc, "opening file $tmp_file"]);
	unless( open TMP, ">$tmp_file" ) {
        	push (@value,[ $hmc, "cannot open $tmp_file, $!\n"]);
	       	return (\@value);
	}

	while(($mtms,$h) = each(%$hash)) {
		dpush(\@value,[$hmc, "mtms:$mtms"]);
        	my $lflag = 0;
		my $managed_system = $mtms;
      		if( defined( $housekeeping ) ) {
               	    	#$hmc_has_work = 1;
        	        #$::work_flag = 1;
             		&dpush(\@value,[$hmc,"$mtms:creating stanza for housekeeping operation\n"]);
                    	$stanza = "updlic::" . $managed_system . "::" . $housekeeping . "::::";
                    	
			&dpush(\@value,[$hmc, "$mtms:Writing $stanza to file\n"]);
			push(@result,[$hmc,"$mtms:$housekeeping successfully!"]);
                    	print TMP "$stanza\n";
       		} else {
			while(my ($name, $d) = each(%$h)) {
				if ( @$d[4] !~ /^(fsp|bpa|lpar)$/ ) {
               				 push @value,
                 				 [$name,"Information only available for LPAR/CEC/BPA",RC_ERROR];
               				 next;
           		    	}
			
				###############
				#If $name is a Lpar, the flag will be changed from "lpar" to "fsp"
				#######################
				if ( @$d[4] =~ /^lpar$/ ) {
                	        	@$d[4] = "fsp";
                        		$lflag = 1;
					push (@value, [$hmc,"$name is a Lpar on MTMS $mtms", 1]);
                		}
				if( @$d[4] eq "fsp" ) {
					$component = "system";
				} else {
					$component = "power";
				}	
				dpush(\@value, [$hmc,"$mtms:componet:$component!"]);
	
				my $values = xCAT::PPCcli::lslic( $exp, $d );
        	    		my $Rc = shift(@$values);
            			#####################################
            			# Return error
      		      		#####################################
            			if ( $Rc != SUCCESS ) {
                			push @value, [$name,@$values[0],$Rc];
                			next;
				}
				
				if ( @$values[0] =~ /ecnumber=(\w+)/ ) {
                	       		$release_level = $1;
                       			&dpush( \@value, [$hmc,"$mtms :release level:$1"]);
				}
				
				if ( @$values[0] =~ /activated_level=(\w+)/ ) {
                        		$active_level = $1;
                       			&dpush( \@value, [$hmc,"$mtms :activated level:$1"]);
				}	
				my $msg;			
				my $flag = 0;	
				($rpm_file, $xml_file, $upgrade_required,$msg, $flag) = &get_lic_filenames($mtms);
				if( $flag == -1) {
					push (@value, [$hmc,"$mtms: $msg"]);
					return (\@value);
				}
				dpush ( \@value, [$hmc, $msg]);

                		# If we get to this point, the HMC has to attempt an update on the
                        	# managed system, so set the flag.
                        	#
                        	#$hmc_has_work = 1;
                        	#::work_flag = 1;

                        	# Collect the rpm and xml file names in a list so we can dcp then
                       		# in one call.
                        	#
                        	if( scalar( grep /$rpm_file/, @rpm_files ) == 0 ) {
                        		push @rpm_files, $rpm_file;
                        		push @xml_files, $xml_file;
                        	}

				push(@result,[$hmc, "Upgrade $mtms from release level:$release_level activated level:$active_level to $rpm_file successfully"]);

                        }
			
			my $rpm_dest = $::POWER_DEST_DIR."/".$dirlist[0];
			# The contents of the stanza file are slightly different depending
              		 # on the operation being performed.
                	#
               		if( $upgrade_required ) {
                      		$stanza = "updlic::" . $managed_system . "::upgrade::::$rpm_dest";
               		} else {
                	       	$stanza = "updlic::" . $managed_system . "::activate::" . $component . "::" .$rpm_dest;
               		}
                	dpush(\@value,[$hmc, "Writing $stanza to file"]);
  			print TMP "$stanza\n";
			@dirlist = ();
			$rpm_file = ();
			$xml_file = ();

   		}
	}
	# Close the file.  dcp the stanza file, rpm update and xml file to the
	# target HMC
	#
	close TMP;
	
	##################################
    	# Get userid/password
    	##################################
    	my $cred = $request->{$hmc}{cred};
	$user =  @$cred[0];
	
	dpush(\@value, [$hmc,"user: $user"]);;
#	$password = @$cred[1]	

	my $rpm_file_list = join(",", @rpm_files);	
	my $xml_file_list = join(",", @xml_files);	
	###############################
	#Prepare for "xdcp"-----runDcp_api
	##############################
	my %options = ();
	$options{ 'user' } = $user; 
	$options{ 'nodes' } = $hmc; 
	$options{ 'preserve' } = 1;
	$options{ 'source' } = "$tmp_file $rpm_file_list $xml_file_list";
	$options{ 'target' } = "/tmp";

	dpush(\@value, [$hmc,"invoking RunDcp_api()"]);
	my @res = xCAT::DSHCLI->runDcp_api( \%options, 0 );
	if ($::RUNCMD_RC) {   # error from dcp
        	my $rsp={};
        	$rsp->{data}->[0] = "Error from dsh. Return Code = $::RUNCMD_RC";
        	xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
		push(@value,[$hmc,$rsp->{data}->[0]]);
		push(@value,[$hmc,"Failed to copy $tmp_file $rpm_file_list $xml_file_list to $hmc"]);
		return(\@value);
    	}

#	print_var(@res);
	%options = ();
	dpush(\@value,[$hmc, "copy files to $hmc complete"]);

	#`$::XDSH $hmc -K`;
	###############################################
	# Now that all the stanzas files have been built and copied to the HMCs,
	# we can use a single dsh command to invoke them all.
	################################################
	$options{ 'user' } = $user; 
	$options{ 'nodes' } = $hmc; 
	$options{ 'exit-status' } = 1;
	$options{ 'stream' } = 1;	
	$options{ 'preserve' } = 1;
	$options{ 'command' } = "csmlicutil $tmp_file";
#	$options{ 'command' } = "ls -al";

	@res = xCAT::DSHCLI->runDsh_api(\%options, 0);
	if ($::RUNCMD_RC) {    # error from dsh 
        	my $rsp={};
        	$rsp->{data}->[0] = "Error from dsh. Return Code = $::RUNCMD_RC";
        	xCAT::MsgUtils->message("S", $rsp, $::CALLBACK, 1);
		dpush(\@value,[$hmc,"failed to run  xCAT::DSHCLI->runDsh_api()"]);
		push(@value,[$hmc,$rsp->{data}->[0]]);
		push(@value,[$hmc,"Maybe need to configure the HMC to allow remote ssh connections"]);
		return(\@value);
    	}


	%options = ();

	my $r = ();
	foreach $r (@res){
		push(@value, [$r]);	

	}
	push(@value, @result);
	return (\@value);	

}

1;