# IBM(c) 2013 EPL license http://www.eclipse.org/legal/epl-v10.html
package xCAT_plugin::openstack;
BEGIN
{
    $::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
}
use lib "$::XCATROOT/lib/perl";
use xCAT::Utils;
use xCAT::TableUtils;
use xCAT::SvrUtils;
use xCAT::NetworkUtils;
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 {
		opsaddbmnode => "openstack",  #external command
		opsaddimage => "openstack",   #external command
		deploy_ops_bm_node => "openstack",   #internal command called from the baremetal driver
		cleanup_ops_bm_node => "openstack",  #internal command called from the baremetal driver
   }
}

sub process_request {
	my $request = shift;
	my $callback = shift;
	my $doreq = shift;
	my $command = $request->{command}->[0];
	
	if ($command eq "opsaddbmnode") {
		return opsaddbmnode($request, $callback, $doreq);
	} elsif ($command eq "opsaddimage") {
		return opsaddimage($request, $callback, $doreq);
	} elsif ($command eq "deploy_ops_bm_node") {
		return deploy_ops_bm_node($request, $callback, $doreq);
	} elsif ($command eq "cleanup_ops_bm_node") {
		return cleanup_ops_bm_node($request, $callback, $doreq);
	} else {
		$callback->({error=>["Unsupported command: $command."],errorcode=>[1]});
		return 1;
	}
}


#-------------------------------------------------------------------------------

=head3  opsaddbmnode
     This function takes the xCAT nodes and register them
     as the OpenStack baremetal nodes
=cut

#-------------------------------------------------------------------------------
sub opsaddbmnode {
	my $request = shift;
	my $callback = shift;
	my $doreq = shift;
	
	@ARGV = @{$request->{arg}};
	Getopt::Long::Configure("bundling");
	Getopt::Long::Configure("no_pass_through");
	
	my $help;
	my $version;
	my $verbose;
	my $host;
	
    if(!GetOptions(
            'h|help'      => \$help,
            'v|version'   => \$version,
            'V|verbose'   => \$verbose,
            's=s'         => \$host,
       ))
    {
        &opsaddbmnode_usage($callback);
        return 1;
    }
    # display the usage if -h or --help is specified
    if ($help) {
        &opsaddbmnode_usage($callback);
        return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($version)
    {
        my $rsp={};
        $rsp->{data}->[0]= xCAT::Utils->Version();
        $callback->($rsp);
        return 0;
    }
	
	if (!$request->{node}) {
		$callback->({error=>["Please specify at least one node."],errorcode=>[1]});
		return 1;  
	}
	if (!$host) {
		$callback->({error=>["Please specify the OpenStack compute host name with -s flag."],errorcode=>[1]});
		return 1;  
	}
    
    my $nodes = $request->{node};

    #get node mgt
    my $nodehmhash;
    my $nodehmtab = xCAT::Table->new("nodehm");
    if ($nodehmtab) {
        $nodehmhash = $nodehmtab->getNodesAttribs($nodes,['power', 'mgt']);
    }

    #get bmc info for the nodes
	my $ipmitab = xCAT::Table->new("ipmi", -create => 0);
	my $tmp_ipmi;
	if ($ipmitab) {
		$tmp_ipmi = $ipmitab->getNodesAttribs($nodes, ['bmc','username', 'password'], prefetchcache=>1);
		#print Dumper($tmp_ipmi);
	} else {
		$callback->({error=>["Cannot open the ipmi table."],errorcode=>[1]});
		return 1;		
	}

    #get mac for the nodes
	my $mactab = xCAT::Table->new("mac", -create => 0);
	my $tmp_mac;
	if ($mactab) {
		$tmp_mac = $mactab->getNodesAttribs($nodes, ['mac'], prefetchcache=>1);
		#print Dumper($tmp_mac);
	} else {
		$callback->({error=>["Cannot open the mac table."],errorcode=>[1]});
		return 1;		
	}

    #get cpu, memory and disk info for the nodes
	my $hwinvtab = xCAT::Table->new("hwinv", -create => 0);
	my $tmp_hwinv;
	if ($hwinvtab) {
		$tmp_hwinv = $hwinvtab->getNodesAttribs($nodes, ['cpucount', 'memory', 'disksize'], prefetchcache=>1);
		#print Dumper($tmp_hwinv);
	} else {
		$callback->({error=>["Cannot open the hwinv table."],errorcode=>[1]});
		return 1;		
	}

    #get default username and password for bmc
    my $d_bmcuser;
    my $d_bmcpasswd;
	my $passtab = xCAT::Table->new('passwd');
	if ($passtab) {
		($tmp_passwd)=$passtab->getAttribs({'key'=>'ipmi'},'username','password');
		if (defined($tmp_passwd)) {
			$d_bmcuser = $tmp_passwd->{username};
			$d_bmcpasswd = $tmp_passwd->{password};
		}
	}

	#print "d_bmcuser=$d_bmcuser, d_bmcpasswd=$d_bmcpasswd \n";
	foreach my $node (@$nodes) {
        #collect the node infomation needed for each node, some info
		my $mgt;
		my $ref_nodehm = $nodehmhash->{$node}->[0];
		if ($ref_nodehm) {
			if ($ref_nodehm->{'power'}) {
				$mgt = $ref_nodehm->{'power'};
			} elsif ($ref_nodehm->{'mgt'}) {
				$mgt = $ref_nodehm->{'mgt'};
			}
		}

		my ($bmc, $bmc_user, $bmc_password, $mac, $cpu, $memory, $disk);
		if (($mgt) && ($mgt eq 'ipmi')) { 
			my $ref_ipmi = $tmp_ipmi->{$node}->[0]; 
			if ($ref_ipmi) {
				if (exists($ref_ipmi->{bmc})) {
					$bmc = $ref_ipmi->{bmc};
				}
				if (exists($ref_ipmi->{username})) {
					$bmc_user = $ref_ipmi->{username};
					if (exists($ref_ipmi->{password})) {
						$bmc_password = $ref_ipmi->{password};
					} 
				} else { #take the default if they cannot be found on ipmi table
					if ($d_bmcuser) { $bmc_user = $d_bmcuser; }
					if ($d_bmcpasswd) { $bmc_password = $d_bmcpasswd; }
				}
			}
		} # else { # for hardware control point other than ipmi, just fake it in OpenStack.
			#$bmc = "0.0.0.0";
			#$bmc_user = "xCAT";
			#$bmc_password = "xCAT";
		#}

		my $ref_mac = $tmp_mac->{$node}->[0]; 
	    if ($ref_mac) {
			if (exists($ref_mac->{mac})) {
				$mac = $ref_mac->{mac};
			}
		}

		$ref_hwinv = $tmp_hwinv->{$node}->[0]; 
	    if ($ref_hwinv) {
			if (exists($ref_hwinv->{cpucount})) {
				$cpu = $ref_hwinv->{cpucount};
			}
			if (exists($ref_hwinv->{memory})) {
				$memory = $ref_hwinv->{memory};
                #TODO: what if the unit is not in MB? We need to convert it to MB
				$memory =~ s/MB|mb//g;
			}
			if (exists($ref_hwinv->{disksize})) {
				#The format of the the disk size is: sda:250GB,sdb:250GB or just 250GB
                #We need to get the size of the first one
				$disk = $ref_hwinv->{disksize};
				my @a = split(',', $disk);
				my @b = split(':', $a[0]);
				if (@b > 1) {
					$disk = $b[1];
				} else {
					$disk = $b[0];
				}
                #print "a=@a, b=@b\n";
                #TODO: what if the unit is not in GB? We need to convert it to MB
				$disk =~ s/GB|gb//g;
			}
		}

		#some info are mendatory
        if (!$mac) {
			$callback->({error=>["Mac address is not defined in the mac table for node $node."],errorcode=>[1]});
			next;
		}
		if (!$cpu) {
			#default cpu count is 1
			$cpu = 1;
		}
		if (!$memory) {
			#default memory size is 1024MB=1GB
			$memory = 1024;
		}
		if (!$disk) {
			#default disk size is 1GB
			$disk = 1;
		}				
		
		if ($verbose) {
			my $rsp;
			push @{$rsp->{data}}, "Attributes gathered from the xCAT database:";
			push @{$rsp->{data}}, "  bmc=$bmc";
			push @{$rsp->{data}}, "  bmc_user=$bmc_user";
			push @{$rsp->{data}}, "  bmc_password=$bmc_password";
			push @{$rsp->{data}}, "  mac=$mac";
			push @{$rsp->{data}}, "  cpu=$cpu";
			push @{$rsp->{data}}, "  memory=$memory";
			push @{$rsp->{data}}, "  disk=$disk";
			xCAT::MsgUtils->message("I", $rsp, $callback);
		}

		#call OpenStack command to add the node into the OpenStack as
        #a baremetal node.
        my $cmd_tmp = "nova baremetal-node-create";
		if ($bmc) {
			#make sure it is an ip address
			if (($bmc !~ /\d+\.\d+\.\d+\.\d+/) && ($bmc !~ /:/)) {
				$bmc =  xCAT::NetworkUtils->getipaddr($bmc);
			}
			$cmd_tmp .= " --pm_address=$bmc";			
		}
		if ($bmc_user) {
			$cmd_tmp .= " --pm_user=$bmc_user";
		}
		if ($bmc_password) {
			$cmd_tmp .= " --pm_password=$bmc_password";
		}
		$cmd_tmp .= " $host $cpu $memory $disk $mac";
 
		my $cmd = qq~$cmd_tmp~;
		if ($verbose) {
			my $rsp;
			push @{$rsp->{data}}, "The command to run on $host:";
			push @{$rsp->{data}}, "  $cmd";
			push @{$rsp->{data}}, "  ";
			xCAT::MsgUtils->message("I", $rsp, $callback);
		}
		#print "cmd=$cmd\n";
		my $output =
			xCAT::InstUtils->xcmd($callback, $doreq, "xdsh", [$host], $cmd, 0);
		if ($::RUNCMD_RC != 0) {
			my $rsp;
			push @{$rsp->{data}}, "OpenStack creating baremetal node $node:";
			push @{$rsp->{data}}, "$output";
			push @{$rsp->{data}}, "The command was: $cmd";
			xCAT::MsgUtils->message("E", $rsp, $callback);
		} else {
			if (($verbose) && ($output)) {
				my $rsp;
				push @{$rsp->{data}}, "$output";
				push @{$rsp->{data}}, "  ";
				xCAT::MsgUtils->message("I", $rsp, $callback);
			}
		}

	}
}


#-------------------------------------------------------------------------------

=head3  opsaddimage
     This function takes the xCAT nodes and register them
     as the OpenStack baremetal nodes
=cut

#-------------------------------------------------------------------------------
sub opsaddimage {
	my $request = shift;
	my $callback = shift;
	my $doreq = shift;
	
	@ARGV = @{$request->{arg}};
	Getopt::Long::Configure("bundling");
	Getopt::Long::Configure("no_pass_through");
	
	my $help;
	my $version;
	my $verbose;
	#my $cloud;
	my $ops_img_names;
    my $controller;
	
    if(!GetOptions(
            'h|help'      => \$help,
            'v|version'   => \$version,
            'V|verbose'   => \$verbose,
            'c=s'         => \$controller,
			'n=s'         => \$ops_img_names,
       ))
    {
        &opsaddimage_usage($callback);
        return 1;
    }
    # display the usage if -h or --help is specified
    if ($help) {
        &opsaddimage_usage($callback);
        return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($version)
    {
        my $rsp={};
        $rsp->{data}->[0]= xCAT::Utils->Version();
        $callback->($rsp);
        return 0;
    }
	
	if (@ARGV ==0) {
		$callback->({error=>["Please specify an image name or a list of image names."],errorcode=>[1]});
		return 1;  
	}

	#make sure the input cloud name is valid.
	#if (!$cloud) {
	#	$callback->({error=>["Please specify the name of the cloud with -c flag."],errorcode=>[1]});
	#	return 1;  
	#} else {
	#	my $cloudstab = xCAT::Table->new('clouds', -create => 0);
	#	my @et = $cloudstab->getAllAttribs('name', 'controller');
	#	if(@et) {
	#		foreach my $tmp_et (@et) {
	#			if ($tmp_et->{name} eq $cloud) {
	#				if ($tmp_et->{controller}) {
	#					$controller = $tmp_et->{controller};
	#					last;
	#				} else {
	#					$callback->({error=>["Please specify the controller in the clouds table for the cloud: $cloud."],errorcode=>[1]});
	#					return 1;  	
	#				}
	#			}
	#		}
	#	}
	
	if (!$controller) {
		$callback->({error=>["Please specify the OpenStack controller node name with -c."],errorcode=>[1]});
		return 1;  			
	}
	#}

	#make sure that the images from the command are valid image names
    @images = split(',', $ARGV[0]);
    @new_names = ();
	if ($ops_img_names) {
		@new_names = split(',', $ops_img_names);
	}
	#print "images=@images, new image names=@new_names, controller=$controller\n";

	my $image_hash = {};
    my $osimgtab = xCAT::Table->new('osimage', -create => 0);
    my @et = $osimgtab->getAllAttribs('imagename');
	if(@et) {
		foreach my $tmp_et (@et) {
			$image_hash->{$tmp_et->{imagename}}{'xCAT'} = 1;
		}
	}
	my @bad_images;
	foreach my $image (@images) {
		if (!exists($image_hash->{$image})) {
			push @bad_images, $image;
		}
	}
	if (@bad_images > 0) {
		$callback->({error=>["The following images cannot be found in xCAT osimage table:\n  " . join("\n  ", @bad_images) . "\n"],errorcode=>[1]});
		return 1;  
	}

	my $index=0;
 	foreach my $image (@images) {
		my $new_name = shift(@new_names);
		if (!$new_name) {
			$new_name = $image; #the default new name is xCAT image name
		}
        my $cmd_tmp = "glance image-create --name $new_name --public --disk-format qcow2 --container-format bare --property xcat_image_name=\'$image\' < /tmp/$image.qcow2";

		my $cmd = qq~touch /tmp/$image.qcow2;$cmd_tmp~;
		if ($verbose) {
			my $rsp;
			push @{$rsp->{data}}, "The command to run on $controller:";
			push @{$rsp->{data}}, "   $cmd";
			push @{$rsp->{data}}, "  ";
			xCAT::MsgUtils->message("I", $rsp, $callback);
		}
		my $output =
			xCAT::InstUtils->xcmd($callback, $doreq, "xdsh", [$controller], $cmd, 0);
		if ($::RUNCMD_RC != 0) {
			my $rsp;
			push @{$rsp->{data}}, "OpenStack creating image $new_name:";
			push @{$rsp->{data}}, "$output";
			push @{$rsp->{data}}, "The command was: $cmd";
			xCAT::MsgUtils->message("E", $rsp, $callback);
		} else {
			if (($verbose) && ($output)) {
				my $rsp;
				push @{$rsp->{data}}, "$output";
				push @{$rsp->{data}}, "  ";
				xCAT::MsgUtils->message("I", $rsp, $callback);
			}
		}		 
		my $cmd1 = qq~rm /tmp/$image.qcow2~;
		if ($verbose) {
			my $rsp;
			push @{$rsp->{data}}, "The command to run on $controller:";
			push @{$rsp->{data}}, "  $cmd1";
			push @{$rsp->{data}}, "  ";
			xCAT::MsgUtils->message("I", $rsp, $callback);
		}
		my $output1 =
			xCAT::InstUtils->xcmd($callback, $doreq, "xdsh", [$controller], $cmd1, 0);
		if (($verbose) && ($output1)) {
			my $rsp;
			push @{$rsp->{data}}, "$output1";
			push @{$rsp->{data}}, "  ";
			xCAT::MsgUtils->message("I", $rsp, $callback);
		}
	}
}

#-------------------------------------------------------------------------------

=head3  deploy_ops_bm_node
	This is a internel command called by OpenStack xCAT-baremetal driver. 
	It prepares the node by adding the config_ops_bm_node postbootscript 
	to the postscript table for the node, then call nodeset and then boot 
	the node up.
=cut

#-------------------------------------------------------------------------------
sub deploy_ops_bm_node {
	my $request = shift;
	my $callback = shift;
	my $doreq = shift;
	
	@ARGV = @{$request->{arg}};
	Getopt::Long::Configure("bundling");
	Getopt::Long::Configure("no_pass_through");

	my $node = $request->{node}->[0];
	
	my $help;
	my $version;
	my $img_name;
    my $hostname;
	my $fixed_ip;
	my $netmask;
	
    if(!GetOptions(
            'h|help'      => \$help,
            'v|version'   => \$version,
            'image=s'     => \$img_name,
			'host=s'      => \$hostname,
			'ip=s'        => \$fixed_ip,
			'mask=s'      => \$netmask,
       ))
    {
        &deploy_ops_bm_node_usage($callback);
        return 1;
    }
    # display the usage if -h or --help is specified
    if ($help) {
        &deploy_ops_bm_node_usage($callback);
        return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($version)
    {
        my $rsp={};
        $rsp->{data}->[0]= xCAT::Utils->Version();
        $callback->($rsp);
        return 0;
    }
	#print "node=$node, image=$img_name, host=$hostname, ip=$fixed_ip, mask=$netmask\n";

	#validate the image name
    my $osimagetab = xCAT::Table->new('osimage', -create=>1);
	my $ref = $osimagetab->getAttribs({imagename => $img_name}, 'imagename');
	if (!$ref) {
		$callback->({error=>["Invalid image name: $img_name."],errorcode=>[1]});
		return 1;  
	}

	#check if the fixed ip is within the xCAT management network.
	#get the master ip address for the node then check if the master ip and 
	#the OpenStack fixed_ip are on the same subnet.
	#my $same_nw = 0;
	#my $master = xCAT::TableUtils->GetMasterNodeName($node);
	#my $master_ip = xCAT::NetworkUtils->toIP($master);
	#if (xCAT::NetworkUtils::isInSameSubnet($master_ip, $fixed_ip, $netmask, 0)) {
	#	$same_nw = 1;
	#}
	   
	
	#add config_ops_bm_node to the node's postbootscript
	my $script = "config_ops_bm_node $hostname $fixed_ip $netmask";
	add_postscript($callback, $node, $script);

    #run nodeset 
	my $cmd = qq~osimage=$img_name~;
	my $output = xCAT::Utils->runxcmd(
		{command => ["nodeset"],
		 node    => [$node], 
		 arg     => [$cmd]},
		$doreq, -1, 1);
	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "nodeset:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
		return 1;
	}		
 
    #deploy the node now, supported nodehm.mgt values: ipmi, blade,fsp, hmc.
    my $hmtab  = xCAT::Table->new('nodehm');
	my $hment = $hmtab->getNodeAttribs($node,['mgt']);
	if ($hment && $hment->{'mgt'}) {
		my $mgt = $hment->{'mgt'};
		if ($mgt eq 'ipmi') { 
			deploy_bmc_node($callback, $doreq, $node);
		} elsif (($mgt eq 'blade') || ($mgt eq 'fsp')) {
			deploy_blade($callback, $doreq, $node);
		} elsif ($mgt eq 'hmc') {
			deploy_hmc_node($callback, $doreq, $node);
		} else {
			my $rsp;
			push @{$rsp->{data}}, "Node $node: nodehm.mgt=$mgt is not supported in the OpenStack cloud.";
			xCAT::MsgUtils->message("E", $rsp, $callback);
			return 1;
		}
	} else {
		#nodehm.mgt must setup for node 
		my $rsp;
		push @{$rsp->{data}}, "Node $node: nodehm.mgt cannot be empty in order to deploy.";
		xCAT::MsgUtils->message("E", $rsp, $callback);
		return 1;
	}

}

# Deploy a rack-mounted node
sub deploy_bmc_node {
	my $callback = shift;
	my $doreq = shift;
	my $node = shift;

    #set boot order
	my $cmd = qq~net~;
	my $output = xCAT::Utils->runxcmd(
		{command => ["rsetboot"],
		 node    => [$node], 
		 arg     => [$cmd]},
		$doreq, -1, 1);
	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "rsetboot:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
	}		
	
    #reboot the node
	my $cmd = qq~boot~;
	my $output = xCAT::Utils->runxcmd(
		{command => ["rpower"],
		 node    => [$node], 
		 arg     => [$cmd]},
		$doreq, -1, 1);
	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "rpower:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
		return 1;
	}
}

# Deploy a blade or fsp controlled node
sub deploy_blade {
	my $callback = shift;
	my $doreq = shift;
	my $node = shift;

    #set boot order
	my $cmd = qq~net~;
	my $output = xCAT::Utils->runxcmd(
		{command => ["rbootseq"],
		 node    => [$node], 
		 arg     => [$cmd]},
		$doreq, -1, 1);
	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "rbootseq:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
	}		
	
    #reboot the node
	my $cmd = qq~boot~;
	my $output = xCAT::Utils->runxcmd(
		{command => ["rpower"],
		 node    => [$node], 
		 arg     => [$cmd]},
		$doreq, -1, 1);
	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "rpower:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
		return 1;
	}	
}

# Deploy a node controlled by HMC
sub deploy_hmc_node {
	my $callback = shift;
	my $doreq = shift;
	my $node = shift;

	my $output = xCAT::Utils->runxcmd(
		{command => ["rnetboot"],
		 node    => [$node]},
		$doreq, -1, 1);
	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "rnetboot:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
		return 1;
	}	
}


#-------------------------------------------------------------------------------

=head3  cleanup_ops_bm_node
	This is a internel command called by OpenStack xCAT-baremetal driver.
	It undoes all the changes made by deploy_ops_bm_node command. It removes
	the config_ops_bmn_ode postbootscript from the postscript table for the 
	node, removes the alias ip and then power off the node.
=cut

#-------------------------------------------------------------------------------
sub cleanup_ops_bm_node {
	my $request = shift;
	my $callback = shift;
	my $doreq = shift;
	
	@ARGV = @{$request->{arg}};
	Getopt::Long::Configure("bundling");
	Getopt::Long::Configure("no_pass_through");

	my $node = $request->{node}->[0];
	
	my $help;
	my $version;
 	my $fixed_ip;
	
    if(!GetOptions(
            'h|help'      => \$help,
            'v|version'   => \$version,
			'ip=s'        => \$fixed_ip,
       ))
    {
        &cleanup_ops_bm_node_usage($callback);
        return 1;
    }
    # display the usage if -h or --help is specified
    if ($help) {
        &cleanup_ops_bm_node_usage($callback);
        return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($version)
    {
        my $rsp={};
        $rsp->{data}->[0]= xCAT::Utils->Version();
        $callback->($rsp);
        return 0;
    }
	#print "node=$node, ip=$fixed_ip\n";   
	
	#removes the config_ops_bm_node postbootscript from the postscripts table
	remove_postscript($callback, $node, "config_ops_bm_node");


	#run updatenode to remove the ip alias 
	my $cmd = qq~-P deconfig_ops_bm_node $fixed_ip~;
	my $output = xCAT::Utils->runxcmd(
		{command => ["updatenode"],
		 node    => [$node], 
		 arg     => [$cmd]},
		$doreq, -1, 1);
	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "updatenode:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
	}
		
    #turn the node power off
	$ssh_ok = 0;
	my $cmd = qq~stat~;
	my $output = xCAT::Utils->runxcmd(
		{command => ["rpower"],
		 node    => [$node], 
		 arg     => [$cmd]},
		$doreq, -1, 1);

	if ($::RUNCMD_RC != 0) {
		my $rsp;
		push @{$rsp->{data}}, "rpower:";
		push @{$rsp->{data}}, "$output";
		xCAT::MsgUtils->message("E", $rsp, $callback);
		return 1;
	}   else {
		if ($output !~ /: off/) {
			#power off the node
			my $cmd = qq~off~;
			my $output = xCAT::Utils->runxcmd(
				{command => ["rpower"],
				 node    => [$node], 
				 arg     => [$cmd]},
				$doreq, -1, 1);
			if ($::RUNCMD_RC != 0) {
				my $rsp;
				push @{$rsp->{data}}, "rpower:";
				push @{$rsp->{data}}, "$output";
				xCAT::MsgUtils->message("E", $rsp, $callback);
				return 1;
			}		
		}
	}
}

#-------------------------------------------------------
=head3  add_postscript

	It adds the 'config_ops_bm_node' postbootscript to the 
	postscript table for the given node.

=cut
#-------------------------------------------------------
sub  add_postscript {
    my $callback=shift;
    my $node=shift;
	my $script=shift;
	#print "script=$script\n";

    my $posttab=xCAT::Table->new("postscripts", -create =>1);
	my %setup_hash;
	my $ref = $posttab->getNodeAttribs($node,[qw(postscripts postbootscripts)]);
	my $found=0;
	if ($ref) {
		if (exists($ref->{postscripts})) {
		    my @a = split(/,/, $ref->{postscripts});
		    if (grep(/^config_ops_bm_node/, @a)) {
				$found = 1;
				if (!grep(/^$script$/, @a)) {
					#not exact match, must replace it with the new script
					for (@a) {
						s/^config_ops_bm_node.*$/$script/;
					}
					my $new_post = join(',', @a);
					$setup_hash{$node}={postscripts=>"$new_post"};
				}
			}
		}
		

		if (exists($ref->{postbootscripts})) {
		    my $post=$ref->{postbootscripts};
		    my @old_a=split(',', $post);
		    if (grep(/^config_ops_bm_node/, @old_a)) {
				if (!grep(/^$script$/, @old_a)) {
					#not exact match, will replace it with new script
					for (@old_a) {
						s/^config_ops_bm_node.*$/$script/;
					}
					my $new_postboot = join(',', @old_a);
					$setup_hash{$node}={postbootscripts=>"$new_postboot"};
				}
		    } else {
				if (! $found) {
					$setup_hash{$node}={postbootscripts=>"$post,$script"};
				}
		    }
		} else {
            if (! $found) {
				$setup_hash{$node}={postbootscripts=>"$script"};
			}
		}
	} else {
		$setup_hash{$node}={postbootscripts=>"$script"};
	}

	if (keys(%setup_hash) > 0) {
	    $posttab->setNodesAttribs(\%setup_hash);
	}

    return 0;
}

#-------------------------------------------------------
=head3  remove_postscript

	It removes the 'config_ops_bm_node' postbootscript from 
	the postscript table for the given node.

=cut
#-------------------------------------------------------
sub  remove_postscript {
    my $callback=shift;
    my $node=shift;
	my $script=shift;

    my $posttab=xCAT::Table->new("postscripts", -create =>1);
	my %setup_hash;
	my $ref = $posttab->getNodeAttribs($node,[qw(postscripts postbootscripts)]);
	my $found=0;
	if ($ref) {
		if (exists($ref->{postscripts})) {
		    my @old_a = split(/,/, $ref->{postscripts});
		    my @new_a = grep(!/^$script/, @old_a);
			if (scalar(@new_a) != scalar(@old_a)) {
				my $new_post = join(',', @new_a);
				$setup_hash{$node}={postscripts=>"$new_post"};
			}
		}

		if (exists($ref->{postbootscripts})) {
		    my @old_b = split(/,/, $ref->{postbootscripts});
		    my @new_b = grep(!/^$script/, @old_b);
			if (scalar(@new_b) != scalar(@old_b)) {
				my $new_post = join(',', @new_b);
				$setup_hash{$node}={postbootscripts=>"$new_post"};
			}
		}

	}
	
	if (keys(%setup_hash) > 0) {
	    $posttab->setNodesAttribs(\%setup_hash);
	}

    return 0;
}


#-------------------------------------------------------------------------------

=head3  opsaddbmnode_usage
	The usage text for opsaddbmnode command.
=cut

#-------------------------------------------------------------------------------
sub opsaddbmnode_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: opsaddbmnode -h";
    $rsp->{data}->[1]= "       opsaddbmnode -v";
    $rsp->{data}->[2]= "       opsaddbmnode <noderange> -s <service_host> [-V]";
    $cb->($rsp);
}


#-------------------------------------------------------------------------------

=head3  opsaddimage_usage
	The usage text for opsaddimage command.
=cut

#-------------------------------------------------------------------------------
sub opsaddimage_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: opsaddimage -h";
    $rsp->{data}->[1]= "       opsaddimage -v";
    $rsp->{data}->[2]= "       opsaddimage <image1,image2...> [-n <new_name1,new_name2...> -c <controller> [-V]";
    $cb->($rsp);
}

#-------------------------------------------------------------------------------

=head3   deploy_ops_bm_node_usage
	The usage text for deploy_ops_bm_node command.
=cut

#-------------------------------------------------------------------------------
sub deploy_ops_bm_node_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: deploy_ops_bm_node -h";
    $rsp->{data}->[1]= "       deploy_ops_bm_node -v";
    $rsp->{data}->[2]= "       deploy_ops_bm_node <node> --image <image_name> --host <ops_hostname> --ip <ops_fixed_ip> --mask <netmask>";
    $cb->($rsp);
}

#-------------------------------------------------------------------------------

=head3  cleanup_ops_bm_node_usage
	The usage text cleanup_ops_bm_node command.
=cut

#-------------------------------------------------------------------------------
sub cleanup_ops_bm_node_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: cleanup_ops_bm_node -h";
    $rsp->{data}->[1]= "       cleanup_ops_bm_node -v";
    $rsp->{data}->[2]= "       cleanup_ops_bm_node <node> [--ip <ops_fixed_ip>]";
    $cb->($rsp);
}

1;