#!/usr/bin/perl -w
##################################################################
# (C) Copyright 2014 Hewlett-Packard Development Company, L.P.
# @(#) Serviceguard cluster simulation command parser
# @(#) Product Name : HP Serviceguard
# @(#) Product Version : A.12.10.00
# @(#) Patch Name :     
#
# *** Note: This file MUST NOT be edited. *****
#
# Any changes made to it will be overwritten when you upgrade to the
# next release of HP Serviceguard.
#
# Changing this file may lead to issues in Simulator behaviour
#
###################################################################

use POSIX qw(uname);
use File::Basename;
use Cwd;

my $sgConfFile = "/etc/cmcluster.conf";
open (MYCONFFILE,$sgConfFile) or
    die "Failed to open $sgConfFile. Cluster Simulation failed.\n";

my $myConf = undef;
my $myLib = undef;
my $var = undef;

# get os type
my $os_type = (uname) [0];
# get path where files are
my (@lines) = <MYCONFFILE>;
foreach my $line (@lines) {
    next if ($line =~ /^#/); # skip comments
    next if ($line =~/^\s*$/); # skip blank lines
    my ($name, $value) = $line =~/^s*(\w+)=(\S.*)$/;
    if ($name eq "SGCONF") {
        $myConf = $value;
    }
    if ($name eq "SGLIB"){
        $myLib = $value;
    }
}
my $SGCONF = $myConf;
my $SGLIB = $myLib;
close (MYCONFFILE);
die "SGConf not defined in /etc/cmcluster.conf. Cluster Simulator failed.\n" unless defined $myConf;

if ($os_type eq "HP-UX" ) {
    $myConf .= "/lib";
    use lib '/etc/cmcluster/lib';
} else {
    if ( $myConf =~ /opt*/ ) {
         use lib '/opt/cmcluster/lib';
    } else {
         use lib '/usr/local/cmcluster/lib';
    }
}
push (@INC, $myConf);

package commandParser;
use Config;
#use strict;
#use Getopt::Long qw(GetOptions :config no_ignore_case);
use Getopt::Long;
use warnings;
use CSIMSGCluster;
use CSIMFunctions;
use CSIMSGClusterNodes;
use CSIMSGClusterPackage;
require 'configParser.pl';
require 'StatusUtils.pl';

# Global variables
my $sessionName="";
my $cmd="";
my $asciiFile="";
my $cluster=0;
my @package_array;
my @node_arr;
my @pkg_arr;
my $package="";
my $clusterName="";
my @pkgs;
my $sessionDir="";
my $verbose=0;
my $force=0;
my $res='n';
my $fileLoc="";
my $nodeName="";
my $enable=0;
my $disable=0;
my $clusterObj=undef;
my $help;
my $reset;
my $cfull=0;
my $cfull_node = "";
my $cfull_cluster = "";
my $cmdstr = "";

# subroutines 

sub usage {
    my ($msg) = @_;
    if ($cfull) {
        print "\nUsage: \n" .
            "cmsimulatecl\n" .
            "\t\t     help | quit | exit\n" .
            "\t\t     listsession \n" . 
            "\t\t     deletesession [-a] | sessionName.. \n" .
            "\t\t     setcluster cluster_name \n" .
            "\t\t     importcluster [-c cluster_name] [-l file_location] \n" .
            "\t\t     cmapplyconf -C cluster_ascii_file  | -P pkg_ascii_file \n " .
            "\t\t     cmdeleteconf [-f] [-p package_name] \n" .
            "\t\t     cmviewcl [-v -f line] \n" .
            "\t\t     cmruncl [-f] \n" .
            "\t\t     cmhaltcl [-f] \n" .
            "\t\t     cmrunpkg [-n node_name]... package_name... \n" . 
            "\t\t     cmhaltpkg [-n node_name]... package_name... \n" .
            "\t\t     cmmodpkg {-e | -d} [-n node_name] package_name \n" .
            "\t\t     cmrunnode [node_name]... \n" .
            "\t\t     cmhaltnode [-f] [node_name]... \n" .
            "\t\t     fail [-n node_name [-i interface_name]] [-p package_name]\n" .
            "\t\t     recover [-n node_name [-i interface_name]] [-p package_name] \n" .
            "\t\t     setnode node_name \n" .
            "\t\t     getnode \n" ;
    }
    else {
        print "\nUsage: \n" .
            "cmsimulatecl \n" .
            "cmsimulatecl --help\n" .
            "cmsimulatecl cmapplyconf -C cluster_ascii_file | --session <sessionName> cmapplyconf -P pkg_ascii_file \n " .
            "\t\t     --session <sessionName> cmdeleteconf [-f][-p package_name] \n" .
            "\t\t     --session <sessionName> cmviewcl [-v -f line]\n" .
            "\t\t     --session <sessionName> cmruncl [-f] \n" .
            "\t\t     --session <sessionName> cmhaltcl [-f] \n" .
            "\t\t     --session <sessionName> cmrunpkg [-n node_name]... package_name... \n" . 
            "\t\t     --session <sessionName> cmhaltpkg [-n node_name]... package_name... \n" .
            "\t\t     --session <sessionName> cmmodpkg {-e | -d} [-n node_name] package_name \n" .
            "\t\t     --session <sessionName> cmrunnode [node_name]... \n" .
            "\t\t     --session <sessionName> cmhaltnode [-f] [node_name]... \n" .
            "\t\t     --session <sessionName> fail [-n node_name [-i interface_name]] [-p package_name] \n" .
            "\t\t     --session <sessionName> recover [-n node_name [-i interface_name]] [-p package_name] \n" .
            "\t\t     --session <sessionName> setnode node_name \n" .
            "\t\t     --session <sessionName> getnode \n" .
            "\t\t     importcluster [-c cluster_name] [-l file_location] \n" .
            "\t\t     listsession \n" .
            "\t\t     deletesession [-a] | sessionName.. \n" ; 
    
    }                   
    print "$msg\n";
}

# In context-full mode, initialize globals between every command on the 'clsim>' prompt.
sub init_globals {
    $sessionName=$cfull_cluster;
    $cmd="";
    $asciiFile="";
    $cluster=0;
    @package_array = ();
    @node_arr = ();
    @pkg_arr = ();
    $package="";
    $clusterName=$cfull_cluster;
    @pkgs = ();
    $sessionDir="";
    $verbose=0;
    $force=0;
    $res='n';
    $fileLoc="";
    $nodeName=$cfull_node;
    $enable=0;
    $disable=0;
    $clusterObj=undef; 
    $help = 0;
    $reset = 0;
}

# If in context-full mode don't really return as in exit!
# parse_cmds() must use only this instead of using return statements directly.
sub return_from_cmd_parser {

    my ($retv) = @_;

    if ($cfull == 0) {
        exit($retv);
    }
    else {
        goto CFULL;
    }
}

sub getOptFailed {
    usage("Invalid Argument");
    return_from_cmd_parser(-1);
}
# subroutine to parse arguments  and take appropriate action.
sub parse_cmds {

    my $full_cmd;
    my @parsed_cmd;
    $cmdstr = join(" ", @ARGV);    

    GetOptions(
        "session=s"	=> \$sessionName,
        "C=s"   	=> \$cluster,
        "l=s"   	=> \$fileLoc,
        "n=s"   	=> \@node_arr,
        "P=s"   	=> \@package_array,
        "f"     	=> \$force,
        "v"     	=> \$verbose,
        "e" 		=> \$enable,
        "d" 		=> \$disable,
        "i=s"       => \$interface, 
        "a"         => \$all,
        "help|h|?"  => \$help, 
    )|| getOptFailed();
    $nodeName = $node_arr[0];
    my $argcount = scalar @ARGV;
    if ($argcount == 0 && (!$help && !$sessionName && !$cluster 
        && !$fileLoc && !$nodeName && !@package_array && $force == 0 
        && $enable == 0 && $disable == 0 && $verbose == 0 )) {
        $cfull = 1;
    }


CFULL:
    if ($cfull) { #cfull-preprocessing
        unless ($sessionName) {
            print "clsim> ";
        } 
        else {
            print "clsim:$sessionName> ";
        }
        @ARGV = ();
        init_globals();
        while (<STDIN>) {
          @ARGV = split(/\s+/, $_);
          chomp(@ARGV);
          last;
        }
        
        my $astring = join ("::", @ARGV);
        if($astring=~/^\s*$/) {
            goto CFULL;
        }
        
        $cmdstr = join(" ", @ARGV);
        
        GetOptions(
          "session=s"     => \$sessionName,
          "C=s"           => \$cluster,
          "l=s"           => \$fileLoc,
          "n=s"           => \@node_arr,
          "P=s"           => \@package_array,
          "f"             => \$force,
          "v"             => \$verbose,
          "e"             => \$enable,
          "d"             => \$disable,
          "a"         => \$all,
          "r"         => \$reset,
          "i=s"       => \$interface,
          "help|h|?"  => \$help, 
        ) || getOptFailed();
        $nodeName = $node_arr[0];
    } # cfull-preprocessing
    
    if ($help) {
        usage("");
        return_from_cmd_parser(-1);
    }
    if ($sessionName && $cluster) {
        if ($ARGV[0] eq 'cmapplyconf') {
            unless($package) {
                usage("Invalid argument: --session.\n");
                return_from_cmd_parser(-1);
            }
        }
        if ($sessionName ne $cluster) {
            print "Session name and cluster name should be identical.\n";
            return_from_cmd_parser(-1);
        }
    }
    if ($sessionName) {
       $cluster=$sessionName;
       $clusterName=$cluster;
    }
    elsif ($cluster) {
       $clusterName=$cluster; 
       $sessionName = $clusterName; 
    }
    if (@ARGV) {
        unless ($ARGV[0] eq 'cmapplyconf' || $ARGV[0] eq 'listsession' ||
                $ARGV[0] eq 'deletesession' || $ARGV[0] eq 'importcluster' || 
                $ARGV[0] eq 'help' || ($cfull && ($ARGV[0] eq 'setnode' || 
                $ARGV[0] eq 'setcluster' || $ARGV[0] eq 'getnode' 
                || $ARGV[0] eq 'exit' || $ARGV[0] eq 'quit')) ) {
            if ($clusterName) {
                if(validateSession($clusterName) == -1){
                    print "The cluster $cluster does not exist.\n";
                    return_from_cmd_parser(-1);
                }
            }
            else {
                usage( "\nInvalid command or argument(s):@ARGV\n");
                return_from_cmd_parser(-1);
            }
        }
        if (@package_array) {
            if($ARGV[0] eq 'cmrunpkg' || $ARGV[0] eq 'cmhaltpkg') {
                usage("$ARGV[0]: Invalid option -P");
                return_from_cmd_parser(-1);
            }
        }

        $cmd=join(" ",@ARGV);  
        if ($cmd=~/^\s*listsession$/) {
            $full_cmd = substr($cmdstr, index($cmdstr, "listsession"));            
            @fullcmd = split " ", $full_cmd;
            shift @fullcmd;
            
            @parsed_cmd = map {join(' ', split(' '))} @fullcmd;            
            
            if (@parsed_cmd){
                print "Unknown Option: @parsed_cmd\n";
                usage("Invalid Argument");
                return_from_cmd_parser(-1);
            }
            listSession();
        }
        elsif ($cmd=~/^\s*deletesession/) {
            my $full_cmd = substr($cmdstr, index($cmdstr, "deletesession"));
            my @old_argv = @ARGV;
            @ARGV = split " ", $full_cmd;
            shift @ARGV;
            
            GetOptions(
                "a" => \$all,
            )|| getOptFailed();
            
            my @parsed_cmd = map {join(' ', split(' '))} @ARGV;
            @ARGV = @old_argv;
            
            if ($all && @parsed_cmd) {
                usage("Incorrect argument.\n");
                return_from_cmd_parser(-1);
            }
            
            deleteSession();
        }
        elsif ($cmd=~/^\s*help$/) {
            usage("");
            return_from_cmd_parser(-1);
        }
        elsif ($cmd=~/^\s*cmapplyconf/) {
            if ($cluster and !@package_array) {   
                unless (open SRCASCII, "< $cluster") {
                    print "Unable to open ascii file $cluster\n";
                    $cluster = undef;
                    $sessionName = undef; 
                    return_from_cmd_parser(-1);
                }
                while (<SRCASCII>) {
                    my $line=$_;
                    chomp($line);
                    if ($line=~/^\s*CLUSTER_NAME/i) {
                        $line=~s/\s+/ /;
                        my @vals=split (" ",$line );        
                        $clusterName=$vals[1];
                    }
                }
                unless (-d "$SGCONF/simulator") {
                    unless (mkdir "$SGCONF/simulator") { 
                        print "Could not create $SGCONF/simulator\n";
                        $cluster = undef;
                        $sessionName = undef;
                        return_from_cmd_parser(-1);
                    }
                }
                 
                if (parse_Configuration("cluster", $cluster, $clusterName) == 0) {
                    print "Completed the cluster creation\n";
                    $cluster = undef;
                    $sessionName = undef;
                }
                else {
                    return_from_cmd_parser(-1);
                }
                close SRCASCII;    
                return_from_cmd_parser(0);
                
            }
            elsif (@package_array) {  
                if (!$sessionName) {
                    if ($cluster) {
                        $sessionName=$cluster;
                    }    
                    else {
                        usage( "Please specify session Name or cluster Name");
                    } 
                }
                # Check if cluster is already configured or not 
                # by verifying existance of $sessionName__cmviewcl_line file
                unless (-e "$SGCONF/simulator/$sessionName/$sessionName"."_cmviewcl_line") {
                    print "Cluster is not configured . Please configue a cluster first.\n";
                    return_from_cmd_parser(-1);
                }
                my $packageName="";
                my $pkgs = @package_array;
                foreach $package (@package_array)
                {
                    unless (open SRCASCII, "< $package") {
                        print "Unable to open ascii file $package\n";
                        return_from_cmd_parser(-1);
                    }
                    while (<SRCASCII>) {
                        my $line=$_;
                        chomp($line);
                        if ($line=~/^\s*package_name/i) {
                            $line=~s/\s+/ /;
                            my @vals=split (" ",$line );        
                            $packageName=$vals[1];
                            unless ($packageName) {
                                print "$package : Missing value after attribute package_name!\n";
                                print "$package : Invalid value for attribute package_name.\n";
                                print "cmapplyconf: Error found in package file: $package\n";
                                return_from_cmd_parser(-1);
                            }
                        }
                    }
                    #### Commented out following code for online cmapplyconf 
                    #  my @pkgs= `ls $SGCONF/simulator/$sessionName 2>/dev/null`;
                    #  foreach my $p (@pkgs){
                    #      chomp ($p);
                    #	      if (($p eq $packageName) and ($p ne "") and ($p ne "clusterConfig")){
                    #          print "A package with $p name is already configured. Please specify another Package Name. \n";
                    #      }
                    #  }
                    #  push (@pkgs,$packageName);                
  
                    if (parse_Configuration("package", $package, $clusterName) == 0) {
                        print "Completed the cluster update\n";
                    }
                    else {
                        print "cmapplyconf: Unable to verify package.\n";
                        return_from_cmd_parser(-1);
                    }
                 }
            }
            close SRCASCII;
        }
        elsif ($cmd=~/^\s*cmdeleteconf/) {
            if ($ARGV[1]) {
                usage("Incorrect argument.");
                return_from_cmd_parser(-1);
            }
            if ($cluster || ($sessionName)) {
                unless (@package_array) { 
                    my $ret = 0; 
                    $ret = deleteConfCluster($cluster,$force);
                    unless($ret) {
                        print "Completed the cluster deletion\n";
                        $sessionName  = undef;
                        $cluster = undef;
                        $cfull_cluster = undef;
                        return_from_cmd_parser(0);
                    }            
                }
                else {
                   
                    my $success = 0;
                    foreach my $package (@package_array) {
                        unless(deleteConfPackage($cluster,$package,$force)) {
                            $success = 1;
                        }
                    } 
                    if ($success) {
                        print "Completed the package deletion\n";
                        return_from_cmd_parser(0);
                    }
                    else {
                        print "cmdeleteconf: Unable to delete the packages.\n";
                        return_from_cmd_parser(-1);
                    }
                }
            }
        }
        elsif ($cmd=~/^\s*cmviewcl\W+/ || $cmd=~/^\s*cmviewcl$/) {            
            my $full_cmd = substr($cmdstr, index($cmdstr, "cmviewcl"));
            my @old_argv = @ARGV;
            @ARGV = split " ", $full_cmd;
            shift @ARGV;
            
            GetOptions(
                "v" => \$verbose,
                "f" => \$force,
            )|| getOptFailed();
            
            my @parsed_cmd = map {join(' ', split(' '))} @ARGV;
            @ARGV = @old_argv;
            
            if (@parsed_cmd){
                foreach (my $c=0; $c < @parsed_cmd; $c++) {
                    if ($parsed_cmd[$c] =~ /^\s*$/ || $parsed_cmd[$c] =~ /^\s*line\s*$/) {
                        next;
                    }
                    else {
                        usage("Invalid Argument $parsed_cmd[$c]");
                        return_from_cmd_parser(-1);
                    }                    
                }
            }           
          
            viewCluster($cmd);            
        }        
        elsif ($cmd=~/^\s*cmruncl\W+/ || $cmd=~/^\s*cmruncl$/) {
            my $full_cmd = substr($cmdstr, index($cmdstr, "cmruncl"));
            my @old_argv = @ARGV;
            @ARGV = split " ", $full_cmd;
            shift @ARGV;
            
            GetOptions(
                "f" => \$force,
            )|| getOptFailed();
            
            my @parsed_cmd = map {join(' ', split(' '))} @ARGV;
            @ARGV = @old_argv;
            
            if (@parsed_cmd){
                usage("Invalid Argument @parsed_cmd");
                return_from_cmd_parser(-1);
            }
        
            #This will call CSIMFunction which will parse status of cluster and then we will be modifying 
            #required fields from status (cmviewcl line o/p) and will again dump it to internal storage
            unless (cm_run_cl($cluster)) {
                print "Waiting for cluster to form ..... done \n";
                print "Cluster successfully formed.\n";
            }
        }	
        elsif ($cmd=~/^\s*cmhaltcl\W+/ || $cmd=~/^\s*cmhaltcl$/) {
            my $full_cmd = substr($cmdstr, index($cmdstr, "cmhaltcl"));
            my @old_argv = @ARGV;
            @ARGV = split " ", $full_cmd;
            shift @ARGV;
            
            GetOptions(
                "f" => \$force,
            )|| getOptFailed();
            
            my @parsed_cmd = map {join(' ', split(' '))} @ARGV;
            @ARGV = @old_argv;
            
            if (@parsed_cmd){
                usage("Invalid Argument @parsed_cmd");
                return_from_cmd_parser(-1);
            }            
            unless (cm_halt_cl($cluster,$force)) {
                print "Waiting for nodes to halt ..... done \n";
                print "Successfully halted all nodes specified. \n";
                print "Halt operation complete. \n";
            }
            else {
                print "cmhaltcl: command failed.\n";
            }
        }
        elsif ($cmd=~/^\s*cmrunpkg/) {
            my $argc = @ARGV;
            my @mypkgs = @ARGV[1..($argc-1)];
            #This is for identifying if node arg is provided or not
            #It will help at the time of running a multinode pkg 
            my $nodeProvided = 1 ; 
            #my @mypkgs = @package_array;
            unless (@node_arr) {
                $nodeName = get_node($cluster); 
                if (!$nodeName) {
                    print "No active node is set to perform this operation.\n";
                    return_from_cmd_parser(-1);
                }
                chomp($nodeName);
                push(@node_arr,$nodeName);
                $nodeProvided = 0;
            }
            my $ret = cm_run_pkg($cluster, $nodeProvided, \@mypkgs, \@node_arr);
            if ($ret == 0) {
                print "cmrunpkg: All specified packages are running\n";
            }
            elsif ($ret == -1) {
                print "cmrunpkg: Unable to start some package or package instances.\n";
            }
            
        } 
        elsif ($cmd=~/^\s*cmhaltpkg/) {
            my $argc = @ARGV;
            my @mypkgs = @ARGV[1..($argc-1)];
            my $ret = cm_halt_pkg($cluster, \@node_arr, \@mypkgs);
            unless ($ret) {
                print "cmhaltpkg: Completed successfully on all packages specified\n";
            }

        }
        elsif ($cmd=~/^\s*cmmodpkg/){
            my $argc = @ARGV;
            my @mypkgs = @ARGV[1..($argc-1)];
            if ($enable){
                my $ret = cm_mod_pkg($cluster, $nodeName, "enable", @mypkgs);
                print "cmmodpkg: Completed successfully on all packages specified\n";
            }
            elsif ($disable){
                my $ret = cm_mod_pkg($cluster, $nodeName, "disable", @mypkgs);
                print "cmmodpkg: Completed successfully on all packages specified\n";
            }
            else {	
                print "cmmodpkg: provide valid options\n";
            }
        }
        elsif ($cmd=~/^\s*cmrunnode/){
            my $argc = @ARGV;
            my @nodeName = @ARGV[1..($argc-1)];
            unless (@nodeName) {
                my $actnode = get_node($cluster);
                if (!$actnode) {
                    print "No active node is set to perform this operation.\n";
                    return_from_cmd_parser(-1);
                }
                push(@nodeName, $actnode);
            }
            my $ret = cm_run_node($cluster, @nodeName);
            unless($ret) {
                print "Cluster successfully formed.\n";
                print "cmrunnode: Completed successfully \n";
            }
        }
        elsif ($cmd=~/^\s*cmhaltnode/){
            if ($cluster) {
                my $argc = @ARGV;
                my @nodeName = @ARGV[1..($argc-1)];
                unless (@nodeName) {
                    my $actnode = get_node($cluster);
                    if (!$actnode) {
                        print "No active node is set to perform this operation.\n";
                        return_from_cmd_parser(-1);
                    }
                    push(@nodeName, $actnode);
                }
                my $ret = cm_halt_node($cluster, $force, @nodeName);
                unless($ret) {
                    print "Waiting for nodes to halt ..... done\n";
                    print "Successfully halted all nodes specified.\n";
                    print "Halt operation complete.\n";
                }
                else {
                    print "cmhaltnode: command failed.\n";
                }
                
            }
            else {
                usage("Please specify cluster/node name \n");
            }
        }
        elsif ($cmd=~/^\s*importcluster/) {
            importCluster();
        }
		elsif ($cmd=~/^\s*fail/) {
            unless ($nodeName) {
                my $actNode = get_node($cluster);
                if (!$actNode) {
                    print "No active node is set to perform this operation.\n";
                    return_from_cmd_parser(-1);
                }
                $nodeName = $actNode;
            }
		    if ($interface) {
                simulate_interface_failure($cluster, $interface, $nodeName);
                return_from_cmd_parser(0);
            }
            elsif (@package_array) {
                my $pkgName = $package_array[0];
                simulate_package_failure($cluster, $pkgName);
                return_from_cmd_parser(0);
            }
            elsif ($nodeName) {
                simulate_node_failure($cluster, $nodeName);
                return_from_cmd_parser(0);
		    }
            else{
                return_from_cmd_parser(0);
            }
	    }
	    elsif ($cmd=~/^\s*recover/) {
            unless ($nodeName) {
                my $actNode = get_node($cluster);
                if (!$actNode) {
                    print "No active node is set to perform this operation.\n";
                    return_from_cmd_parser(-1);
                }
                $nodeName = $actNode;
            }
            if ($interface) {
                simulate_interface_recover($cluster, $interface, $nodeName);
                return_from_cmd_parser(0);
            }
	  	    elsif (@package_array) {
                my $pkgName = $package_array[0];
			    simulate_package_recover($cluster, $pkgName);
                return_from_cmd_parser(0);
            }
            elsif ($nodeName) {
			    simulate_node_recover($cluster, $nodeName);
		    }
		    else {
			    return_from_cmd_parser(-1);
		    }
	    }
        elsif ($cmd=~/^\s*quit$/) {
            exit;
        }
        elsif ($cmd=~/^\s*exit$/) {
            exit;
        }
        elsif ($cmd=~/^\s*setcluster/) {
            my $argc = @ARGV;
                if ($argc ge 2 && $reset) {
                   usage("Incorrect argument.\n");
                   return_from_cmd_parser(-1);
                }
                elsif ($argc lt 2 && $reset == 0) {
                   usage("Please specify cluster name.\n");
                   return_from_cmd_parser(-1);
                }
                $clusterName = $ARGV[1];
                my $sessionDir="$SGCONF/simulator" . "/" . $clusterName;
                unless (-d $sessionDir) {
                    print "No valid simulation session or cluster of name $clusterName exists.\n";
                    #$cfull_cluster = "";
                    return_from_cmd_parser(-1);
                }
                $cfull_cluster = $clusterName;
                $sessionName = $clusterName;
                $clusterObj = undef; 
                my $filename =  $sessionDir . "/" . $cfull_cluster . "_cmviewcl_line";
                $clusterObj = &statusParser($filename);
                unless ($clusterObj) {
                    return_from_cmd_parser(-1);
                }
                return_from_cmd_parser(0);
        }
        elsif ($cmd=~/^\s*setnode/) {
	        my $ret;
            my $argc = @ARGV;
            if ($argc lt 2) {
               usage("Please specify node name.\n");
               return_from_cmd_parser(-1);
            }
            $nodeName = $ARGV[1];
            $cfull_node = $nodeName;
            $ret = set_node($cluster, $ARGV[1]);
            unless ($ret) {
                print "Node $ARGV[1] is set as active node for session $cluster.\n";
            }
            else {
                print "Node $ARGV[1] is not part of $cluster cluster.\n";
            }
            return_from_cmd_parser($ret);
        }
        elsif ($cmd=~/^\s*getcluster/) {
            my $argc = @ARGV;
            if ($argc gt 1) {
                usage("Incorrect argument.\n");
                return_from_cmd_parser(-1);
            }
            $clusterName = $cfull_cluster;
            unless ($clusterName) {
                print "No cluster is set as active cluster.\n";
            }
            else {
                print "$clusterName is active cluster for this session. \n";
            }
        }
	    elsif ($cmd=~/^\s*getnode/) {
	        my $argc = @ARGV;
	        if ($argc gt 1) {
		        usage("Incorrect argument.\n");
		        return_from_cmd_parser(-1);
	        }
	        my $node = get_node($cluster);
            if ($node) {
                print "$node is active node for session $cluster. \n";
                return_from_cmd_parser(0);
            }
            else{
                print "No node is set as active node.\n";
                return_from_cmd_parser(-1);
            }
        }
        else {
            usage( "\nInvalid command or argument(s):@ARGV\n");
        }
    }
    else {
       usage("No argument. Please specify arguments on command line\n");
       return_from_cmd_parser(-1);
    }

    if (!$cfull) {
        # after one round of processing return back from parse_cmds()
        return;
    }
    goto CFULL;
}
sub importCluster {
    if ($cluster and $fileLoc) {
        usage( "Invalid options provided. \n\n");
        return_from_cmd_parser(-1);
    }
    unless (-d "$SGCONF/simulator") {
        unless (mkdir "$SGCONF/simulator") {
            print "Could not create $SGCONF/simulator\n";
            return_from_cmd_parser(-1);
        }
    }
    if ($cluster) {
        $SGCONF = getSGCONF(); 
        my $sessionDir="$SGCONF/simulator" . "/" . $cluster;
        my $orig_cl_file = $sessionDir . "/" . $cluster . "_cmviewcl_line.tmp";
        my $filename =  $sessionDir . "/" . $cluster . "_cmviewcl_line";
        mkdir $sessionDir;
        my $cmd = "cmviewcl -c $cluster -vf line > $orig_cl_file";
        my $ret = system("$cmd");
        if ($ret == 0){
            $clusterObj = &statusParser($orig_cl_file);
            `rm -f $orig_cl_file 2>/dev/null`;
            unless ($clusterObj) {
                return_from_cmd_parser(-1);
            }
            &statusDumper($clusterObj,$filename);	
            $ret = set_node($clusterObj->{name},$clusterObj->{nodes}[0]->{name});
            print "\nCluster $cluster is imported. Please use cmviewcl to view the cluster. \n\n";
            return_from_cmd_parser(0);
        }
        else {
            `rm -r "$sessionDir" 2>/dev/null` ;
            print "\nERROR: Cluster $cluster does not exist or not valid. \n\n";
            return_from_cmd_parser(-1);
        }
    }

    if ($fileLoc) {
        unless (open CMVIEW, "< $fileLoc") {
            print "Unable to open given file $fileLoc\n";
            return_from_cmd_parser(-1);
        }
        close CMVIEW;

        $clusterObj = &statusParser($fileLoc);
        unless ($clusterObj) {
            return_from_cmd_parser(-1);
        }
        my $impCluster = $clusterObj->getName();
        my $clusterPr = $clusterObj->getClusterPR();
        my $clusterNodeNum = $clusterObj->getNumOfNodes();
		unless($impCluster && $clusterPr && $clusterNodeNum) {	
			print "\n$fileLoc is not a valid input file. \n\n";
			return_from_cmd_parser(-1); 
		}
        my $sessionDir="$SGCONF/simulator" . "/" . $impCluster;
        mkdir $sessionDir;

        $SGCONF = getSGCONF();
        my $filename =  $SGCONF . "/simulator/" . $impCluster . "/" . $impCluster . "_cmviewcl_line";
        &statusDumper($clusterObj,$filename);
        
        set_node($clusterObj->{name},$clusterObj->{nodes}[0]->{name});
        print "\nCluster $impCluster is imported. Please use cmviewcl to view the cluster \n\n";
        return_from_cmd_parser(0);
    }

    my $filename =  $sessionDir."/"."local_cmviewcl_line";
    my $cmd = "cmviewcl 2>/dev/null";
    my $ret = system("$cmd");
    if ($ret ne 0) {
        print "\nERROR: Cluster does not exist or not valid. \n\n";
        return_from_cmd_parser(-1);
    }   
    $cmd = "cmviewcl -vf line > $filename";
    $ret = system("$cmd");
    $clusterObj = &statusParser($filename);
    $cmd = "rm -rf $filename";
    $ret = system("$cmd");

    my $impCluster = $clusterObj->getName();
    my $sessionDir="$SGCONF/simulator"."/".$impCluster;
    mkdir $sessionDir;
    $filename =  $sessionDir."/".$impCluster."_cmviewcl_line";
    &statusDumper($clusterObj,$filename);
    $ret = set_node($clusterObj->{name},$clusterObj->{nodes}[0]->{name});
    print "\nCluster $impCluster is imported. Please use cmviewcl to view the cluster \n\n";
    return_from_cmd_parser(0);
}

# subroutine to list the sessions
sub listSession{
    my $SGCONF=getSGCONF();
    my @sessions = ` ls "$SGCONF/simulator" 2>/dev/null`;
    if(@sessions){
        print @sessions;
    }
    else{
    print "No session available\n";
    }
}
sub deleteSession {
    my $argc = @ARGV;
    my $deleteall = 0;
    my @sessions = ();

    if ($argc le 1 && !$all && !$sessionName) {
        usage("Incorrect argument.\n");
        return_from_cmd_parser(-1);
    }

    if($argc ge 1) {
        if ($all) {
            @sessions = ` ls "$SGCONF/simulator" 2>/dev/null`;
        }
        else {
            @sessions = @ARGV[1..($argc-1)];
            foreach my $session (@sessions) {
                if(validateSession($session) == -1){
                    print "The session $session does not exist.\n";
                    return_from_cmd_parser(-1);
                }                
            }
        }
        foreach my $session (@sessions) {
            print "session: $session \n";
        }
        unless ($sessionName && ($argc == 1)) {
            print "Do you really want to delete above session(s) ([y]/n)";
        } else {
            print "Do you really want to delete session $sessionName ([y]/n)";
        }
        while (<STDIN>) {
            if ($_ =~ /^\s*$/){
                $res='y';
                last;
            }
            $res=$_;
            last;
        }
        if ($res=~/y/i) {
            if ($sessionName && ($argc == 1) && !$all) {
                `rm -rf $SGCONF/simulator/$sessionName 2>/dev/null`;
            }
            else
            {
                foreach my $session (@sessions) {
                    #print "$SGCONF/simulator/$session \n";
                    `rm -rf $SGCONF/simulator/$session 2>/dev/null`;
                    $all = 0;
                }
            }
            if ($sessionName) {
                $sessionName  = undef;
                $cluster = undef;
                $cfull_cluster = undef;    
            }
        }
    }
    return_from_cmd_parser(0);

}
sub viewCluster {
    
    my  $cmd =shift;
    if ($sessionName) {
            $clusterName=$sessionName;
    }
    else {
       $clusterName=$cluster;
    }    
    if ((!$force) and ($cmd=~/line/)) {
        usage("Please specify -f option with line \n");
        return_from_cmd_parser(-1);
    }
    cm_view_cl($clusterName, $cmd);
}


sub run {
    parse_cmds();
}

sub new {
    my ($val)=@_;
    my $self={};
    bless $self, $val;
    return $self;
}

my $command=commandParser->new();
$command->run();
 
1;
