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

# This module is used to support the rhev
# The rhev-m is used as the agent to manage the storage domain, network, rhev-h
# There are concepts Datacenter and Cluster for the rhev, SD and network belongs to DC, 
#   rhev-h (host) belongs to cluster
#
# When installing rhev-h, it will try to register to rhev-m. From xCAT point of view, just approve.
# The fence must be configured for the rhev-h to enable the SD management, otherwise when
#    when the SPM failed, the failure take over for the SPM cannot happen automatically.
#
# The SD needs to be created with a host as the SPM (Storage Pool Manager), when the current
#   SPM failed, SPM will switch to another available rhev-h.
#
# Add rhevh to the management 
#   for the rhevh, the adding should be done automatically that specify the rhev-m infor when installing of the rhev-h
# Need to run the approval for the host to be added to the rhevm
#
# The features that are not used
    # tag, to catalog the resources with tag
    # role, for access permission
    # domain, for user/group management
#TODO: handle the functions base on the version
#TODO: add the support of iscsi storage domain



package xCAT_plugin::rhevm;

use strict;
use warnings;

use POSIX qw(WNOHANG nice);
use POSIX qw(WNOHANG setsid :errno_h);
use IO::Select;
require IO::Socket::SSL; IO::Socket::SSL->import('inet4');
use Time::HiRes qw(gettimeofday sleep);

use Fcntl qw/:DEFAULT :flock/;
use File::Path;
use File::Copy;

use Getopt::Long;
Getopt::Long::Configure("bundling");
Getopt::Long::Configure("pass_through");

use HTTP::Headers;
use HTTP::Request;
use XML::LibXML;

use xCAT::Utils;
use xCAT::TableUtils;
use xCAT::ServiceNodeUtils;

use xCAT::Table;
use xCAT::MsgUtils;
use xCAT::Usage;

sub handled_commands{
    return {
        copycd => 'rhevm',
        mkinstall => "nodetype:os=(rhevh.*)",
        rpower => 'nodehm:power,mgt',
        rsetboot => 'nodehm:mgt',
        rmigrate => 'nodehm:mgt',
        cfgve => 'rhevm',
        lsve => 'rhevm',
        lsvm => ['hypervisor:type=(rhev.*)','nodehm:mgt'],
        mkvm => 'nodehm:mgt',
        rmvm => 'nodehm:mgt',
        clonevm => 'nodehm:mgt',
        #rinv => 'nodehm:mgt',
        chvm => 'nodehm:mgt',
        #rshutdown => "nodetype:os=(rhev.*)",
        rmhypervisor => ['hypervisor:type','nodetype:os=(rhev.*)'],
        chhypervisor => ['hypervisor:type','nodetype:os=(rhev.*)'],
        rhevhupdateflag => "nodetype:os=(rhevh.*)",
        getrvidparms => 'nodehm:mgt',
    };
}

my $verbose;
my $global_callback;

sub preprocess_request {
    my $request = shift;
    my $callback = shift;
    
    #if already preprocessed, go straight to request
    if ((defined($request->{_xcatpreprocessed}->[0]))
        && ($request->{_xcatpreprocessed}->[0] == 1)) {
        return [$request];
    }

    unless ($request and $request->{command} and $request->{command}->[0]) { return; }
    if ($request->{command}->[0] eq 'copycd') {
    	  return [$request];
    }

    my $nodes = $request->{node};
    my $command = $request->{command}->[0];
    my $extraargs = $request->{arg};

    if ($extraargs) {
        @ARGV=@{$extraargs};
        my $help;
        my $ver;
        GetOptions("V" => \$verbose, 'h|help' => \$help, 'v|version' => \$ver); 
        $global_callback = $callback;
        if ($help) {
            my $usage_string = xCAT::Usage->getUsage($command);
            my $rsp;
            push @{$rsp->{data}}, $usage_string;
            xCAT::MsgUtils->message("I", $rsp, $callback);
            return ();
        }
        if ($ver) {
            my $ver_string = xCAT::Usage->getVersion($command);
            my $rsp;
            push @{$rsp->{data}}, $ver_string;
            xCAT::MsgUtils->message("I", $rsp, $callback);
            return ();
        }
    }

    # Read the user password for the rhevm
    # Only support the general password in passwd table
    my $passtab = xCAT::Table->new('passwd');
    my ($rhevmadminpw,$rhevhrootpw, $rhevhadminpw);
    if ($passtab) {
        my $pw = $passtab->getAttribs({'key'=>'rhevm', 'username'=>'admin'}, 'password');
        if (defined($pw)) {
            $rhevmadminpw = $pw->{password};
        }
        # The $rhevmadminpw must be unencrypted, since http need this to generate the authorized key
        if (!$rhevmadminpw) {
            my $rsp;
            push @{$rsp->{data}}, "The unencrypted password of \'admin\' for the rhevm much be set in the passwd table.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return ();
        } 

        $pw = $passtab->getAttribs({'key'=>'rhevh', 'username'=>'admin'}, 'password');
        if (defined($pw)) {
            $rhevhadminpw = $pw->{password};
        }
        if (!$rhevhadminpw) {
            my $rsp;
            push @{$rsp->{data}}, "The password of \'admin\' for the rhevh much be set in the passwd table.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return ();
        } else {
            $rhevhadminpw =  authpw($rhevhadminpw);
        }
        
        $pw = $passtab->getAttribs({'key'=>'rhevh', 'username'=>'root'}, 'password');
        if (defined($pw)) {
            $rhevhrootpw = $pw->{password};
            if ($rhevhrootpw) {
                $rhevhrootpw = authpw($rhevhrootpw);
            }
        }
    }

    # Get the host for the nodes
    my $vmtab = xCAT::Table->new("vm");
    my $vmtabhash = $vmtab->getNodesAttribs($nodes,['host','mgr']);
    my $hyptab = xCAT::Table->new("hypervisor");
    my $hyptabhash = $hyptab->getNodesAttribs($nodes,['type','mgr']);

    # The hash that use hyp as key
    # In following example: rhevm1 is rhev-m;  rhevh1 and rhevh2 are rhev-h
    # vm11 is vm which located at rhevh1, vm12 is vm which located at rhevh2
    # vm1 has not specific host to bind
    # The user and password for rhev-m and rhev-h also specified
    #  |0  'rhevm1'
    #  |1  HASH(0x99066e0)
    #  |   'host' => HASH(0x9906230)
    #  |      'rhevh1' => HASH(0x99064a0)
    #  |         'adminpw' => '$1$k343MVXm$tZrjCk5GUJgRguNxdyIrT0'
    #  |         'node' => ARRAY(0x98f91a8)
    #  |            0  'vm11'
    #  |         'rootpw' => '$1$k3Yvim3b$9NLOSVlIiQY3ZYluT.CqP/'
    #  |      'rhevh2' => HASH(0x99064e8)
    #  |         'adminpw' => '$1$k343MVXm$tZrjCk5GUJgRguNxdyIrT0'
    #  |         'node' => ARRAY(0x9905c60)
    #  |            0  'vm12'
    #  |         'rootpw' => '$1$k3Yvim3b$9NLOSVlIiQY3ZYluT.CqP/'
    #  |   'node' => ARRAY(0x98ff378)
    #  |      0  'vm1'
    #  |   'pw' => '$1$9IXfmatc$Vcoy23AF5q0BcBE0cB3Uq/'
    #  |   'user' => 'admin'
    my %rhevm_hash;

    foreach my $node (@$nodes){
        my $vment = $vmtabhash->{$node}->[0];
        my $hypent = $hyptabhash->{$node}->[0];
        if (defined($vment->{'mgr'})) {    # is a vm and has rhevm info
            $rhevm_hash{$vment->{'mgr'}}->{'user'} = "admin";
            $rhevm_hash{$vment->{'mgr'}}->{'pw'} = $rhevmadminpw;
            if (defined($vment->{'host'})) {    # is a vm and has rhevm, host info
                push @{$rhevm_hash{$vment->{'mgr'}}->{'host'}->{$vment->{'host'}}->{'node'}}, $node;
                $rhevm_hash{$vment->{'mgr'}}->{'host'}->{$vment->{'host'}}->{'adminpw'} = $rhevhadminpw;
                $rhevm_hash{$vment->{'mgr'}}->{'host'}->{$vment->{'host'}}->{'rootpw'} = $rhevhrootpw;
            } else {
                push @{$rhevm_hash{$vment->{'mgr'}}->{'node'}}, $node;
            }
        } elsif (defined($hypent->{'mgr'})) {    # is a rhevh
            $rhevm_hash{$hypent->{'mgr'}}->{'user'} = "admin";
            $rhevm_hash{$hypent->{'mgr'}}->{'pw'} = $rhevmadminpw;
            push @{$rhevm_hash{$hypent->{'mgr'}}->{'host'}->{$node}->{'node'}}, $node;
            $rhevm_hash{$hypent->{'mgr'}}->{'host'}->{$node}->{'adminpw'} = $rhevhadminpw;
            $rhevm_hash{$hypent->{'mgr'}}->{'host'}->{$node}->{'rootpw'} = $rhevhrootpw;
        } elsif ($command eq 'lsvm') {    # hope the node is a rhevm, that only the lsvm can be run to display
        } else {
            my $rsp;
            push @{$rsp->{data}}, "$node: Missing the management point in \'vm.mgr\' or \'hypervisor.mgr\'.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
        }
    }

    # For the lsve or cfgve command, get the object from argument
    if ($command =~ /^(cfgve|lsve)$/) {
        # -t type -o obj -m mgr 
        my $mgr;
        unless ($extraargs) {
            return ();
        }
        @ARGV=@{$extraargs};
        GetOptions("m=s" => \$mgr); #use mgr to know where to dispatch this request
        if ($mgr) {
            $rhevm_hash{$mgr}->{'user'} = "admin";
            $rhevm_hash{$mgr}->{'pw'} = $rhevmadminpw;
        } else {
            my $rsp;
            push @{$rsp->{data}}, "The flag -m is necessary to perform the command.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return ();
        }
    }

    # Prepare the request for each service node
    # The dispatch depends on the rhevm. Since the operation is in serial, so no need to use the service node.
    my @requests;
    my @rhevms=keys(%rhevm_hash);
    my $sn = xCAT::ServiceNodeUtils->get_ServiceNode(\@rhevms, 'xcat', "MN");
    foreach my $snkey (keys %$sn){
        my $reqcopy = {%$request};
        $reqcopy->{'_xcatdest'} = $snkey;
        $reqcopy->{_xcatpreprocessed}->[0] = 1;
        # Search the node base on the hypervisor
        my $rhevms=$sn->{$snkey};
        my @moreinfo=();
        my @nodes=();
        foreach my $rhevm (@$rhevms) {
            #[rhevm][user_rhevm][pw_rhevm][rhevh][user_rhevh][pw_rhevh][nodes]
            my $data_rhevm = "[$rhevm][$rhevm_hash{$rhevm}->{'user'}][$rhevm_hash{$rhevm}->{'pw'}]";
            if (defined ($rhevm_hash{$rhevm}->{'host'})) {
                foreach my $host (keys %{$rhevm_hash{$rhevm}->{'host'}}) {
                    my $data_rhevh = $data_rhevm."[$host][$rhevm_hash{$rhevm}->{'host'}->{$host}->{'adminpw'}][$rhevm_hash{$rhevm}->{'host'}->{$host}->{'rootpw'}][".join(',',@{$rhevm_hash{$rhevm}->{'host'}->{$host}->{'node'}})."]";
                    push @moreinfo, $data_rhevh;
                    push @nodes, @{$rhevm_hash{$rhevm}->{'host'}->{$host}->{'node'}};
                }
            }
            if (defined  ($rhevm_hash{$rhevm}->{'node'})) {
                my $data_node = $data_rhevm."[][][][".join(',',@{$rhevm_hash{$rhevm}->{'node'}})."]";
                push @moreinfo, $data_node;
                push @nodes, @{$rhevm_hash{$rhevm}->{'node'}};
            }
            unless (defined ($rhevm_hash{$rhevm}->{'host'}) || defined  ($rhevm_hash{$rhevm}->{'node'})) {
                push @moreinfo, $data_rhevm."[][][][]";
            }
        }
        if (scalar @nodes) {
            $reqcopy->{node} = \@nodes;
        }
        $reqcopy->{moreinfo}=\@moreinfo;
        if ($verbose) {
            $reqcopy->{verbose} = 1;
        }
        push @requests, $reqcopy;
    }

    return \@requests;
}


sub process_request {
    my $request = shift;
    my $callback = shift;
    my $subreq = shift;

    my $command = $request->{command}->[0];
    my $args = $request->{arg};
    my $nodes = $request->{node};

    $verbose = $request->{verbose};
    
    if($command eq 'copycd'){
        return copycd($request,$callback);
    }  elsif ($command eq 'rhevhupdateflag') {
        # handle the command to update bootloader configuration file for rhevh installation
        return rhevhupdateflag($request,$callback,$subreq);
    }

    my $moreinfo;
    if ($request->{moreinfo}) { 
        $moreinfo=$request->{moreinfo}; 
    } else {
        my $rsp;
        push @{$rsp->{data}}, "";
        xCAT::MsgUtils->message("I", $rsp, $callback);
    }

    my %rhevm_hash;
    foreach my $info (@$moreinfo) {
        $info=~/^\[(.*?)\]\[(.*?)\]\[(.*?)\]\[(.*?)\]\[(.*?)\]\[(.*?)\]\[(.*?)\]/;
        my $rhevm=$1;
        my $rhevmuser = $2;
        my $rhevmpw = $3;
        my $rhevh=$4;
        my $rhevhadminpw = $5;
        my $rhevhrootpw = $6;
        my @nodes;
        if ($7) { @nodes =split(',', $7) };

        $rhevm_hash{$rhevm}->{name} = $rhevm;
        $rhevm_hash{$rhevm}->{user} = $rhevmuser;
        $rhevm_hash{$rhevm}->{pw} = $rhevmpw;
        if ($rhevh) {
            $rhevm_hash{$rhevm}->{host}->{$rhevh}->{name} = $rhevh;
            $rhevm_hash{$rhevm}->{host}->{$rhevh}->{adminpw} = $rhevhadminpw;
            $rhevm_hash{$rhevm}->{host}->{$rhevh}->{rootpw} = $rhevhrootpw;
            push @{$rhevm_hash{$rhevm}->{host}->{$rhevh}->{node}}, @nodes;
        } elsif (@nodes) {
            push @{$rhevm_hash{$rhevm}->{node}}, @nodes;
        }
    }

    # TODO: Plan to make long http connection to the every rhevm, but it does not work well
    foreach my $rhevm (keys %rhevm_hash) {
        # TODO fork process for each rhev-m
        # get the ca.crt for the specific rhevm
        if (! -r "/etc/xcat/rhevm/$rhevm/ca.crt") {
            if (! -d "/etc/xcat/rhevm/$rhevm") {
                mkpath ("/etc/xcat/rhevm/$rhevm");
            }
            my $cmd = "cd /etc/xcat/rhevm/$rhevm/; wget -q http://$rhevm:8080/ca.crt";
            xCAT::Utils->runcmd($cmd, -1);
            if ($::RUNCMD_RC != 0) {
                my $rsp;
                push @{$rsp->{data}}, "Could not get the CA certificate from http://$rhevm:8080/ca.crt.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                return undef;
            }
        }
   }

    if($command eq 'mkinstall'){
        mkinstall($request, $callback, \%rhevm_hash);
    } elsif ($command eq "rsetboot") {
        rsetboot($callback, \%rhevm_hash, $args);
    } elsif ($command eq "addhost") {
        addhost($callback, \%rhevm_hash);
    } elsif ($command eq "chhypervisor") {
        cfghost($callback, \%rhevm_hash, $nodes, $args);
    } elsif ($command eq "rmhypervisor") {
        push @$args, "-r";
        cfghost($callback, \%rhevm_hash, $nodes, $args);
    }elsif ($command eq "cfgve") {
        cfgve($callback, \%rhevm_hash,$args);
    } elsif ($command eq "lsve") {
        lsve($callback, \%rhevm_hash,$args);
    } elsif ($command eq "rmhost") {
        rmhost();
    } elsif ($command eq "lsvm") {
        lsvm($callback, \%rhevm_hash, $args);
    } elsif ($command eq "chvm") {
        chvm($callback, \%rhevm_hash, $nodes, $args);
    }elsif ($command eq "mkvm") {
        mkvm($callback, \%rhevm_hash, $nodes, $args);
    } elsif ($command eq "rmvm") {
        rmvm($callback, \%rhevm_hash, $args);
    } elsif ($command eq "clonevm") {
        clonevm($callback, \%rhevm_hash, $args);
    } elsif ($command eq "rmigrate") {
        rmigrate($callback, \%rhevm_hash, $args);
    } elsif ($command eq "rpower") {
        power ($callback, \%rhevm_hash, $args);
    } elsif ($command eq "getrvidparms") {
        getrvidparms ($callback, \%rhevm_hash, $nodes);
    }

}

my @cpiopid;

# Perform the copycds for rhev-h to a specific dirtory 
sub copycd {
    my $request = shift;
    my $callback = shift;

    my $distname;
    my $arch;
    my $path;
    my $mntpath;
    my $file;  # the iso source file must be passed to generate the initrd

    @ARGV = @{$request->{arg}};
    GetOptions( 'n=s' => \$distname,
                'a=s' => \$arch,
                'p=s' => \$path,
                'm=s' => \$mntpath,
                'f=s' => \$file,
              );

    unless ($distname && $arch && $mntpath) {
        return;
    }

    if ($distname && $distname !~ /^rhev/) {
        return;
    } elsif (! $file) {
        $callback->({error => "Only support to use the iso file for rhev"});
        return;
    }

    my $installroot = "/install";
    my @entries =  xCAT::TableUtils->get_site_attribute("installdir");
    my $t_entry = $entries[0];
    if ( defined($t_entry) ) {
        $installroot = $t_entry;
    }
    my $rsp;
    push @{$rsp->{data}}, "Copying media to $installroot/$distname/$arch/";
    xCAT::MsgUtils->message("I", $rsp, $callback);

    unless ($path) {
        $path = "$installroot/$distname/$arch";
    }
    my $omask = umask 0022;
    if(-l $path)
    {
        unlink($path);
    }
    mkpath("$path");
    umask $omask;

    my $rc;
    my $reaped = 0;
    $SIG{INT} = $SIG{TERM} = sub {
        foreach(@cpiopid){
            kill 2, $_;
        }
        if ($mntpath) {
            chdir("/");
            system("umount $mntpath");
        }
    };
    my $KID;
    chdir $mntpath;
    my $numFiles = `find . -print | wc -l`;
    my $child = open($KID, "|-");
    unless (defined $child)
    {
        $callback->({error => "Media copy operation fork failure"});
        return;
    }
    if ($child)
    {
        push @cpiopid, $child;
        my @finddata = `find .`;
        for (@finddata)
        {
            print $KID $_;
        }
        close($KID);
        $rc = $?;
    }
    else
    {
        nice 10;
        my $c = "nice -n 20 cpio -vdump $path";
        my $k2 = open(PIPE, "$c 2>&1 |") ||
           $callback->({error => "Media copy operation fork failure"});
        push @cpiopid, $k2;
        my $copied = 0;
        my ($percent, $fout);
        while(<PIPE>){
          next if /^cpio:/;
          $percent = $copied / $numFiles;
          $fout = sprintf "%0.2f%%", $percent * 100;
          $callback->({sinfo => "$fout"});
          ++$copied;
        }
        exit;
    }

    # copy the iso to the source dir to generate the initrd by nodeset
    copy ($file, "$installroot/$distname/$arch/rhevh.iso");
}

# Perform the install preparation for the installation of rhev-h
sub mkinstall {
    my $request  = shift;
    my $callback = shift;
    my $rhevm_hash    = shift;
    my @nodes    = @{$request->{node}};

    my %doneimgs;

    my $installdir = "/install";
    my @ents = xCAT::TableUtils->get_site_attribute("installdir");
    my $site_ent = $ents[0];
    if( defined($site_ent) )
    {
        $installdir = $site_ent;
    }

    my $tftpdir = "/tftpboot";
    @ents = xCAT::TableUtils->get_site_attribute("tftpdir");
    $site_ent = $ents[0];
    if( defined($site_ent) )
    {
        $tftpdir = $site_ent;
    }

    my $nttab = xCAT::Table->new('nodetype');
    my %ntents = %{$nttab->getNodesAttribs(\@nodes, ['profile', 'os', 'arch', 'provmethod'])};

    my $bptab  = xCAT::Table->new('bootparams',-create=>1);
    my $restab = xCAT::Table->new('noderes',-create=>1);
    my %resents = %{$restab->getNodesAttribs(\@nodes, ['xcatmaster', 'tftpdir', 'primarynic', 'installnic'])};

    foreach my $rhevm (keys %{$rhevm_hash}) {
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $node (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if ($node eq $rhevm_hash->{$rhevm}->{host}->{$node}->{node}->[0]) {  #this is a rhev-h
                    my $ent = $ntents{$node}->[0];
                    my $os = $ent->{os};
                    my $arch    = $ent->{arch};
                    my $profile = $ent->{profile};
            
                    my ($kcmdline,$k,$i);
                    if ($arch =~ /x86/
                        && -r "$installdir/$os/$arch/isolinux/vmlinuz0"
                        && -r "$installdir/$os/$arch/isolinux/initrd0.img"
                        && -r "$installdir/$os/$arch/rhevh.iso") {
                        my $tftppath = "$tftpdir/xcat/$os/$arch";
                        mkpath($tftppath);
                        copy ("$installdir/$os/$arch/isolinux/vmlinuz0", $tftppath);
            
                        # append the full iso to the initrd. It will be downloaded to the node and as the installation source to install rhev-h
                        unless ($doneimgs{"$os|$arch"}) {
                            my $cmd = "cd $installdir/$os/$arch/; echo rhevh.iso | cpio -H newc --quiet -L -o | gzip -9 | cat $installdir/$os/$arch/isolinux/initrd0.img - > $tftppath/initrd0.img";
                            `$cmd`;
                            $doneimgs{"$os|$arch"} = 1;
                        }
                        $k = "xcat/$os/$arch/vmlinuz0";
                        $i = "xcat/$os/$arch/initrd0.img";
                    } else {
                        my $rsp;
                        push @{$rsp->{data}}, "Cannot find vmlinux";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                    }
            
                    $kcmdline = " rootflags=loop";
                    $kcmdline .= " root=live:/rhevh.iso";
                    $kcmdline .= " rootfstype=auto ro liveimg nomodeset check rootflags=ro crashkernel=512M-2G:64M,2G-:128M elevator=deadline processor.max_cstate=1 install reinstall quiet rd_NO_LVM rhgb rd_NO_LUKS rd_NO_MD rd_NO_DM";

                    # set the boot device
                    my $ksdev = "";
                    $ent = $resents{$node}->[0];
                    if ($ent->{installnic}) {
                        if ($ent->{installnic} eq "mac") {
                            my $mactab = xCAT::Table->new("mac");
                            my $macref = $mactab->getNodeAttribs($node, ['mac']);
                            $ksdev = xCAT::Utils->parseMacTabEntry($macref->{mac},$node);
                        }  else {
                            $ksdev = $ent->{installnic};
                        }
                     } elsif ($ent->{primarynic}) {
                        if ($ent->{primarynic} eq "mac") {
                            my $mactab = xCAT::Table->new("mac");
                            my $macref = $mactab->getNodeAttribs($node, ['mac']);
                            $ksdev = xCAT::Utils->parseMacTabEntry($macref->{mac},$node);
                        } else {
                            $ksdev = $ent->{primarynic};
                        }
                    }
                    
                    # set the storage parameters
                    $kcmdline .= " storage_init";
                    
                    # set the bootif
		    if ($ksdev) { 
                    	$kcmdline .= " BOOTIF=$ksdev ip=dhcp";
	            } else { #let boot firmware fill it in
                    	$kcmdline .= " ip=dhcp";
		    }
            
                    # set the passwd for admin and root
                    $kcmdline .=  " adminpw=$rhevm_hash->{$rhevm}->{host}->{$node}->{adminpw} rootpw=$rhevm_hash->{$rhevm}->{host}->{$node}->{rootpw} ssh_pwauth=1";
            
                    # set the hostname and password of the management server for the node so that node could register to the rhevm automatically.
                    $kcmdline .= " management_server=$rhevm_hash->{$rhevm}->{name} rhevm_admin_password=$rhevm_hash->{$rhevm}->{host}->{$node}->{rootpw}";
            
                    # set the flag update trigger, after installing of rhev-h, this url will be 'wget', xCAT MN will handle this event to run the upfateflag for this rhev-h
                    my $xcatmaster;
                    if ($ent and $ent->{xcatmaster}) {
                        $xcatmaster = $ent->{xcatmaster};
                    } else {
                        $xcatmaster = '!myipfn!';
                    }
                    $kcmdline .= " local_boot_trigger=http://$xcatmaster/xcatrhevh/rhevh_finish_install/\@HOSTNAME\@";
            
                    $bptab->setNodeAttribs($node,
                        { kernel   => $k,
                          initrd   => $i,
                          kcmdline => $kcmdline});
            
                }
            }
        }
    }
}

# Generate the REST API http request 
# $method: GET, PUT, POST, DELETE
# $api: the url of rest api
# $content: an xml section which including the data to perform the rest api
sub genreq {
    my $rhevm = shift;
    my $method = shift;
    my $api = shift;
    my $content = shift;

    if (! defined($content)) { $content = ""; }
    my $header = HTTP::Headers->new('content-type' => 'application/xml',
                             'Accept' => 'application/xml',
                             #'Connection' => 'keep-alive',
                             'Host' => $rhevm->{name}.':8443');
    $header->authorization_basic($rhevm->{user}.'@internal', $rhevm->{pw});

    my $ctlen = length($content);
    $header->push_header('Content-Length' => $ctlen);

    my $url = "https://".$rhevm->{name}.":8443".$api;
    my $request = HTTP::Request->new($method, $url, $header, $content);
    $request->protocol('HTTP/1.1');

    return $request;
}

# Make connection to rhev-m
# Send REST api request to rhev-m
# Receive the response from rhev-m
# Handle the error cases
#
# return 1-ssl connection error; 
#          2-http response error; 
#          3-return a http error message; 
#          5-operation failed
sub send_req {
    my $ref_rhevm = shift;
    my $request = shift;

    my $rhevm = $ref_rhevm->{name};

    my $rc = 0;
    my $response;
    my $connect;
    my $socket = IO::Socket::INET->new( PeerAddr => $rhevm, 
                                                              PeerPort => '8443',
                                                              Timeout => 15);
    if ($socket) {
        $connect = IO::Socket::SSL->start_SSL($socket, SSL_ca_file => "/etc/xcat/rhevm/$rhevm/ca.crt", Timeout => 0);
        if ($connect) {
            my $flags=fcntl($connect,F_GETFL,0);
            $flags |= O_NONBLOCK;
            fcntl($connect,F_SETFL,$flags);
        } else {
            $rc = 1;
            $response = "Could not make ssl connection to $rhevm:8443.";
        }
    } else {
        $rc = 1;
        $response = "Could not create socket to $rhevm:8443.";
    }

    if ($rc) {
        return ($rc, $response);
    }

    my $IOsel = new IO::Select;
    $IOsel->add($connect);

    if ($verbose) {
        my $rsp;
        push @{$rsp->{data}}, "\n===================================================\n$request----------------";
        xCAT::MsgUtils->message("I", $rsp, $global_callback);
    }

    print $connect $request;
    $response = "";
    my $retry;
    my $ischunked;
    my $firstnum;
    while ($retry++ < 10) {
        unless ($IOsel->can_read(2)) {
            next;
        }
        my $readbytes;
        my $res = "";
        do { $readbytes=sysread($connect,$res,65535,length($res)); } while ($readbytes);
        if ($res) {
            my @part = split (/\r\n/, $res);
            for my $data (@part) {
              # for chunk formated data, check the last chunk to finish
              if ($data =~ /Transfer-Encoding: (\S+)/) {
                if ($1 eq "chunked") {
                  $ischunked = 1;
                }
              }
              if ($ischunked && $data =~ /^([\dabcdefABCDEF]+)$/) {
                if ($1 eq 0) {
                  # last chunk
                  goto FINISH;
                }else {
                  # continue to get the rest chunks
                  $retry = 0;
                  next;
                }
              } else {
                # put all data together
                $response .= $data;
              }
           }
        }
        unless ($ischunked) {
            # for non chunk data, just read once
            if ($response) {
                last;
            } else {
                if (not defined $readbytes and $! == EAGAIN) { next; }
                $rc = 2;
                last;
            }
        }
    }

FINISH: 
    if ($retry >= 10 ) {$rc = 3;}

    if ($verbose) {
        my $rsp;
        push @{$rsp->{data}}, "$response===================================================\n";
        xCAT::MsgUtils->message("I", $rsp, $global_callback);
    }

    $IOsel->remove($connect);
    close($connect);

    if ($response) {
        if (grep (/<html>/, $response)) { # get a error message in the html
            $rc = 3; 
        }  elsif (grep (/<\?xml/, $response)) {
	    $response =~ s/.*?</</ms;
            my $parser = XML::LibXML->new();
            my $doc = $parser->parse_string($response);
            if ($doc ) {
                my $attr;
                if ($attr = getAttr($doc, "/fault/detail")) {
                    $response = $attr;
                    $rc = 5;
                } elsif ($attr = getAttr($doc, "/action/fault/detail")) {
                    if ($attr eq "[]") {
                        if ($attr = getAttr($doc, "/action/fault/reason")) {
                            $response = $attr;
                        } else {
                            $response = "failed";
                        }
                    } else {
                        $response = $attr;
                    }
                    $rc = 5;
                }
            }
        }
   }
    
    return ($rc, $response);
}

# Add the rhels host since it cannot register automatically.
sub addhost {
    my $callback = shift;
    my $rhevm_hash = shift;

    my @domain = xCAT::TableUtils->get_site_attribute("domain");
    if (!$domain[0]) {
        my $rsp;
        push @{$rsp->{data}}, "The site.domain must be set to enable the rhev support.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return;
    }

    # Create the xml data
    my $doc = XML::LibXML->createDocument();
    my $root = $doc->createElement("host");
    $doc->setDocumentElement($root);
    my $name_ele = $doc->createElement("name");
    $root->appendChild($name_ele);
    my $name_t = XML::LibXML::Text->new("");
    $name_ele->appendChild($name_t);
    
    my $add_ele = $doc->createElement("address");
    $root->appendChild($add_ele);
    my $add_t = XML::LibXML::Text->new("");
    $add_ele->appendChild($add_t);
    
    my $rootpw_ele= $doc->createElement("root_password");
    $root->appendChild($rootpw_ele);
    my $rootpw_t = XML::LibXML::Text->new("");
    $rootpw_ele->appendChild($rootpw_t);
    
    foreach my $rhevm (keys %{$rhevm_hash}) {
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if ($rhevh eq $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}->[0]) {
                    # Create the host first
                    my $api = "/api/hosts";
                    my $method = "POST";

                    # Generate the content
                    $name_t->setData($rhevh);
                    my $addofrhevh = $rhevh.".".$domain[0];
                    $add_t->setData($addofrhevh);
                    $rootpw_t->setData($rhevm_hash->{$rhevm}->{host}->{$rhevh}->{pw});
                    $rootpw_t->setData('$1$c5TJgKlJ$CuO6rR5B3d5mZc3Etu9HZ1');
                    my $content = $doc->toString();
                    
                    my $request = genreq($ref_rhevm, $method, $api, $content);
                    my ($rc, $response) = send_req($ref_rhevm, $request->as_string());

                    my $rsp;
                    if ($rc) {
                        push @{$rsp->{data}}, "$rhevh: $response";
                        next;
                    } else {
                        my $parser = XML::LibXML->new();
                        my $doc = $parser->parse_string($response);
                        if ($doc ) {
                            my $attr;
                            if ($attr = getAttr($doc, "/vms/hosts/status/state")) {
                                push @{$rsp->{data}}, "$rhevh: state: $attr";
                            }
                        }
                    }
                }
            }
        } 
    }
    # Adding the host to rhevm
}

# name -> path mapping for the resource display
my $display = {
    'datacenters' => {
        'description' => ["description"],
        'storagetype' => ['storage_type'],
        'storageformat' =>['storage_format'],
        'state' => ['status/state'],
    },
    'clusters' => {
        'description' => ["description"],
        'cpu' => ["cpu", "id"],
        'memory_overcommit' => ["memory_policy/overcommit", "percent"],
        'memory_hugepage' => ["memory_policy/transparent_hugepages/enabled"],
    },
    'storagedomains' => {
        'type' => ["type"],
        'ismaster' => ["master"],
        'storage_type' => ["storage/type"],
        'storage_add' => ["storage/address"],
        'storage_path' => ["storage/path"],
        'available' => ["available"],
        'used' => ["used"],
        'committed' => ["committed"],
        'storage_format' => ["storage_format"],
        'status' => ["status/state"],
    },
    'networks' => {
        'description' => ["description"],
        'vlan' => ["vlan", "id"],
        'stp' => ["stp"],
        'state' => ["status/state"],
    },
    'hosts' => {
        'address' => ["address"],
        'state' => ["status/state"],
        'type' => ["type"],
        'storage_manager' => ["storage_manager"],
        'powermgt' => ["power_management/enabled"],
        'powermgt_type' => ["power_management", "type"],
        'powermgt_addr' => ["power_management/address"],
        'powermgt_user' => ["power_management/username"],
        'ksm' => ["ksm/enabled"],
        'hugepages' => ["transparent_hugepages/enabled"],
        'iscsi' => ["iscsi/initiator"],
        'cpu' => ["cpu/name"],
        'cpuspeed' => ["cpu/speed"],
        'summary_active' => ["summary/active"],
        'summary_migrating' => ["summary/migrating"],
        'summary_total' => ["summary/total"],
    },
    'host_nics' => {
        'network' => ["network", "id", "networks", "/network/name"],
        'mac' => ["mac", "address"],
        'ip' => ["ip", "address"],
        'netmask' => ["ip", "netmask"],
        'gateway' => ["ip", "gateway"],
        'speed' => ["speed"],
        'boot_protocol' => ["boot_protocol"],
        'state' => ["status/state"],
    },
    'vms' => {
        'memory' => ["memory"],
        'state' => ["status/state"],
        'type' => ["type"],
        'cpusocket' => ["cpu/topology", "sockets"],
        'cpucore' => ["cpu/topology", "cores"],
        'bootorder' => ["os/boot", "dev"],
        'display' => ["display/type"],
        'start_time' => ["start_time"],
        'creation_time' => ["creation_time"],
        'stateless' => ["stateless"],
        'placement_policy' => ["placement_policy/affinity"],
        'memory_guaranteed' => ["memory_policy/guaranteed"],
        'host' => ["host", "id", "hosts", "/host/name"],
    },
    'templates' => {
        'memory' => ["memory"],
        'state' => ["status/state"],
        'type' => ["type"],
        'cpusocket' => ["cpu/topology", "sockets"],
        'cpucore' => ["cpu/topology", "cores"],
        'bootorder' => ["os/boot", "dev"],
        'display' => ["display/type"],
        'creation_time' => ["creation_time"],
        'stateless' => ["stateless"],
    },
    'disks' => {
        'size' => ["size"],
        'type' => ["type"],
        'state' => ["status/state"],
        'iftype' => ["interface"],
        'format' => ["format"],
        'bootable' => ["bootable"],
        'storage_domains' => ["storage_domains/storage_domain", "id", "storagedomains", "/storage_domain/name"],
    },
    'nics' => {
        'iftype' => ["interface"],
        'mac' => ["mac", "address"],
        'network' => ["network", "id", "networks", "/network/name"],
    },
};

# Display the resource, it's called by lsvm and lsve
# $reponse - xml response return from send_req
# $type -datacenters, clusters, storagedomains ...
# $prelead - space that will be displayed pre the real message
# $criteria - 'dc=<name>' or 'name=<name>', only display when matchs
sub displaysrc {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $response = shift;
    my $type = shift;
    my $prelead = shift;
    my $criteria = shift;
    my $individual = shift;

    my @output;
    my @displayed;
    
    my $prefix;
    if ($type eq "datacenters") {
        $prefix = "/data_centers/data_center";
    } elsif ($type eq "clusters") {
        $prefix = "/clusters/cluster";
    } elsif ($type eq "storagedomains") {
        if ($individual) {
            $prefix = "/storage_domain";
        } else {
            $prefix = "/storage_domains/storage_domain";
        }
    } elsif ($type eq "networks") {
        $prefix = "/networks/network";
    } elsif ($type eq "hosts") {
        $prefix = "/hosts/host";
    } elsif ($type eq "vms") {
        $prefix = "/vms/vm";
    } elsif ($type eq "templates") {
        $prefix = "/templates/template";
    } elsif ($type eq "disks") {
        $prefix = "/disks/disk";
    } elsif ($type eq "nics") {
        $prefix = "/nics/nic";
    } elsif ($type eq "host_nics") {
        $prefix = "/host_nics/host_nic";
    } else {
        return ();
    }
    
    my $parser = XML::LibXML->new();
    my $doc = $parser->parse_string($response);
    if ($doc) {
        my @nodes = $doc->findnodes($prefix);
        foreach my $node (@nodes) {
            # when crteria specified, the dc or name need to be checked
            if ($criteria) {
                my ($name, $value) = split('=', $criteria);
                my $curval;
                if ($name eq "dc") {
                    my $cnode = $node->findnodes("data_center");
                    if (defined($cnode->[0])) {
                        $curval = $cnode->[0]->getAttribute("id");
                    } else {
                        next;
                    }
                } elsif ($name eq "name") {
                    my $cnode = $node->findnodes("name");
                    if (defined($cnode->[0])) {
                        $curval = $cnode->[0]->textContent();
                    } else {
                        next;
                    }
                }

                unless ($curval eq $value) {
                    next;
                }
            }
            
            # Get the resource name first and display
            my $objname = getAttr($node, "name");
            push @displayed, getAttr($node, "", "id");
            push @output, $prelead.$type.": [".$objname."]";

            # Display each item for the specific type
            foreach my $name (sort (keys %{$display->{$type}})) {
                if (defined ($display->{$type}->{$name}->[2])) { # search the resource from the id
                    # If the [3] and [4] params are specified, use the [0] and [1] to get the target resouce id,
                    # Then search the resource of this id, [3] is type and [4] is the path to get the end message
                    my $id = getAttr($node, $display->{$type}->{$name}->[0], $display->{$type}->{$name}->[1]);
                    my $srctype = $display->{$type}->{$name}->[2];
                    my $srcpath = $display->{$type}->{$name}->[3];
                    my ($rc, $newid, $stat, $response) = search_src($ref_rhevm, $srctype, "/".$id, 1);
                    unless ($rc) {
                        my $parser = XML::LibXML->new();
                        my $doc = $parser->parse_string($response);
                        if ($doc ) {
                            my $attr;
                            if ($attr = getAttr($doc, $srcpath) || defined ($attr)) {
                                push @output, $prelead."  ".$name.": ".$attr;
                            }
                        }
                    }
                } else {
                    my $value = getAttr($node, $display->{$type}->{$name}->[0], $display->{$type}->{$name}->[1]);
                    if ($value) {
                        push @output, $prelead."  ".$name.": ".$value;
                    }
                }
            }
        }
    }
    
    my $rsp;
    if (@output) {
        push @{$rsp->{data}}, @output;
    }
    xCAT::MsgUtils->message("I", $rsp, $callback);

    return @displayed;
}

# Display the virtual environment
# -t - type of resouce: dc - datacenter; cl - cluster; sd - storage domain; nw - network; tpl - template
# -o - the object that needs to be displayed. It could be multiple objs separated with ','
# -m - the rhevm that manage the resources
sub lsve {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;
    my $nodes = shift;

    my @output;

    my ($type, $objs, $mgr, $approve, $create, $update, $active, $network, $power, $remove);
    if ($args) {
        @ARGV=@{$args};
        GetOptions('t=s' => \$type,
                        'o=s' => \$objs,
                        'm=s' => \$mgr);
    }

    my $rhevm = (keys %{$rhevm_hash})[0];
    my $ref_rhevm = {'name' => $rhevm, 
                             'user' => $rhevm_hash->{$rhevm}->{user}, 
                             'pw' => $rhevm_hash->{$rhevm}->{pw}};

    my @objs;
    if ($objs) {
        @objs = split (',', $objs);
    } else {
        push @objs, 'xxxxxx_all_objs';
    }
    foreach my $obj (@objs) {
        if ($type eq "dc") {
            my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "datacenters", $obj);
            unless ($rc) {
                displaysrc($callback, $ref_rhevm, $response, "datacenters", "");
                my $dcid = $id;

                if ($obj ne 'xxxxxx_all_objs') {
                    # Display the cluster, storagedomain, network if requiring to display datacenter
                    ($rc, $id, $stat, $response) = search_src($ref_rhevm, "clusters", "datacenter%3D$obj");
                    unless ($rc) {
                        displaysrc($callback, $ref_rhevm, $response, "clusters", "    ");
                    }
                    #($rc, $id, $stat, $response) = search_src($ref_rhevm, "storagedomains", "datacenter%3D$obj");
                    ($rc, $id, $stat, $response) = search_src($ref_rhevm, "datacenters/$dcid/storagedomains:storagedomains");
                    unless ($rc) {
                        displaysrc($callback, $ref_rhevm, $response, "storagedomains", "    ");
                    }
                    ($rc, $id, $stat, $response) = search_src($ref_rhevm, "networks");
                    unless ($rc) {
                        displaysrc($callback, $ref_rhevm, $response, "networks", "    ", "dc=$dcid");
                    }
                    ($rc, $id, $stat, $response) = search_src($ref_rhevm, "templates", "datacenter%3D$obj");
                    unless ($rc) {
                        displaysrc($callback, $ref_rhevm, $response, "templates", "    ");
                    }
                }
            }
        } elsif ($type eq "cl") {
            my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "clusters", "$obj");
            unless ($rc) {
                displaysrc($callback, $ref_rhevm, $response, "clusters", "");
            }
        } elsif ($type eq "sd") {
            my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "storagedomains", "$obj");
            unless ($rc) {
                displaysrc($callback, $ref_rhevm, $response, "storagedomains", "");
            }
        } elsif ($type eq "nw") {
            my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "networks");
            unless ($rc) {
                if ($obj eq 'xxxxxx_all_objs') {
                    displaysrc($callback, $ref_rhevm, $response, "networks", "  ");
                } else {
                    displaysrc($callback, $ref_rhevm, $response, "networks", "  ", "name=$obj");
                }
            }
        } elsif ($type eq "tpl") {
            my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "templates", "$obj");
            unless ($rc) {
                displaysrc($callback, $ref_rhevm, $response, "templates", "");
            }
        } else {
            my $rsp;
            push @{$rsp->{data}}, "The type: $type is not supported.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return;
        }
    }
    
    return;
}

# Configure the rhev virtual environment
# -t - type of resouce: dc - datacenter; cl - cluster; sd - storage domain; nw - network
# -o - the object that needs to be configured. It could be multiple objs separated with ','
# -m - the rhevm that manage the resources
# -d - datacenter name that needs by creating
# -c - creating a resource
# -u - updating a resource
# -g - activate a resource
# -s - deactivate a resource
# -a - attach a resource
# -b - detach a resource
# -r - delete a resource

# Working format:
# cfgve -t sd -m <mgr> -o <name> -c
# cfgve -t sd -m <mgr> -o <name> -a/-g/-s
# cfgve -t nw -m <mgr> -o < name> -c
# cfgve -t tpl -m <mgr> -o <name> -r
# 
sub cfgve {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;
    my $nodes = shift;

    my ($type, $objlist, $mgr, $datacenter, $cluster, $create, $update, $remove, $activate, $deactivate, $attach, $detach, $force, $stype, $cputype, $vlan);
    if ($args) {
        @ARGV=@{$args};
        GetOptions('t=s' => \$type,
                        'o=s' => \$objlist,
                        'm=s' => \$mgr,
                        'd=s' => \$datacenter,
                        'l=s' => \$cluster,
                        'c' => \$create,
                        'u' => \$update,
                        'g' => \$activate,
                        's' => \$deactivate,
                        'a' => \$attach,
                        'b' => \$detach,
                        'r' => \$remove,
                        'f' => \$force,
                        'k=s' => \$stype,
                        'p=s' => \$cputype,
                        'n=s' => \$vlan);
    }

    my $rhevm = (keys %{$rhevm_hash})[0];
    my $ref_rhevm = {'name' => $rhevm, 
                             'user' => $rhevm_hash->{$rhevm}->{user}, 
                             'pw' => $rhevm_hash->{$rhevm}->{pw}};

    my @objs;
    if ($objlist) {
        @objs = split (',', $objlist);
    }
    foreach my $obj (@objs) {
        if ($type eq "sd") {
            if ($create) {
                if (mkSD($callback, $ref_rhevm, $obj)) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: create storage domain succeeded.";
                    xCAT::MsgUtils->message("I", $rsp, $callback);
                    return;
                }
            } elsif ($activate || $deactivate || $attach || $detach || $remove) {
                # get the name of datacenter
                my $vsdtab = xCAT::Table->new('virtsd',-create=>0);
                my $vsdent = $vsdtab->getAttribs({'node'=>$obj}, ['datacenter']);
                my $datacenter = $vsdent->{datacenter};
                unless ($datacenter) {
                    $datacenter = "Default";
                }
                my ($rc, $dcid, $sdid, $stat);
                ($rc, $dcid, $stat) = search_src($ref_rhevm, "datacenters", $datacenter);
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: failed to get datacenter: $datacenter.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    return;
                }
                ($rc, $sdid, $stat) = search_src($ref_rhevm, "storagedomains", $obj);
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: failed to get storagedomains: $obj.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    return;
                }
                if ($activate || $deactivate) {
                    my $rsp;
                    if (activate($callback, $ref_rhevm,"/api/datacenters/$dcid/storagedomains/$sdid", $obj, $deactivate)) {
                        push @{$rsp->{data}}, "$obj: failed.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                    } else {
                        push @{$rsp->{data}}, "$obj: succeeded.";
                        xCAT::MsgUtils->message("I", $rsp, $callback);
                    }
                } elsif ($attach || $detach) {
                    my $rsp;
                    if (attach($callback, $ref_rhevm,"/api/datacenters/$dcid/storagedomains", "storage_domain", $sdid, $detach)) {
                        push @{$rsp->{data}}, "$obj: failed.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                    } else {
                        push @{$rsp->{data}}, "$obj: succeeded.";
                        xCAT::MsgUtils->message("I", $rsp, $callback);
                    }
                } elsif ($remove) {
                    if ($force) {
                        # deactivate the storage domain
                        activate($callback, $ref_rhevm,"/api/datacenters/$dcid/storagedomains/$sdid", $obj, 1);
                    
                        # detach the storage domain to the datacenter
                        attach($callback, $ref_rhevm,"/api/datacenters/$dcid/storagedomains", "storage_domain", $sdid, 1);
                    }
    
                    if (!deleteSD($callback, $ref_rhevm, "/api/storagedomains/$sdid", $obj)) {
                        my $rsp;
                        push @{$rsp->{data}}, "$obj: delete storage domain succeeded.";
                        xCAT::MsgUtils->message("I", $rsp, $callback);
                        return;
                    }
                }
            } 
        } elsif ($type eq "tpl") {
            if ($remove) {
                my ($rc, $tplid, $stat, $response) = search_src($ref_rhevm, "templates", "$obj");
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: cannot find the template: $obj.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                }
                generalaction($callback, $ref_rhevm, "/api/templates/$tplid", "DELETE", 1);
            }
        } elsif ($type eq "nw") {
            if ($create) {
                # serach datacenter
                unless ($datacenter) {
                    $datacenter = "Default";
                }
                my ($rc, $dcid, $stat) = search_src($ref_rhevm, "datacenters", $datacenter);
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: failed to get datacenter: $datacenter.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
                
                # create the network
                my $api = "/api/networks";
                my $method = "POST";
                my $content = "<network><name>$obj</name><data_center id=\"$dcid\"/></network>";
                if ($vlan) {
                    $content = "<network><name>$obj</name><data_center id=\"$dcid\"/><vlan id=\"$vlan\"/></network>";
                }
                my $request = genreq($ref_rhevm, $method, $api, $content);
                my $response;
                ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: $response";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: succeeded";
                    xCAT::MsgUtils->message("I", $rsp, $callback);
                    next;
                }
            } elsif ($remove) {
                my ($rc, $nwid, $stat) = search_src($ref_rhevm, "networks", $obj);
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: failed to get networks: $obj.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
                generalaction($callback, $ref_rhevm, "/api/networks/$nwid", "DELETE", 1);
            } elsif ($attach || $detach) {
                unless ($cluster) {
                    $cluster = "Default";
                }
                my ($rc, $clid, $stat, $response) = search_src($ref_rhevm, "clusters", "$cluster");
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: cannot find the cluster:$cluster.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }

                my $nwid;
                ($rc, $nwid, $stat) = search_src($ref_rhevm, "networks", "$obj");
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: cannot find the network.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }

                if ($attach) {
                    my $api = "/api/clusters/$clid/networks";
                    my $method = "POST";
                    my $content = "<network id=\"$nwid\"><name>$obj</name></network>";
                    my $request = genreq($ref_rhevm, $method, $api, $content);
                    my $response;
                    ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                    if ($rc) {
                        my $rsp;
                        push @{$rsp->{data}}, "$obj: $response";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        next;
                    } else {
                        my $rsp;
                        push @{$rsp->{data}}, "$obj: succeeded";
                        xCAT::MsgUtils->message("I", $rsp, $callback);
                        next;
                    }
                } elsif($detach) {
                    generalaction($callback, $ref_rhevm, "/api/clusters/$clid/networks/$nwid", "DELETE", 1);
                }
            }
        } elsif ($type eq "dc") {
            my ($rc, $dcid, $stat, $response) = search_src($ref_rhevm, "datacenters", "$obj");
            
            if ($create) {
                if (!$rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: data center has been created.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }

                unless ($stype && $stype =~ /^(nfs|localfs)$/) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: the storage type needs to be specified by -k.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
                # create the datacenter
                my $api = "/api/datacenters";
                my $method = "POST";
                my $content = "<data_center><name>$obj</name><storage_type>$stype</storage_type><version minor=\"0\" major=\"3\"/></data_center>";
                my $request = genreq($ref_rhevm, $method, $api, $content);
                my $response;
                ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: $response";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: succeeded";
                    xCAT::MsgUtils->message("I", $rsp, $callback);
                    next;
                }
            } elsif ($remove) {
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: cannot find the data center.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
                generalaction($callback, $ref_rhevm, "/api/datacenters/$dcid", "DELETE", 1);
            }
        } elsif ($type eq "cl") {
            my ($rc, $clid) = search_src($ref_rhevm, "clusters", "$obj");
            
            if ($create) {
                if (!$rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: cluster has been created.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }

                unless ($datacenter) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: the datacenter for the cluster must be specified.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
                my $dcid;
                ($rc, $dcid) = search_src($ref_rhevm, "datacenters", "$datacenter");
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: failed to get the datacenter: $datacenter.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }

                unless ($cputype) {
                    $cputype = "Intel Penryn Family";
                }
                
                # create the datacenter
                my $api = "/api/clusters";
                my $method = "POST";
                my $content = "<cluster><name>$obj</name><data_center id=\"$dcid\"/><cpu id=\"$cputype\"/></cluster>";
                my $request = genreq($ref_rhevm, $method, $api, $content);
                my $response;
                ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: $response";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: succeeded";
                    xCAT::MsgUtils->message("I", $rsp, $callback);
                    next;
                }
            } elsif ($remove) {
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$obj: cannot find the cluster.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
                generalaction($callback, $ref_rhevm, "/api/clusters/$clid", "DELETE", 1, $force);
            }
        } else {
            my $rsp;
            push @{$rsp->{data}}, "The type: $type is not supported.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return;
        }
    }
                             
}


# configure host
# -a: approve the host that can be managed by rhev-m
# -n: configure the network for host
# -p: configure the power management for host.  
#      This will be used for rhev-m to check the power status of host, so that when SPM (Storage Pool Manager) host
#      down, rhev-m could switch the SPM role to another host automatically.
#      For rack mounted server, the ipmilan is used to do the power management. The IP of bmc and user:passwd are
#      neccessary to be configured for power management.
# -e: activate the host
# -d: deactivate a host to maintanance mode
sub cfghost {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $nodes = shift;
    my $args = shift;

    my ($approve, $network, $power, $activate, $deactivate, $remove, $force);
    if ($args) {
        @ARGV=@{$args};
        GetOptions('a' => \$approve,
                        'n' => \$network,
                        'p' => \$power,
                        'e' => \$activate,
                        'd' => \$deactivate,
                        'r' => \$remove,
                        'f' => \$force);
    }

    # Set the default user:pw for ipmi
    my ($ipmiuser, $ipmipw) = ('USERID', 'PASSW0RD');
    my ($hment, $ipmient);
    my %hyper;

    # get the IP, user, passwd for the bmc of the host if requiring to configure power management
    if ($power) {
        my $hmtab = xCAT::Table->new('nodehm',-create=>0);
        $hment = $hmtab->getNodesAttribs($nodes,['mgt']);

        my $ipmitab = xCAT::Table->new('ipmi',-create=>0);
        $ipmient = $ipmitab->getNodesAttribs($nodes,['bmc', 'username', 'password']);

        #get the default password for bmc
        my $pwtab = xCAT::Table->new('passwd',-create=>0);
        my $pwent = $pwtab->getAttribs({'key'=>'ipmi'},['username', 'password']);
        if ($pwent) {
            $ipmiuser = $pwent->{'username'};
            $ipmipw = $pwent->{'password'};
        }
    }

    # get the network parameters for the host if requiring to configure the network for host
    if ($network || $approve) {
        # get the network interface for host
        my $hyptab = xCAT::Table->new('hypervisor',-create=>0);
        my $hypent = $hyptab->getNodesAttribs($nodes,['interface', 'datacenter', 'cluster']);
        foreach my $node (@$nodes) {
            if (defined ($hypent->{$node}->[0])) {
                $hyper{$node}{interface} = $hypent->{$node}->[0]->{interface};
                $hyper{$node}{datacenter} = $hypent->{$node}->[0]->{datacenter};
                $hyper{$node}{cluster} = $hypent->{$node}->[0]->{cluster};
            }
            if (!$hyper{$node}{datacenter}) {
                $hyper{$node}{datacenter} = "Default";
            }
            if (!$hyper{$node}{cluster}) {
                $hyper{$node}{cluster} = "Default";
            }
        }
    }

    foreach my $rhevm (keys %{$rhevm_hash}) {
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm,
                                 'user' => $rhevm_hash->{$rhevm}->{user},
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if ($rhevh eq $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}->[0]) {
                    # get the host
                    my ($rc, $hostid, $hoststat) = search_src($ref_rhevm, "hosts", $rhevh);
                    if ($rc) {
                        my $rsp;
                        push @{$rsp->{data}}, "$rhevh: host was not created.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        next;
                    }

                    if ($approve) {
                      if ($hoststat eq "pending_approval") {
                        # get the id of cluster
                        my ($rc, $clusterid, $clusterstat) = search_src($ref_rhevm, "clusters", $hyper{$rhevh}{cluster});
                        if ($rc) {
                            my $rsp;
                            push @{$rsp->{data}}, "$rhevh: failed to get cluster: $hyper{$rhevh}{cluster}.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        }
                        my $approved = 0;
                        # Create the host first
                        my $api = "/api/hosts/$hostid/approve";
                        my $method = "POST";

                        # Generate the content
                        my $content = "<action><cluster id=\"$clusterid\"/></action>";

                        my $request = genreq($ref_rhevm, $method, $api, $content);
                        my $response;
                        ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                        
                        if ($rc) {
                            my $rsp;
                            push @{$rsp->{data}}, "$rhevh: $response";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        } else {
                            my $parser = XML::LibXML->new();
                            my $doc = $parser->parse_string($response);
                            if ($doc ) {
                                my $attr;
                                if ($attr = getAttr($doc, "/action/status/state")) {
                                    if ($attr eq "complete") {
                                        $approved = 1;
                                    }
                                }
                            }
                        }

                        my $rsp;
                        if ($approved) {
                            push @{$rsp->{data}}, "$rhevh: approved.";
                            xCAT::MsgUtils->message("I", $rsp, $callback);
                        } else {
                            push @{$rsp->{data}}, "$rhevh: failed to approve.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        }
                      } else {
                          my $rsp;
                          push @{$rsp->{data}}, "$rhevh: the state of node is not correct for approve. Current state: $hoststat";
                          xCAT::MsgUtils->message("E", $rsp, $callback);
                      }
                    }

                    if ($activate || $deactivate) {
                        my $rsp;
                        if (activate($callback, $ref_rhevm,"/api/hosts/$hostid", $rhevh, $deactivate)) {
                            push @{$rsp->{data}}, "$rhevh: failed.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                        } else {
                            push @{$rsp->{data}}, "$rhevh: succeeded.";
                            xCAT::MsgUtils->message("I", $rsp, $callback);
                        }
                    }
                    
                    # configure the network interface for a host
                    if ($network) {
                        unless ($hyper{$rhevh}{interface}) {
                            my $rsp;
                            push @{$rsp->{data}}, "$rhevh: the hypervisor.interface needs to be configured to configure the network for a host.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        }
                        
                        if ($hoststat eq "maintenance") {
                            cfghypnw($callback, $ref_rhevm, $rhevh, $hyper{$rhevh}{interface}, $hyper{$rhevh}{datacenter});
                        } else {
                            my $rsp;
                            push @{$rsp->{data}}, "$rhevh: the hypervisor needs to be deactivated to maintenance state for the network configuring.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        }
                    }

                    if ($power) {
                        # Configure the power management for a host
                        # for rack mounted machine, use the 'ipmilan' type of power management
                        if (defined($hment->{$rhevh}->[0]) && $hment->{$rhevh}->[0]->{'mgt'}) {
                            if ($hment->{$rhevh}->[0]->{'mgt'} eq "ipmi") {
                                # get the bmc IP, user, password for the bmc
                                my ($user, $pw, $addr) = ($ipmiuser, $ipmipw);
                                if (defined($ipmient->{$rhevh}->[0]) && $ipmient->{$rhevh}->[0]->{bmc}) {
                                    $addr = $ipmient->{$rhevh}->[0]->{bmc};
                                } else {
                                    my $rsp;
                                    push @{$rsp->{data}}, "$rhevh: the ipmi.bmc was not set to know the hardware control point.";
                                    xCAT::MsgUtils->message("E", $rsp, $callback);
                                    next;
                                }
                                if (defined($ipmient->{$rhevh}->[0]) && $ipmient->{$rhevh}->[0]->{username}) {
                                    $user = $ipmient->{$rhevh}->[0]->{username};
                                }
                                if (defined($ipmient->{$rhevh}->[0]) && $ipmient->{$rhevh}->[0]->{password}) {
                                    $pw = $ipmient->{$rhevh}->[0]->{password};
                                }

                                my $doc = XML::LibXML->createDocument();
                                my $root = $doc->createElement("host");
                                $doc->setDocumentElement($root);
                                my $pm_ele = $doc->createElement("power_management");
                                $root->appendChild($pm_ele);
                                $pm_ele->setAttribute("type", "ipmilan");

                                $pm_ele->appendTextChild("enabled", "true");
                                $pm_ele->appendTextChild("address", $addr);
                                $pm_ele->appendTextChild("username", $user);
                                $pm_ele->appendTextChild("password", $pw);

                                my $api = "/api/hosts/$hostid";
                                my $method = "PUT";

                                my $request = genreq($ref_rhevm, $method, $api, $doc->toString);
                                my ($rc, $response) = send_req($ref_rhevm, $request->as_string());

                                my $rsp;
                                if ($rc) {
                                    push @{$rsp->{data}}, "$rhevh: $response";
                                    next;
                                } else {
                                    push @{$rsp->{data}}, "$rhevh: Setting power management: $addr";
                                }
                                xCAT::MsgUtils->message("I", $rsp, $callback);
                            } else {
                                my $rsp;
                                push @{$rsp->{data}}, "$rhevh: the supported power management method: ipmi.";
                                xCAT::MsgUtils->message("E", $rsp, $callback);
                            }
                        } else {
                            my $rsp;
                            push @{$rsp->{data}}, "$rhevh: the nodehm.mgt was not set to know the management method.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                        }
                    } # end of power management configure

                    if ($remove) {
                        if ($force && ($hoststat ne "maintenance")) {
                            # deactivate the host anyway
                            activate($callback, $ref_rhevm,"/api/hosts/$hostid", $rhevh, 1);
                            if (waitforcomplete($ref_rhevm, "/api/hosts/$hostid", "/host/status/state=maintenance", 30)) {
                                my $rsp;
                                push @{$rsp->{data}}, "$rhevh: failed to waiting the host gets to \"maintenance\" state.";
                                xCAT::MsgUtils->message("E", $rsp, $callback);
                                next;
                            }
                        }
                        generalaction($callback, $ref_rhevm, "/api/hosts/$hostid", "DELETE", 1);
                    }
                }
            } # end of for each host
        }
    }
}


sub rmhost {
}

# List the host and virtual machine
# -s short
# -v display virtual machines which belongs to the host
sub lsvm {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;
    my $nodes = shift;

    my ($short, $vm4host);
    if ($args) {
        @ARGV=@{$args};
        GetOptions('s' => \$short,
                        'v' => \$vm4host);
    }
    
    foreach my $rhevm (keys %{$rhevm_hash}) {
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};
    
        # Get the node that will be handled
        my @vms;
        my @hyps;
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    foreach my $node (@{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}}) {
                        if ($rhevh eq $node) {
                            push @hyps, $rhevh;
                        } else {
                            push @vms, $node;
                        }
                    }
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
            push @vms, @{$rhevm_hash->{$rhevm}->{node}};
        }

        foreach my $hyp (@hyps) {
            # Get the host
            my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "hosts", "$hyp");
            unless ($rc) {
                my @hostids = displaysrc($callback, $ref_rhevm, $response, "hosts", "");

                # display the nics for the vm
                my $hostid = $hostids[0];
                ($rc, $id, $stat, $response) = search_src($ref_rhevm, "hosts:host_nics", "/$hostid/nics");
                unless ($rc) {
                    displaysrc($callback, $ref_rhevm, $response, "host_nics", "    ");
                }

                # TODO, display the vm for host always?
                if (1||$vm4host) {
                    my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "vms", "Host.name%3D$hyp");
                    unless ($rc) {
                        displaysrc($callback, $ref_rhevm, $response, "vms", "    ");
                    }
                }
            }
        }

        # Display virtual machines
        foreach my $vm (@vms) {
            # Get vm
            my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "vms", $vm);
            unless ($rc) {
                my @vmids = displaysrc($callback, $ref_rhevm, $response, "vms", "");
                
                # display the disks for the vm
                my $vmid = $vmids[0];
                my ($rc, $id, $stat, $response) = search_src($ref_rhevm, "vms:disks", "/$vmid/disks");
                unless ($rc) {
                    displaysrc($callback, $ref_rhevm, $response, "disks", "    ");
                }
                    
                # display the nics for the vm
                ($rc, $id, $stat, $response) = search_src($ref_rhevm, "vms:nics", "/$vmid/nics");
                unless ($rc) {
                    displaysrc($callback, $ref_rhevm, $response, "nics", "    ");
                }
            }
        }
    }
}

# Create virtual machine
# Since the configuration for a vm is complicated, all the parameters will be gotten from vm table
sub mkvm {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $nodes = shift;

    my $upmac;  # used to update the mac table
    my $mactab = new xCAT::Table('mac',-create=>1);

    # Get the attributes for the node from the vm table
    my $vmtab = xCAT::Table->new('vm',-create=>0);
    my $vment = $vmtab->getNodesAttribs($nodes,['master', 'host', 'cluster', 'virtflags', 'storage', 'storagemodel', 'memory', 'cpus', 'nics', 'nicmodel', 'bootorder', 'vidproto']);

    # Generate the xml content for add the storage
    # Note: this is an independent action after the vm creating
    my $adds = XML::LibXML->createDocument();
    my $asroot = $adds->createElement("disk");
    $adds->setDocumentElement($asroot);

    # set the disk type: system and data
    my $disktype_ele = $adds->createElement("type");
    $asroot->appendChild($disktype_ele);
    my $disktype_t = XML::LibXML::Text->new("system");
    $disktype_ele->appendChild($disktype_t);

    # set the bootable
    my $diskboot_ele = $adds->createElement("bootable");
    $asroot->appendChild($diskboot_ele);
    my $diskboot_t = XML::LibXML::Text->new("true");
    $diskboot_ele->appendChild($diskboot_t);
    
    my $sd_ele = $adds->createElement("storage_domains");
    $asroot->appendChild($sd_ele);
    my $sdid_ele = $adds->createElement("storage_domain");
    $sd_ele->appendChild($sdid_ele);

    # add size of disk
    my $sdsize_ele = $adds->createElement("size");
    $asroot->appendChild($sdsize_ele);
    my $sdsize_t = XML::LibXML::Text->new("");
    $sdsize_ele->appendChild($sdsize_t);

   # add the element for type of disk interface 
    my $sdif_ele = $adds->createElement("interface");
    $asroot->appendChild($sdif_ele);
    my $sdif_t = XML::LibXML::Text->new("virtio");
    $sdif_ele->appendChild($sdif_t);

    # add the disk format element
    my $sdft_ele = $adds->createElement("format");
    $asroot->appendChild($sdft_ele);
    my $sdfm_t = XML::LibXML::Text->new("cow");
    $sdft_ele->appendChild($sdfm_t);

    # Generate the xml content for add network interface
    # Note: this is an independent action after the vm creating
    my $addnw = XML::LibXML->createDocument();
    my $anwroot = $addnw->createElement("nic");
    $addnw->setDocumentElement($anwroot);

    # add the interface type element
    my $nwif_ele = $addnw->createElement("interface");
    $anwroot->appendChild($nwif_ele);
    my $nwif_t = XML::LibXML::Text->new("virtio");
    $nwif_ele->appendChild($nwif_t);

    # add the name element
    my $nwname_ele = $addnw->createElement("name");
    $anwroot->appendChild($nwname_ele);
    my $nwname_t = XML::LibXML::Text->new("nic1");
    $nwname_ele->appendChild($nwname_t);

    # add the network element which specify which network this nic 
    # will be added to
    my $nwnw_ele = $addnw->createElement("network");
    $anwroot->appendChild($nwnw_ele);
    my $nwnwname_ele = $addnw->createElement("name");
    $nwnw_ele->appendChild($nwnwname_ele);
    my $nwnwname_t = XML::LibXML::Text->new("rhevm");
    $nwnwname_ele->appendChild($nwnwname_t);

    # create a mac element
    my $nwmac_ele = $addnw->createElement("mac");
    
    foreach my $rhevm (keys %{$rhevm_hash}) {
        my %node_hyp;
        my %hostid;
        my $success = 0;
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};
    
        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    foreach (@{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}}) {
                        $node_hyp{$_}{hyp} = $rhevh;
                        $hostid{$rhevh} = 1;
                    }
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
            foreach (@{$rhevm_hash->{$rhevm}->{node}}) {
                $node_hyp{$_}{hyp} = "";
            }
        }

        # get the host id
        # this is used for the case that needs locate vm to a spcific host
        foreach my $host (keys %hostid) {
            my ($rc, $id, $stat) = search_src($ref_rhevm, "hosts", $host);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "Cannot find $host in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                return;
            }
            $hostid{$host} = $id;
        }
        my @nodes = (keys %node_hyp);
        my $macmac = $mactab->getNodesAttribs(\@nodes, ['mac']);
   
        foreach my $node (@nodes) {
            my $myvment = $vment->{$node}->[0];
            unless ($myvment) {
                my $rsp;
                push @{$rsp->{data}}, "$node: has NOT entry in vm table.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }
            
            # Check the existence of the node
            my ($rc, $id, $stat) = search_src($ref_rhevm, "vms", $node);
            if (!$rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: virtual machine has been created.";
                xCAT::MsgUtils->message("I", $rsp, $callback);
                next;
            }
            
            #Create the virtual machine first
            my $api = "/api/vms";
            my $method = "POST";
            
            # generate the content
            # configure the template
            my $hastpl = 0;
            my $tplele;
            if ($myvment->{master}) {
                $tplele = "<template><name>$myvment->{master}</name></template>";
                $hastpl = 1;
            } else {
                $tplele = "<template><name>Blank</name></template>";
            }
            
            # configure memory
            my $memele;
            if ($myvment->{memory}) {
                my $memsize = $myvment->{memory};
                $memsize =~ s/g/000000000/i;
                $memsize =~ s/m/000000/i;
                $memele = "<memory>$memsize</memory>";
            } elsif (!$hastpl) {
                $memele = "<memory>2000000000</memory>";
            }
            
            # set the cpu
            my $cpuele;
            if ($myvment->{cpus}) {
                my ($socketnum, $corenum) = split(':', $myvment->{cpus});
                unless ($corenum) {$corenum = 1;}
                $cpuele = "<cpu><topology cores=\"$corenum\" sockets=\"$socketnum\"/></cpu>";
            } elsif (!$hastpl) {
                $cpuele = "<cpu><topology cores=\"1\" sockets=\"1\"/></cpu>"
            }
            
            # configure bootorder
            # there's a bug that sequence is not correct to set two order, so currently just set one
            my $boele;
            if ($myvment->{bootorder}) {
                my ($firstbr, $secbr) = split (',', $myvment->{bootorder});
                if ($secbr) {
                    $boele = "<os><boot dev=\"$firstbr\"/><boot dev=\"$secbr\"/><boot/></os>";
                } else {
                    $boele = "<os><boot dev=\"$firstbr\"/><boot/></os>";
                }
            } elsif (!$hastpl) {
                $boele = "<os><boot dev=\"network\"/><boot/></os>";
            }

            my $disele;
            if ($myvment->{vidproto}) {
                $disele = "<display><type>$myvment->{vidproto}</type></display>";
            } else {
                $disele = "<display><type>vnc</type></display>";
            }

            my $affinity;
            if ($myvment->{virtflags}) {
                # parse the specific parameters from vm.virtflags
                my @pairs = split (':', $myvment->{virtflags});
                foreach my $pair (@pairs) {
                    my ($name, $value) = split('=', $pair);
                    if ($name eq "placement_affinity") {
                        # set the affinity for placement_policy
                        $affinity = "<affinity>$value</affinity>"
                    }
                }
            }

            if (!$affinity && !$hastpl) {
                $affinity = "<affinity>migratable</affinity>"
            }

            my $hostele;
            if ($myvment->{host}) {
                $hostele = "<host id=\"$hostid{$myvment->{host}}\"/>";
            }

            my $placement_policy;
            if ($affinity || $hostele) {
                $placement_policy= "<placement_policy>$hostele$affinity</placement_policy>";
            }

            # set the cluster for the vm
            my $clusterele;
            if ($myvment->{cluster}) {
                $clusterele = "<cluster><name>$myvment->{cluster}</name></cluster>";
            } else {
                $clusterele = "<cluster><name>Default</name></cluster>";
            }

            my $content = "<vm><type>server</type><name>$node</name>$clusterele$tplele$memele$cpuele$boele$placement_policy$disele</vm>";
            my $request = genreq($ref_rhevm, 
                               $method,
                               $api,
                               $content);
            my $response;
            my $vmid;
            ($rc, $response) = send_req($ref_rhevm, $request->as_string());
            if (!$rc) {
                my $parser = XML::LibXML->new();
                my $doc = $parser->parse_string($response);
                my $newvm;
                if (defined ($doc->findnodes("/vm/name")->[0])) {
                    $newvm = $doc->findnodes("/vm/name")->[0]->textContent();
                }
                if ($newvm ne $node) {
                    my $rsp;
                    push @{$rsp->{data}}, "$node: create virtual machine failed.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
                my $vm = $doc->findnodes("/vm")->[0];
                $vmid = $vm->getAttribute('id');
                $success = 1;
            } else {
                my $rsp;
                push @{$rsp->{data}}, $response;
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }
    
            #Add the disk for the vm from storage domain
            my @disklist = split ('\|', $myvment->{storage});
                foreach (@disklist) {
                my ($sdname, $disksize, $disktype) = split(':', $_);
                if ($sdname) {
                    if (waitforcomplete($ref_rhevm, "/api/vms/$vmid", "/vm/status/state=down", 30)) {
                        my $rsp;
                        push @{$rsp->{data}}, "$node: failed to waiting the vm gets to \"down\" state.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        next;
                    }
                    $success = 0;
    
                    #Get the storage domain by name
                    my $sdid;
                    ($rc, $sdid, $stat) = search_src($ref_rhevm, "storagedomains", $sdname);
                    if ($rc) {
                        my $rsp;
                        push @{$rsp->{data}}, "Could not get the storage domain $sdname.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        next;
                    } 
    
                    if ($sdid) {
                        $api = "/api/vms/$vmid/disks";
                        $method = "POST";
                        
                        # generate the content
                        if ($disktype) {
                            $disktype_t->setData($disktype);
                            if ($disktype eq "system") {
                                $diskboot_t->setData("true");
                            } else {
                                $diskboot_t->setData("false");
                            }
                        } else {
                            $disktype_t->setData("system");
                            $diskboot_t->setData("true");
                        }
                        # set the size of disk
                        if ($disksize) {
                            $disksize =~ s/g/000000000/i;
                            $disksize =~ s/m/000000/i;
                        } else {
                            $disksize = "5000000000"; #5G is default
                        }
                        $sdid_ele->setAttribute("id", $sdid);
                        $sdsize_t->setData($disksize);
    
                        # set the interface type and format for disk
                        if ($myvment->{storagemodel}) {
                            my ($iftype,$iffmt) = split(':', $myvment->{storagemodel});
                            $sdif_t->setData($iftype);
                            $sdfm_t->setData($iffmt);
                        } else {
                            $sdif_t->setData("virtio");
                            $sdfm_t->setData("cow");
                        }
        
                        $request = genreq($ref_rhevm, $method, $api, $adds->toString());
                        ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                        if (!$rc) {
                            my $parser = XML::LibXML->new();
                            my $doc = $parser->parse_string($response);
                            if (defined($doc->findnodes("/fault")->[0])) {
                                my $rsp;
                                push @{$rsp->{data}}, "$node: Add disk failed for virtual machine";
                                if ($doc->findnodes("/fault/detail")->[0]) {
                                    push @{$rsp->{data}}, $doc->findnodes("/fault/detail")->[0]->textContent();
                                }
                                xCAT::MsgUtils->message("E", $rsp, $callback);
                                next;
                            }
                            my $state;
                            if (defined($doc->findnodes("/disk/creation_status/state")->[0])) {
                                $state = $doc->findnodes("/disk/creation_status/state")->[0]->textContent();
                            }
                            if ($state =~ /fail/i) {
                                my $rsp;
                                push @{$rsp->{data}}, "$node: Add disk failed for virtual machine";
                                xCAT::MsgUtils->message("E", $rsp, $callback);
                                next;
                            }
                            $success = 1;
                        } else {
                            my $rsp;
                            push @{$rsp->{data}}, $response;
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        }
                    }
                }
            }
            
            # Add the network interface
            #Get the network by name
            my @nics;
            if ($myvment->{nics}) {
                @nics = split(/\|/, $myvment->{nics});
            }
            if (!@nics && !$hastpl) {
                # default is to add nic1 to manament network 'rhevm'
                push @nics, "rhevm:eth0:yes";
            }
            if (@nics) {
                if (waitforcomplete($ref_rhevm, "/api/vms/$vmid", "/vm/status/state=down", 30)) {
                    my $rsp;
                    push @{$rsp->{data}}, "$node: failed to waiting the vm gets to \"down\" state.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
            }
            
            # if no installnic is specified, set the firstmac to mac.mac
            my $firstmac;
            
            # Search the nic
            my %oldmac;
            ($rc, undef, $stat, $response) = search_src($ref_rhevm, "vms:nics", "/$vmid/nics");
            unless ($rc) {
                my $parser = XML::LibXML->new();
                my $doc = $parser->parse_string($response);
                my @nicnodes = $doc->findnodes("/nics/nic");
                foreach my $nic (@nicnodes) {
                    if (defined($nic->findnodes("name"))) {
                        my $ethname = getAttr($nic, "name");
                        my $mac = getAttr($nic, "mac", "address");
                        $oldmac{$ethname} = $mac;
                        unless($firstmac) {
                             $firstmac = $mac;
                        }
                    }
                }
            }
            
            foreach my $nic (@nics) {
                # format of nic: [networkname:ifname:installnic]
                my ($nwname, $ifname, $instnic) = split(':', $nic);

                if (defined($oldmac{$ifname})) {
                    # The nic has been defined, mostly by clone
                    if ($instnic) {
                        $upmac->{$node}->{mac} = $oldmac{$ifname};
                    }
                    next;
                }

                # start the configuring
                $success = 0;
            
                my $nwid;
                ($rc, $nwid, $stat) = search_src($ref_rhevm, "networks", "$nwname");
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "Could not get the network $nwname.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                } 

                $api = "/api/vms/$vmid/nics";
                $method = "POST";
                
                # generate the content
                # set the nic interface type
                if ($myvment->{nicmodel}) {
                    $nwif_t->setData($myvment->{nicmodel});
                } else {
                    $nwif_t->setData("virtio");
                }
                $nwname_t->setData($ifname);
                $nwnwname_t->setData($nwname);

                # set the mac address element
                # if no entry in mac.mac, and this is install nic, THEN use the existed mac
                # otherwise create a new mac automatically by rhev-m
                my $orgmac;
                if ($instnic && defined ($macmac->{$node}->[0]) && defined ($macmac->{$node}->[0]->{'mac'})) {
                    $orgmac = $macmac->{$node}->[0]->{'mac'};
                    $anwroot->appendChild($nwmac_ele);
                    $nwmac_ele->setAttribute("address", $orgmac);
                } else {
                    $anwroot->removeChild($nwmac_ele);
                }
                
                $content = $addnw->toString();
                $request = genreq($ref_rhevm, 
                                   $method,
                                   $api,
                                   $content);
                ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                if (!$rc) {
                    my $parser = XML::LibXML->new();
                    my $doc = $parser->parse_string($response);
                    if (defined($doc->findnodes("/nic/mac")->[0])) {
                        my $realmac = $doc->findnodes("/nic/mac")->[0]->getAttribute("address");
                        unless($firstmac) {
                             $firstmac = $realmac;
                        }
                        if ($instnic) {
                            $upmac->{$node}->{mac} = $realmac;
                        }
                        
                        $success = 1;
                        next;
                     } else {
                        my $rsp;
                        push @{$rsp->{data}}, "$node: failed to create virtual machine.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        next;
                    }
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, $response;
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
            }

            if (!$upmac->{$node}->{mac} && $firstmac) {
                $upmac->{$node}->{mac} = $firstmac;
            }

            if ($success) {
                my $rsp;
                push @{$rsp->{data}}, "$node: Succeeded";
                xCAT::MsgUtils->message("I", $rsp, $callback);
            }
        }
    }

    $mactab->setNodesAttribs($upmac);
}

# Remove a virtual machine
sub rmvm {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;

    my $force;
    if ($args) {
        @ARGV=@{$args};
        GetOptions('f' => \$force);
    }

    foreach my $rhevm (keys %{$rhevm_hash}) {
        my @nodes;
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};

        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    push @nodes, @{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}};
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
             push @nodes, @{$rhevm_hash->{$rhevm}->{node}};
        }

        # perform the action against the node
        foreach my $node (@nodes) {
            # Get the ID of node
            my ($rc, $id, $state) = search_src($ref_rhevm, "vms", $node);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: node was not defined in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            } elsif (! defined($id)) {
                my $rsp;
                push @{$rsp->{data}}, "$node: node was not defined in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }

            # Remove the vm
            my $api = "/api/vms/$id";
            my $method = "DELETE";
            
            my $content = "<action/>";
            if ($force) {
                $content = "<action><force>true</force></action>";
            }
            my $request = genreq($ref_rhevm, 
                               $method,
                               $api,
                               $content);
            my $response;
            ($rc, $response) = send_req($ref_rhevm, $request->as_string());
            if ($rc == 2) {
                my $rsp;
                push @{$rsp->{data}}, "$node: succeeded.";
                xCAT::MsgUtils->message("I", $rsp, $callback);
                next;
            } else {
                my $rsp;
                push @{$rsp->{data}}, $response;
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }
        }
    }
}

# Change virtual machine
sub chvm {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $nodes = shift;

    # Get the mac address for the nodes from the mac table
    my $mactab = new xCAT::Table('mac',-create=>1);

    # Get the attributes for the nodes from the vm table
    my $vmtab = xCAT::Table->new('vm',-create=>0);
    my $vment = $vmtab->getNodesAttribs($nodes,['master', 'host', 'cluster', 'virtflags', 'storage', 'storagemodel', 'memory', 'cpus', 'nics', 'nicmodel', 'bootorder', 'vidproto']);

    foreach my $rhevm (keys %{$rhevm_hash}) {
        my %node_hyp;
        my %hostid;
        my $success = 0;
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};
    
        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    foreach (@{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}}) {
                        $node_hyp{$_}{hyp} = $rhevh;
                        $hostid{$rhevh} = 1;
                    }
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
            foreach (@{$rhevm_hash->{$rhevm}->{node}}) {
                $node_hyp{$_}{hyp} = "";
            }
        }

        # get the host id
        # this is used for the case that needs locate vm to a spcific host
        foreach my $host (keys %hostid) {
            my ($rc, $id, $stat) = search_src($ref_rhevm, "hosts", $host);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "Cannot find $host in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                return;
            }
            $hostid{$host} = $id;
        }
        my @nodes = (keys %node_hyp);
        my $macmac = $mactab->getNodesAttribs(\@nodes, ['mac']);
   
        foreach my $node (@nodes) {
            my $myvment = $vment->{$node}->[0];
            unless ($myvment) {
                my $rsp;
                push @{$rsp->{data}}, "$node: has NOT entry in vm table.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }
            
            # Check the existence of the node
            my ($rc, $vmid, $stat) = search_src($ref_rhevm, "vms", $node);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: virtual machine was not created.";
                xCAT::MsgUtils->message("I", $rsp, $callback);
                next;
            }
            
            # generate the content
            my $tplele;
            if ($myvment->{master}) {
                $tplele = "<template><name>$myvment->{master}</name></template>";
            }
            
            # configure memory
            my $memele;
            if ($myvment->{memory}) {
                my $memsize = $myvment->{memory};
                $memsize =~ s/g/000000000/i;
                $memsize =~ s/m/000000/i;
                $memele = "<memory>$memsize</memory>";
            }
            
            # set the cpu
            my $cpuele;
            if ($myvment->{cpus}) {
                my ($socketnum, $corenum) = split(':', $myvment->{cpus});
                unless ($corenum) {$corenum = 1;}
                $cpuele = "<cpu><topology cores=\"$corenum\" sockets=\"$socketnum\"/></cpu>";
            }
            
            # configure bootorder
            # there's a bug that sequence is not correct to set two order, so currently just set one
            my $boele;
            if ($myvment->{bootorder}) {
                my ($firstbr, $secbr) = split (',', $myvment->{bootorder});
                if ($secbr) {
                    $boele = "<os><boot dev=\"$firstbr\"/><boot dev=\"$secbr\"/><boot/></os>";
                } else {
                    $boele = "<os><boot dev=\"$firstbr\"/><boot/></os>";
                }
            }

            my $disele;
            if ($myvment->{vidproto}) {
                $disele = "<display><type>$myvment->{vidproto}</type></display>";
            }

            my $affinity;
            if ($myvment->{virtflags}) {
                # parse the specific parameters from vm.virtflags
                my @pairs = split (':', $myvment->{virtflags});
                foreach my $pair (@pairs) {
                    my ($name, $value) = split('=', $pair);
                    if ($name eq "placement_affinity") {
                        # set the affinity for placement_policy
                        $affinity = "<affinity>$value</affinity>"
                    }
                }
            }

            my $hostele;
            if ($myvment->{host}) {
                $hostele = "<host id=\"$hostid{$myvment->{host}}\"/>";
            }

            my $placement_policy;
            if ($affinity) {
                $placement_policy = "<placement_policy>$hostele$affinity</placement_policy>";
            } elsif ($hostele) {
                $affinity = "<affinity>migratable</affinity>";
                $placement_policy = "<placement_policy>$hostele$affinity</placement_policy>";
            }

            # set the cluster for the vm
            my $clusterele;
            if ($myvment->{cluster}) {
                $clusterele = "<cluster><name>$myvment->{cluster}</name></cluster>";
            }

            my $api = "/api/vms/$vmid";
            my $method = "PUT";
            
            my $content = "<vm><type>server</type><name>$node</name>$clusterele$tplele$memele$cpuele$boele$placement_policy$disele</vm>";
            my $request = genreq($ref_rhevm, $method, $api, $content);
            my $response;
            ($rc, $response) = send_req($ref_rhevm, $request->as_string());
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: $response";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            } else {
                my $parser = XML::LibXML->new();
                my $doc = $parser->parse_string($response);
                my $state;
                if ($node eq getAttr($doc, "/vm/name")) {
                    my $rsp;
                    push @{$rsp->{data}}, "$node: change vm completed.";
                    xCAT::MsgUtils->message("I", $rsp, $callback);
                    next;
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, "$node: change vm failed.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }
            } 
        }
    }
}

# Clone the virtual machine
# create template first
sub clonevm {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;

    my ($template, $basemaster);
    if ($args) {
        @ARGV=@{$args};
        GetOptions('t=s' => \$template,
                        'b' => \$basemaster);
    }

    my $ref_rhevm;
    my @nodes;
    foreach my $rhevm (keys %{$rhevm_hash}) {
        # generate the hash of rhevm which will be used for the action functions
        $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};

        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    push @nodes, @{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}};
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
             push @nodes, @{$rhevm_hash->{$rhevm}->{node}};
        }
    }

    my $node = $nodes[0];
    # create a template from a vm
    if ($template) {
        # Get the ID of node
        my ($rc, $vmid, $state) = search_src($ref_rhevm, "vms", $node);
        if ($rc) {
            my $rsp;
            push @{$rsp->{data}}, "$node: node was not defined in the rhevm.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return;
        }

        if ($state ne "down") {
            my $rsp;
            push @{$rsp->{data}}, "$node: vm needs to be shutdown to run the clone.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return;
        }

        my $api = "/api/templates";
        my $method = "POST";
        my $content = "<template><name>$template</name><vm id=\"$vmid\"/></template>";
        my $request = genreq($ref_rhevm, $method, $api, $content);
        my $response;
        ($rc, $response) = send_req($ref_rhevm, $request->as_string());
        if ($rc) {
            return (1, $response);
        } else {
            my $parser = XML::LibXML->new();
            my $doc = $parser->parse_string($response);
            if ($doc->findnodes("/template/status/state")->[0]) {
                my $state = $doc->findnodes("/template/status/state")->[0]->textContent();
    
                my $rsp;
                push @{$rsp->{data}}, "$template: $state.";
                xCAT::MsgUtils->message("I", $rsp, $callback);
            } else {
                my $rsp;
                push @{$rsp->{data}}, "$template: failed to get the status.";
                xCAT::MsgUtils->message("I", $rsp, $callback);
            }
            return;
        }
    }

}

# Set the boot sequence for the vm
sub rsetboot {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;

    my ($showstat, $bootdev);
    if ($args) {
        my $arg = $args->[0];
        if ($arg =~ /^stat/) {
            $showstat = 1;
        } else {
            $bootdev = $arg;
        }
    } else {
        $showstat = 1;
    }

    my ($firstbr, $secbr);
    if ($bootdev) {
        ($firstbr, $secbr) = split (',', $bootdev);
        if (($firstbr && $firstbr !~ /^(network|hd)$/) || ($secbr && $secbr !~ /^(network|hd)$/)) {
            my $rsp;
            push @{$rsp->{data}}, "Supported boot device: network, hd";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return 1;
        }
    }

    foreach my $rhevm (keys %{$rhevm_hash}) {
        my @nodes;
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};

        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    push @nodes, @{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}};
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
             push @nodes, @{$rhevm_hash->{$rhevm}->{node}};
        }

        foreach my $node (@nodes) {
            # Get the ID of vm
            my ($rc, $vmid, $state, $response) = search_src($ref_rhevm, "vms", $node);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: node was not defined in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }

            if ($showstat) {
                my $parser = XML::LibXML->new();
                my $doc = $parser->parse_string($response);
                my @bootdevs = getAttr($doc, "/vms/vm/os/boot", "dev");
                my $bootlist = join(',', @bootdevs);
                my $rsp;
                push @{$rsp->{data}}, "$node: $bootlist";
                xCAT::MsgUtils->message("I", $rsp, $callback);
                next;
            }

            # configure bootorder
            my $boele;
            if ($secbr) {
                $boele = "<os><boot dev=\"$firstbr\"/><boot dev=\"$secbr\"/><boot/></os>";
            } else {
                $boele = "<os><boot dev=\"$firstbr\"/><boot/></os>";
            }

            my $api = "/api/vms/$vmid";
            my $method = "PUT";
            
            my $content = "<vm>$boele</vm>";
            my $request = genreq($ref_rhevm, $method, $api, $content);
            ($rc, $response) = send_req($ref_rhevm, $request->as_string());
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: $response";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            } else {
                my $rsp;
                push @{$rsp->{data}}, "$node: set boot order completed.";
                xCAT::MsgUtils->message("I", $rsp, $callback);
                next;
            } 
        }
    }
}

#Migrate the virtual machine
sub rmigrate {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;

    my ($template, $basemaster);
    unless ($args) {
        my $rsp;
        push @{$rsp->{data}}, "Needs a target host.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
    }

    my $host = $args->[0];

    foreach my $rhevm (keys %{$rhevm_hash}) {
        my @nodes;
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};

        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    push @nodes, @{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}};
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
             push @nodes, @{$rhevm_hash->{$rhevm}->{node}};
        }

        foreach my $node (@nodes) {
            # Get the ID of vm
            my ($rc, $vmid, $state) = search_src($ref_rhevm, "vms", $node);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: node was not defined in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }

            my $hostid;
            ($rc, $hostid, $state) = search_src($ref_rhevm, "hosts", $host);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$host: host was not defined in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }

            # Remove the vm
            my $api = "/api/vms/$vmid/migrate";
            my $method = "POST";
            
            my $content = "<action><host id=\"$hostid\"/><force>true</force></action>";
            my $request = genreq($ref_rhevm, $method, $api, $content);
            my $response;
            ($rc, $response) = send_req($ref_rhevm, $request->as_string());
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: $response.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
            } else {
                my $parser = XML::LibXML->new();
                my $doc = $parser->parse_string($response);
                if ($doc->findnodes("/action/status/state")->[0]) {
                    my $state = $doc->findnodes("/action/status/state")->[0]->textContent();
        
                    my $rsp;
                    push @{$rsp->{data}}, "$node: migrated to $host: $state.";
                    xCAT::MsgUtils->message("I", $rsp, $callback);
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, "$node: failed to migrate to $host.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                }
            }
        }
    }
}

# Hardware control 
# rpower <vm> on/off/reset
sub power {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $args = shift;

    foreach my $rhevm (keys %{$rhevm_hash}) {
        my @nodes;
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};

        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    push @nodes, @{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}};
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
             push @nodes, @{$rhevm_hash->{$rhevm}->{node}};
        }

        # perform the action against the node
        foreach my $node (@nodes) {
            # Get the ID of node
            my ($rc, $id, $state) = search_src($ref_rhevm, "vms", $node);
            if ($rc) {
                my $rsp;
                push @{$rsp->{data}}, "$node: node was not defined in the rhevm.";
                xCAT::MsgUtils->message("E", $rsp, $callback);
                next;
            }
            
            my $output;
            if ($args->[0] eq 'on') {
                if ($state eq "up" || $state eq "powering_up") {
                    $output = "$node: on";
                } else {
                    my ($rc, $msg) = power_action($ref_rhevm, $id, 'start');
                    if (!$rc) {
                        $output = "$node: on";
                    } else {
                        $output = "$node: $msg";
                    }
                }
            } elsif ($args->[0] eq 'off') {
                if ($state eq "down" || $state eq "powering_down" || $state eq "powered_down") {
                    $output = "$node: off";
                } else {
                    my ($rc, $msg) = power_action($ref_rhevm, $id, 'stop');
                    if (!$rc) {
                        $output = "$node: off";
                    } else {
                        $output = "$node: $msg";
                    }
                }
            } elsif ($args->[0] eq 'reset' || $args->[0] eq 'boot') {
                if ($state eq "up" || $state eq "powering_up") {
                    my ($rc, $msg) = power_action($ref_rhevm, $id, 'stop');
                    if (!$rc) {
                        if (waitforcomplete($ref_rhevm, "/api/vms/$id", "/vm/status/state=down", 30)) {
                            my $rsp;
                            push @{$rsp->{data}}, "$node: failed to waiting the vm gets to \"down\" state.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        }
                        ($rc, $msg) = power_action($ref_rhevm, $id, 'start');
                        if (!$rc) {
                            $output = "$node: $args->[0]";
                        } else {
                            $output = "$node: $msg";
                        }
                    } else {
                        $output = "$node: $msg";
                    }
                } else {
                    my ($rc, $msg) = power_action($ref_rhevm, $id, 'start');
                    if (!$rc) {
                        $output = "$node: $args->[0]";
                    } else {
                        $output = "$node: $msg";
                    }
                }
            } elsif ($args->[0] eq 'softoff') {
                if ($state eq "down" || $state eq "powering_down" || $state eq "powered_down") {
                    $output = "$node: softoff";
                } else {
                    my ($rc, $msg) = power_action($ref_rhevm, $id, 'shutdown');
                    if (!$rc) {
                        $output = "$node: softoff";
                    } else {
                        $output = "$node: $msg";
                    }
                }
            } elsif ($args->[0] eq 'suspend') {
                if ($state eq "suspended") {
                    $output = "$node: suspended";
                } else {
                    my ($rc, $msg) = power_action($ref_rhevm, $id, 'suspend');
                    if (!$rc) {
                        $output = "$node: suspended";
                    } else {
                        $output = "$node: $msg";
                    }
                }
            } elsif ($args->[0] =~ /^stat/) {
                if ($state eq "down") {
                    $output = "$node: off";
                } elsif ($state eq "up") {
                    $output = "$node: on";
                } else {
                    $output = "$node: $state";
                }
            }
            my $rsp;
            push @{$rsp->{data}}, $output;
            xCAT::MsgUtils->message("I", $rsp, $callback);
        }
    }

}

# Do the power control
sub power_action {
    my $rhevm = shift;
    my $id = shift;
    my $action = shift;
    
    my $api = "/api/vms/$id/$action";
    my $method = "POST";
    my $content = "<action/>";
    my $request = genreq($rhevm, 
                       $method,
                       $api,
                       $content);
    my ($rc, $response) = send_req($rhevm, $request->as_string());
    if ($rc) {
        return (1, $response);
    } else {
        my $parser = XML::LibXML->new();
        my $doc = $parser->parse_string($response);
        my $state = $doc->findnodes("/action/status/state")->[0]->textContent();
        return (0, $state);
    }

    return (1);
}

# Search resource inside rhev-m
# $orgtype: format: [type] or [container:type]
#               [type] could be: datacenter, cluster ...
#               [container:type could be: 'vms:nics' ('vms' is the container of nic, 'nics' is the real type), vms:disk  
# $node: could be name for a resource; or the path of resource when start with '/'
#           if no $node specified, search all resource with the '$type'
# $individual: do search for a resource individually
#
# return -1-parameter error; 11-nosuch id; 
sub search_src {
    my $rhevm = shift;
    my $orgtype = shift;
    my $node = shift;
    my $individual = shift;

    my $api;
    my ($container, $type);
    if ($orgtype =~ /:/) {
        ($container, $type) = split (/:/, $orgtype);
    } else {
       $container = $type = $orgtype;
    }

    my $ispath;
    if ($node) {
        if ($node =~ /^\//) {
            # is a path
            $api = "/api/$container".$node;
            $ispath = 1;
        } elsif ($node =~ /\%3D/) {
            $api = "/api/$container?search=$node";
        } elsif ($node eq "xxxxxx_all_objs") {
            $api = "/api/$container";
        }else {
            $api = "/api/$container?search=name%3D$node";
            if ($type eq "hosts") {
                #append the domain for the hypervisor
                $api .= "*";
            }
        }
    } else {
        $api = "/api/$container";
    }
    my $method = "GET";
    my $content = "";

    my $request = genreq($rhevm, $method, $api, $content);
    my ($rc, $response) = send_req($rhevm, $request->as_string());

    if ($rc) {
        return ($rc, $response);
    } else {
        my $parser = XML::LibXML->new();
        my $doc = $parser->parse_string($response);
        if ($doc ) {
            my ($id, $state, $idstr, $ststr);
            if ($type eq "vms") {
                $idstr = "/vms/vm";
            } elsif ($type eq "hosts") {
                if ($individual) {
                    $idstr = "/host";
                } else {
                    $idstr = "/hosts/host";
                }
            } elsif ($type eq "templates") {
                $idstr = "/templates/template";
            } elsif ($type eq "storagedomains") {
                if ($individual) {
                    $idstr = "/storage_domain";
                } else {
                    $idstr = "/storage_domains/storage_domain";
                }
            } elsif ($type eq "networks") {
                if ($individual) {
                    $idstr = "/network";
                } else {
                    $idstr = "/networks/network";
                }                
            } elsif ($type eq "datacenters") {
                $idstr = "/data_centers/data_center";
            } elsif ($type eq "clusters") {
                $idstr = "/clusters/cluster";
            } elsif ($type eq "disks") {
                $idstr = "/disks/disk";
            } elsif ($type eq "nics") {
                $idstr = "/nics/nic";
            } elsif ($type eq "host_nics") {
                $idstr = "/host_nics/host_nic";
            } else {
                return (-1);
            }

            my $idnode;
            # network is special that does not support to  serach a specific resource, 
            # so have to do the search by code from all the output
            if ($type eq "networks" && $node &&(!$ispath)) { 
                my @nodes = $doc->findnodes($idstr);
                foreach my $n (@nodes) {
                    if ($node eq getAttr($n, "name")) {
                        $idnode = $n;
                        last;
                    }
                }
            } else {
                $idnode = $doc->findnodes($idstr)->[0];
            }
            if (defined $idnode) {
              $id = $idnode->getAttribute('id');
              if ($type eq "vms") {
                  $ststr = "/vms/vm/status/state";
              } elsif ($type eq "hosts") {
                  $ststr = "/hosts/host/status/state";
              } elsif ($type eq "templates") {
                  $ststr = "/templates/template/status/state";
              } elsif ($type eq "storagedomains") {
                  if ($individual) {
                      $ststr = "/storage_domain/storage/type";
                  } else {
                      $ststr = "/storage_domains/storage_domain/storage/type";
                  }
              } elsif ($type eq "networks") {
                  $ststr = "status/state";
                  $doc = $idnode;
              } elsif ($type eq "datacenters") {
                  $ststr = "/data_centers/data_center/status/state";
              } elsif ($type eq "clusters") {
                  $ststr = "/clusters/cluster/name";
              } elsif ($type eq "disks") {
                  $ststr = "/disks/disk/status/state";
              } elsif ($type eq "nics") {
                  $ststr = "/nics/nic/name";
              } elsif ($type eq "host_nics") {
                  $ststr = "/host_nics/host_nic/status/state";
              } else {
                  return (-1);
              }
              my $statenode = $doc->findnodes($ststr)->[0];
              if (defined $statenode) {
                $state = $statenode->textContent();
              }

              # no id was found
              if (!$id) {
                  return (11);
              }
              
              return (0, $id, $state, $response);
            } else {
                return (11);
            }
        }
    }

    return (1);
}

# Get the value for a element from the xml of rest api response
sub getAttr {
    my $doc = shift;
    my $path = shift;
    my $att = shift;

    my @nodes;
    if ($path) {
        # handle the cases that has multiple entries for one atributes like boot order
        @nodes = $doc->findnodes($path);
    } else {
        push @nodes, $doc;
    }
    
    if (@nodes) {
        my @value;
        foreach my $node (@nodes) {
            if ($att) {
                push @value, $node->getAttribute($att);
            } else {
                push @value, $node->textContent();
            }
        }
        return join (',', @value);
    } else {
        return "";
    }
}

# It's a command that will be triggered from the httpd when the installation of rhev-h has finished
# Run nodeset and updatenodestat to update the status for the rhev-h
sub rhevhupdateflag {
    my $request = shift;
    my $callback = shift;
    my $subreq = shift;

    my $node = $request->{node};
    
    # run the nodeset xx next
    $subreq->({command=>['nodeset'], node=>$node, arg=>['next']}, $callback);

    # run the 'updatenodestat <node> booted'
    $subreq->({command=>['updatenodestat'], node=>$node, arg=>['booted']}, $callback);
}

# use the md5 to authorize the passwd
sub authpw {
    my $passwd = shift;

    if ($passwd =~ /^\$1\$/) {
        return $passwd;
    } else {
        my $cmd = "openssl passwd -1 $passwd";
        return xCAT::Utils->runcmd($cmd, -1);
    }
}

# Configure the network for host
# create the network for cluster if it does not exist
# configure the interface and add them to the corresponding network
sub cfghypnw {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $host = shift;
    my $interface = shift;
    my $datacenter = shift;
    
    # the format of the interface attirbute
    # networkname:interfacename:bootpro:IP:netmask:gateway
    my @if = split(/\|/, $interface);
    foreach (@if) {
        my ($netname, $ifname, $bprotocol, $ip, $nm, $gw) = split (':', $_);
        unless ($netname && $ifname) {
            my $rsp;
            push @{$rsp->{data}}, "$host: Missing network name or interface name: $_.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            next;
        }

        # get host id
        my ($rc, $hostid, $stat) = search_src($ref_rhevm, "hosts", $host);
        if ($rc) {
            my $rsp;
            push @{$rsp->{data}}, "$host: host was not created.";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            next;
        }
        
        # get network interface and configure it
        my $nicid;
        my $api = "/api/hosts/$hostid/nics";
        my $method = "GET";
        my $request = genreq($ref_rhevm, $method, $api, "");
        my $response;
        ($rc, $response) = send_req($ref_rhevm, $request->as_string());
        if ($rc) {
            my $rsp;
            push @{$rsp->{data}}, "$host: $response";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            next;
        } else {
            my $parser = XML::LibXML->new();
            my $doc = $parser->parse_string($response);
            my @hostnics = $doc->findnodes("/host_nics/host_nic");
            foreach my $nicnode (@hostnics) {
                if ($ifname eq getAttr($nicnode, "name")) {
                    $doc = $nicnode;
                    last;
                }
            }
                
            if ($doc ) {
                my $attr;
                if ($attr = getAttr($doc, "", "id")) {
                    $nicid = $attr;
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, "$host: does not have interface $ifname.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }

                # get the network
                my $oldnetname;
                my $oldnetid;
                if ($attr = getAttr($doc, "network", "id")) {
                    $oldnetid = $attr;
                }
                if ($attr = getAttr($doc, "network/name")) {
                    $oldnetname = $attr;
                }

                # attach the nic to the network if needed
                # search the network
                my $newnetid;
                ($rc, $newnetid, $stat) = search_src($ref_rhevm, "networks", $netname);
                if ($rc) {
                    if ($rc == 11) {
                        my $rsp;
                        push @{$rsp->{data}}, "$host: network: $netname does not exist.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                    } else {
                        my $rsp;
                        push @{$rsp->{data}}, "$host: failed to get the network: $netname.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                    }
                    next;
                }

                # detach the nic from current network if old != new
                if (($oldnetname && ($oldnetname ne $netname))
                  ||($oldnetid && ($oldnetid ne $newnetid))) { 
                     unless ($oldnetid) {
                         ($rc, $oldnetid, $stat) = search_src($ref_rhevm, "networks", $oldnetname);
                         if ($rc) {
                            my $rsp;
                            push @{$rsp->{data}}, "$host: failed to get the network: $oldnetname.";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                         }
                     }
                     #detach the interface to the network
                     if (attach($callback, $ref_rhevm, "/api/hosts/$hostid/nics/$nicid", "network", $oldnetid, 1)) {
                        my $rsp;
                        push @{$rsp->{data}}, "$host: failed to detach $ifname from $netname.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        next;
                     }
                }

                # attach the interface to the network
                if ((!$oldnetname || ($oldnetname ne $netname))
                  && (!$oldnetid || ($oldnetid ne $newnetid))) {
                    if (attach($callback, $ref_rhevm, "/api/hosts/$hostid/nics/$nicid", "network", $newnetid)) {
                        my $rsp;
                        push @{$rsp->{data}}, "$host: failed to attach $ifname to $netname.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        next;
                     }
                     generalaction($callback, $ref_rhevm, "/api/hosts/$hostid/commitnetconfig");
                 }
                
                # check the bootprotocol and network parameters, and configure if needed
                if (defined ($bprotocol) && $bprotocol =~ /^(dhcp|static)$/) {
                    my $newpro;
                    if ($attr = getAttr($doc, "boot_protocol")) {
                        if ($attr eq "dhcp") {
                            if ($bprotocol eq "static" ) {
                                $newpro = "static";
                            }
                        } elsif ($attr eq "static") {
                            if ($bprotocol eq "dhcp") {
                                $newpro = "dhcp";
                            } else {
                                my ($curip, $curnm, $curgw);
                                if ($attr = getAttr($doc, "ip", "address")) {
                                    $curip = $attr;
                                } 
                                if ($attr = getAttr($doc, "ip", "netmask")) {
                                    $curnm = $attr;
                                } 
                                if ($attr = getAttr($doc, "ip", "gateway")) {
                                    $curgw = $attr;
                                } 

                                if ($ip ne $curip || $nm ne $curnm || $gw ne $curgw) {
                                    $newpro = "static";
                                }
                            }
                        }
                    } else {
                        $newpro = $bprotocol;
                    }

                    # Set the attributes for the nic
                    $api = "/api/hosts/$hostid/nics/$nicid";
                    $method = "PUT";
                    my $content;
                    if (defined ($newpro) && $newpro eq "dhcp")  {
                        $content = "<host_nic><boot_protocol>dhcp</boot_protocol></host_nic>";
                    } elsif (defined ($newpro) && $newpro eq "static")  {
                        $content = "<host_nic><boot_protocol>static</boot_protocol><ip address=\"$ip\" netmask=\"$nm\" gateway=\"$gw\"/></host_nic>";
                    }
                    if (defined ($newpro)) {
                        my $request = genreq($ref_rhevm, $method, $api, $content);
                        ($rc, $response) = send_req($ref_rhevm, $request->as_string());
                        if ($rc) {
                            my $rsp;
                            push @{$rsp->{data}}, "$host: $response";
                            xCAT::MsgUtils->message("E", $rsp, $callback);
                            next;
                        }
                    }
                } else {
                    my $rsp;
                    push @{$rsp->{data}}, "$host: the boot procotol was not set or invalid.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    next;
                }

                 generalaction($callback, $ref_rhevm, "/api/hosts/$hostid/commitnetconfig");
            }
        }
    }
    
    return 0;
}

# Create a Storage Domain
# The parameters will be gotten from virtsd table
sub mkSD {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $sd = shift;

    # get the informage for the SD
    my ($rc, $sdid, $state) = search_src($ref_rhevm, "storagedomains", $sd);
    if (!$rc) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: storagedomains has been defined in the rhevm.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 0;
    } 

    # get the attributes for the SD
    my $vsdtab = xCAT::Table->new('virtsd',-create=>0);
    my $vsdent = $vsdtab->getAttribs({'node'=>$sd}, ['sdtype', 'stype', 'location', 'host', 'datacenter']);
    unless ($vsdent) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: cannot find the definition for $sd in the virtsd table.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 0;
    }

    unless ($vsdent->{host}) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: a SPM host needs to be specified.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 0;
    }
    unless ($vsdent->{stype} && (($vsdent->{stype} eq "localfs") || $vsdent->{location})) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: the sdtype and location need to be specified.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 0;
    }

    unless ($vsdent->{stype} =~ /^(nfs|localfs)$/) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: supported storage type: nfs, localfs.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 0;
    }

    # get the host as SPM
    my $hostid;
    ($rc, $hostid, $state) = search_src($ref_rhevm, "hosts", $vsdent->{host});
    if ($rc) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: cannot find the host $vsdent->{host}.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 0;
    } 
    
    # To create the SD
    my $api = "/api/storagedomains";
    my $method = "POST";

    # Create the xml data
    my $doc = XML::LibXML->createDocument();
    my $root = $doc->createElement("storage_domain");
    $doc->setDocumentElement($root);

    $root->appendTextChild("name", $sd);

    # set the host will be the SPM
    my $host_ele = $doc->createElement("host");
    $root->appendChild($host_ele);
    $host_ele->setAttribute("id", $hostid);

    # set the location of storage
    my $storage_ele = $doc->createElement("storage");
    $root->appendChild($storage_ele);
    $storage_ele->appendTextChild("type", $vsdent->{stype});
    
    my ($address, $path) = split(':', $vsdent->{location});
    if ($vsdent->{stype} eq "nfs") {
        $storage_ele->appendTextChild("address", $address);
        $storage_ele->appendTextChild("path", $path);
    } elsif ($vsdent->{stype} eq "localfs") {
        $storage_ele->appendTextChild("path", "/data/images/rhev");
    }

    if ($vsdent->{sdtype}) {
        $root->appendTextChild("type", $vsdent->{sdtype});
    } else {
        $root->appendTextChild("type", "data");
    }

    my $request = genreq($ref_rhevm, $method, $api, $doc->toString);
    my $response;
    ($rc, $response) = send_req($ref_rhevm, $request->as_string());

    
    if ($rc) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: $response";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 0;
    } else {
        my $parser = XML::LibXML->new();
        my $doc = $parser->parse_string($response);
        if ($doc ) {
            my $sdid;
            if ($sdid = getAttr($doc, "/storage_domain", "id")) {
                if ($vsdent->{stype} eq "localfs") {
                    #return directly
                    return $sdid;
                }
                # attach the storage domain to the datacenter
                my $dc = $vsdent->{datacenter};
                unless ($dc) {$dc = "default"};
                my $dcid;
                ($rc, $dcid, $state) = search_src($ref_rhevm, "datacenters", $dc);
                if ($rc) {
                    my $rsp;
                    push @{$rsp->{data}}, "$sd: $response";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    return 0;
                }

                # attach the storage domain to the datacenter
                if (attach($callback, $ref_rhevm, "/api/datacenters/$dcid/storagedomains", "storage_domain", $sdid)) {
                    my $rsp;
                    push @{$rsp->{data}}, "$sd: failed to attach to datacenter:$dc.";
                    xCAT::MsgUtils->message("E", $rsp, $callback);
                    return 0;
                }

                # Check the state of the storage domain
                if (checkstat($callback, $ref_rhevm, "storage_domain", "/api/datacenters/$dcid/storagedomains/$sdid") ne "active") {
                    # active the storage domain
                    if (activate($callback, $ref_rhevm,"/api/datacenters/$dcid/storagedomains/$sdid", $sd)) {
                        my $rsp;
                        push @{$rsp->{data}}, "$sd: failed to activate the storage domain.";
                        xCAT::MsgUtils->message("E", $rsp, $callback);
                        return 0;
                    }
                }
                
                return $sdid;
            }
        }
    }

    return 0;
}

# Activate or Deactive a resource
# 0 - suc; 1 - failed
sub activate {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $path = shift;
    my $name = shift;
    my $deactivate = shift;

    my $api;
    if ($deactivate) {
        $api = $path."/deactivate";
    } else {
        $api = $path."/activate";
    }
    my $method = "POST";
    my $content = "<action/>";
    my $request = genreq($ref_rhevm, $method, $api, $content);

    my ($rc, $response) = send_req($ref_rhevm, $request->as_string());
    if ($rc) {
            my $rsp;
            push @{$rsp->{data}}, "$name: $response";
            xCAT::MsgUtils->message("E", $rsp, $callback);
            return 1;
    } else {
        my $parser = XML::LibXML->new();
        my $doc = $parser->parse_string($response);
        if ($doc ) {
            my $attr;
            if ($attr = getAttr($doc, "/action/status/state")) {
                if ($attr ne "complete") {
                    if (waitforcomplte()) {
                        return 1;
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            }
        }
    }
    return 1;
}

# Attach or Detach a resource
# type: network (for host nic), storage_domain (for sd)
# 0 - suc; 1 - failed
sub attach {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $path = shift;
    my $type = shift;
    my $id = shift;
    my $detach = shift;

    my $method = "POST";
    my $api;
    my $content;
    if ($type eq "storage_domain") {
        if ($detach) {
            $api = "$path/$id";
            $method = "DELETE";
            $content = "";
        } else {
            $api = $path;
            $content = "<$type id=\"$id\"/>";
        }
    } else {
        if ($detach) {
            $api = $path."/detach";
        } else {
            $api = $path."/attach";
        }
        $content = "<action><$type id=\"$id\"/></action>";
    }
    
    
    my $request = genreq($ref_rhevm, $method, $api, $content);

    my ($rc, $response) = send_req($ref_rhevm, $request->as_string());
    if ($rc) {
        # no output for detaching sd from datacenter
        if ($rc == 2 && $type eq "storage_domain" && $detach) {
            return 0;
        }
        my $rsp;
        push @{$rsp->{data}}, "$response:$rc";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 1;
    } else {
        my $parser = XML::LibXML->new();
        my $doc = $parser->parse_string($response);
        if ($doc ) {
            my $attr;
            if ($type eq "storage_domain") {
                 if (getAttr($doc, "/storage_domain/status/state") =~ /(inactive|active)/) {
                     return 0;
                 } else {
                     return 1;
                 }
            } else {
                if ("complete" eq getAttr($doc, "/action/status/state")) {
                    return 0;
                 } else {
                    return 1;
                }
            }
        }
    }
    return 1;
}

# Common subroutine for general action of rest api
sub generalaction {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $api = shift;
    my $method = shift;
    my $norsp = shift;
    my $force = shift;

    unless ($method) {
        $method = "POST";
    }

    my $content = "<action/>";
    if ($force) {
        $content = "<action><force>true</force></action>";
    }
    my $request = genreq($ref_rhevm, $method, $api, $content);
    my ($rc, $response) = send_req($ref_rhevm, $request->as_string());

    # no need to handle response for DELETE
    if ($norsp && !$response) {
        return;
    }
    
    if ($rc) {
        my $rsp;
        push @{$rsp->{data}}, "$response";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 1;
    }
}

# Check the state of a object
sub checkstat {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $type = shift;
    my $api = shift;

    my $request = genreq($ref_rhevm, "GET", $api, "");
    my ($rc, $response) = send_req($ref_rhevm, $request->as_string());
    if ($rc) {
        return "";
    } else {
        my $parser = XML::LibXML->new();
        my $doc = $parser->parse_string($response);
        if ($doc ) {
            if ($type eq "storage_domain") {
                 return getAttr($doc, "/storage_domain/status/state")
            } 
        }
    }

    return "";
}

# delete storage domain
sub deleteSD {
    my $callback = shift;
    my $ref_rhevm = shift;
    my $path = shift;
    my $sd = shift;

    # get the attributes for the SD
    my $vsdtab = xCAT::Table->new('virtsd',-create=>0);
    my $vsdent = $vsdtab->getAttribs({'node'=>$sd}, ['host']);
    unless ($vsdent) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: cannot find the definition for $sd in the virtsd table.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 1;
    }

    unless ($vsdent->{host}) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: a SPM host needs to be specified.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 1;
    }
    
    # get the id of host
    my ($rc, $hostid, $stat) = search_src($ref_rhevm, "hosts", $vsdent->{host});
    if ($rc) {
        my $rsp;
        push @{$rsp->{data}}, "$sd: Cannot find the host: $vsdent->{host} for the storag domain.";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 1;
    }
    
    my $method = "DELETE";
    my $api = $path;
    my $content;

    $content = "<storage_domain><host id=\"$hostid\"/><format>true</format></storage_domain>";

    my $request = genreq($ref_rhevm, $method, $api, $content);
    my $response;
    ($rc, $response) = send_req($ref_rhevm, $request->as_string());

    # no need to handle response for DELETE
    if ($rc) {
        # no output for detaching sd from datacenter
        if ($rc == 2) {
            return 0;
        }
        my $rsp;
        push @{$rsp->{data}}, "$response";
        xCAT::MsgUtils->message("E", $rsp, $callback);
        return 1;
    }
}

sub waitforcomplete {
    my $ref_rhevm = shift;
    my $api = shift;
    my $criteria = shift;
    my $timeout = shift;

    unless ($timeout) {
        $timeout = 10;
    }

    my ($path, $target) = split ('=', $criteria);

    my $method = "GET";
    my $content = "";

    my $start = Time::HiRes::gettimeofday();

    while (1) {

        my $request = genreq($ref_rhevm, $method, $api, $content);
        my ($rc, $response) = send_req($ref_rhevm, $request->as_string());
    
        if ($rc) {
            return ($rc, $response);
        } else {
            my $parser = XML::LibXML->new();
            my $doc = $parser->parse_string($response);
            if ($doc ) {
                if ($target eq getAttr($doc, $path)) {
                    return 0;
                }
            }
        }

        my $now = Time::HiRes::gettimeofday();
        if (($now - $start) > $timeout) {
            return 2;
        } else {
            sleep (0.5);
        }
    }
    
    return 1;
}

# Get the vid prameters for external video console program to display console
sub getrvidparms {
    my $callback = shift;
    my $rhevm_hash = shift;
    my $nodes = shift;

    foreach my $rhevm (keys %{$rhevm_hash}) {
        my @nodes;
        # generate the hash of rhevm which will be used for the action functions
        my $ref_rhevm = {'name' => $rhevm, 
                                 'user' => $rhevm_hash->{$rhevm}->{user}, 
                                 'pw' => $rhevm_hash->{$rhevm}->{pw}};

        # generate the node that will be handled
        if (defined $rhevm_hash->{$rhevm}->{host}) {
            foreach my $rhevh (keys %{$rhevm_hash->{$rhevm}->{host}}) {
                if (defined $rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}) {
                    push @nodes, @{$rhevm_hash->{$rhevm}->{host}->{$rhevh}->{node}};
                }
            }
        }
        if (defined $rhevm_hash->{$rhevm}->{node}) {
             push @nodes, @{$rhevm_hash->{$rhevm}->{node}};
        }

        # perform the action against the node
        foreach my $node (@nodes) {
            my $node = $nodes->[0];
            my %consparam;
            $consparam{method} = 'kvm';
        
            # get the attributes for vm
            my ($rc, undef, undef, $response) = search_src($ref_rhevm, "vms", "$node");
        
            my $vmid;
            my $rsp;
            if ($rc) {
                $rsp->{node}->[0]->{errorcode} = $rc;
                $rsp->{node}->[0]->{name}->[0]=$node;
                $rsp->{node}->[0]->{error} = $response;
                $callback->($rsp);
                next;
            } else {
                my $parser = XML::LibXML->new();
                my $doc = $parser->parse_string($response);
                if ($doc ) {
                    my $attr;
                    if ($attr = getAttr($doc, "/vms/vm", "id")) {
                        $vmid = $attr;
                    }
                    if ($attr = getAttr($doc, "/vms/vm/display/type")) {
                        $consparam{vidproto} = $attr;
                    }
                    if ($attr = getAttr($doc, "/vms/vm/display/address")) {
                        $consparam{server} = $attr;
                    }
                    if ($attr = getAttr($doc, "/vms/vm/display/port")) {
                        $consparam{vidport} = $attr;
                    }
                }
            }
        
            # get the password ticket for the external program to accesss the VNC
            my $api = "/api/vms/$vmid/ticket";
            my $method = "POST";
            my $content = "<action><ticket><expiry>120</expiry></ticket></action>";
        
            my $request = genreq($ref_rhevm, $method, $api, $content);
            ($rc, $response) = send_req($ref_rhevm, $request->as_string());
        
            if ($rc) {
                $rsp->{node}->[0]->{errorcode} = $rc;
                $rsp->{node}->[0]->{name}->[0]=$node;
                $rsp->{node}->[0]->{error} = $response;
                $callback->($rsp);
                next;
            } else {
                my $parser = XML::LibXML->new();
                my $doc = $parser->parse_string($response);
                if ($doc ) {
                    my $attr;
                    if ($attr = getAttr($doc, "/action/ticket/value")) {
                        $consparam{password} = $attr;
                    }    
                }
            }
        
            
            $rsp = ();
            $rsp->{node}->[0]->{name}->[0]=$node;
            foreach (keys %consparam) {
                $rsp->{node}->[0]->{data}->[0]->{desc}->[0] = $_;
                $rsp->{node}->[0]->{data}->[0]->{contents}->[0] = $consparam{$_};
                $callback->($rsp);
            }
        }
    }

    return;
}


1;