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

=head1
  xCAT plugin package to handle xdsh

   Supported command:
         nodenetconn
         ipforward (internal command)

=cut

#-------------------------------------------------------
package xCAT_plugin::vlan;
BEGIN
{
  $::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
}
use lib "$::XCATROOT/lib/perl";
use strict;
use xCAT::Table;
use xCAT::Utils;
use xCAT::NetworkUtils;
use xCAT::MsgUtils;
use Getopt::Long;
use xCAT::NodeRange;
use Data::Dumper;
use Text::Balanced qw(extract_bracketed);
use xCAT::SwitchHandler;
use Safe;
my $evalcpt = new Safe;
$evalcpt->share('&mknum');
$evalcpt->permit('require');

my %Switches=();
  
1;

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

=head3  handled_commands

Return list of commands handled by this plugin

=cut

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

sub handled_commands
{
    return {
            mkvlan => "vlan",
            chvlan => "vlan",
            rmvlan => "vlan",
            lsvlan => "vlan",
            chvlanports => "vlan",
           };
}


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

=head3  preprocess_request

  Preprocess the command

=cut

#-------------------------------------------------------
sub preprocess_request
{

    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    my $command = $request->{command}->[0];
    $::CALLBACK = $callback;

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

    if ($command eq "mkvlan") {
	return preprocess_mkvlan($request,$callback,$sub_req);
    } elsif($command eq "chvlanports"){
        return preprocess_chvlanports($request,$callback,$sub_req);
    } elsif ($command eq "chvlan") {
	return preprocess_chvlan($request,$callback,$sub_req);
    } elsif ($command eq "rmvlan") {
	return preprocess_rmvlan($request,$callback,$sub_req);
    } elsif ($command eq "lsvlan") {
	return preprocess_lsvlan($request,$callback,$sub_req);
    } else {
	my $rsp={};
	$rsp->{error}->[0]= "$command: unsupported command.";
	$callback->($rsp);
	return 1;
    }
}

sub preprocess_mkvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    my $command = $request->{command}->[0];
    my $args    = $request->{arg};

    # parse the options
    @ARGV=();
    if ($args) {
	@ARGV=@{$args};
    }
    Getopt::Long::Configure("bundling");
    Getopt::Long::Configure("no_pass_through");

    my $nr;
    my $net;
    my $netmask;
    my $prefix;
    my $nic;
    if(!GetOptions(
	    'h|help'      => \$::HELP,
	    'v|version'   => \$::VERSION,
	    'n|nodes=s'   => \$nr,
	    't|net=s'   => \$net,
	    'm|mask=s'   => \$netmask,
	    'p|prefix=s'   => \$prefix,
            'i|interface=s' => \$nic,
       ))
    {
	&mkvlan_usage($callback);
	return 1;
    }
    # display the usage if -h or --help is specified
    if ($::HELP) {
	&mkvlan_usage($callback);
	return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($::VERSION)
    {
	my $rsp={};
	$rsp->{data}->[0]= xCAT::Utils->Version();
	$callback->($rsp);
	return 0;
    }

    my $vlan_id=0;
    if (@ARGV>0) {
	$vlan_id=$ARGV[0];   
    }

    my @nodes=();
    if ($nr) {
	#get nodes
	@nodes = noderange($nr);
	if (nodesmissed) {
	    my $rsp={};
	    $rsp->{data}->[0]= "Invalid nodes in noderange:".join(',',nodesmissed);
	    $callback->($rsp);
	    return 1;
	}
    } else {
	my $rsp={};
	$rsp->{data}->[0]= "Please specify a list of nodes to be added to the new vlan.";
	$callback->($rsp);
	return 1;
    }

    
    if ($net && (!$netmask)) {
	my $rsp={};
	$rsp->{data}->[0]= "Please specify a netmask for the vlan.";
	$callback->($rsp);
	return 1;
    }
    if ($netmask && (!$net)) {
	my $rsp={};
	$rsp->{data}->[0]= "Please specify a network address for the vlan.";
	$callback->($rsp);
	return 1;
    }

    #let process _request to handle it
    my $reqcopy = {%$request};
    $reqcopy->{_xcatpreprocessed}->[0] = 1;
    $reqcopy->{vlanid}->[0] = $vlan_id; 
    $reqcopy->{node} = \@nodes;
    if ($net) { $reqcopy->{net}->[0]=$net; }
    if ($netmask) { $reqcopy->{netmask}->[0]=$netmask; }
    if ($prefix) { $reqcopy->{prefix}->[0]=$prefix; }
    if ($nic) { $reqcopy->{nic}->[0]=$nic; }
    return [$reqcopy];
}
# TODO: finish this
sub preprocess_chvlanports {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    my $command = $request->{command}->[0];
    my $args    = $request->{arg};

    # parse the options
    @ARGV=();
    if ($args) {
	@ARGV=@{$args};
    }
    Getopt::Long::Configure("bundling");
    Getopt::Long::Configure("no_pass_through");

    my $nr;
    my $delete;
    my $nic;
    if(!GetOptions(
        'h|help'      => \$::HELP,
        'v|version'   => \$::VERSION,
        'n|nodes=s'   => \$nr,
        'd|delete'    => \$delete,
        'i|interface=s' => \$nic,
    ))
    {
        &chvlanports_usage($callback);
        return 1;
    }
    # display the usage if -h or --help is specified
    if ($::HELP) {
        &chvlanports_usage($callback);
        return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($::VERSION)
    {
        my $rsp={};
        $rsp->{data}->[0]= xCAT::Utils->Version();
        $callback->($rsp);
        return 0;
    }
    if (@ARGV==0) {
        my $rsp={};
        $rsp->{data}->[0]= "Please specify a vlan id.";
        $callback->($rsp);
        return 1;
    }

    my $vlan_id=$ARGV[0];   

    my @nodes=();
    if (!$nr) {
        my $rsp={};
        $rsp->{data}->[0]= "Please specify a range of nodes to be added to vlan $vlan_id.";
        $callback->($rsp);
        return 1;
    } else {
        #get nodes
        @nodes = noderange($nr);
        if (nodesmissed) {
            my $rsp={};
            $rsp->{data}->[0]= "Invalid nodes in noderange:".join(',',nodesmissed);
            $callback->($rsp);
            return 1;
        }
    }
    
    if (!$nic) {
        my $rsp={};
        $rsp->{data}->[0]= "Please specify a network interface for nodes";
        $callback->($rsp);
        return 1;
    }

    #let process _request to handle it
    my $reqcopy = {%$request};
    $reqcopy->{_xcatpreprocessed}->[0] = 1;
    $reqcopy->{vlanid}->[0]=$vlan_id;
    $reqcopy->{node} = \@nodes;
    $reqcopy->{delete}->[0] = $delete;
    $reqcopy->{nic}->[0]=$nic;
    return [$reqcopy];
}

sub preprocess_chvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    my $command = $request->{command}->[0];
    my $args    = $request->{arg};

    # parse the options
    @ARGV=();
    if ($args) {
	@ARGV=@{$args};
    }
    Getopt::Long::Configure("bundling");
    Getopt::Long::Configure("no_pass_through");

    my $nr;
    my $delete;
    my $nic;
    if(!GetOptions(
	    'h|help'      => \$::HELP,
	    'v|version'   => \$::VERSION,
	    'n|nodes=s'   => \$nr,
	    'd|delete'    => \$delete,
            'i|interface=s' => \$nic,
       ))
    {
	&chvlan_usage($callback);
	return 1;
    }
    # display the usage if -h or --help is specified
    if ($::HELP) {
	&chvlan_usage($callback);
	return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($::VERSION)
    {
	my $rsp={};
	$rsp->{data}->[0]= xCAT::Utils->Version();
	$callback->($rsp);
	return 0;
    }
    if (@ARGV==0) {
	my $rsp={};
	$rsp->{data}->[0]= "Please specify a vlan id.";
	$callback->($rsp);
	return 1;
    }

    my $vlan_id=$ARGV[0];   

    my @nodes=();
    if (!$nr) {
	my $rsp={};
	$rsp->{data}->[0]= "Please specify a range of nodes to be added to vlan $vlan_id.";
	$callback->($rsp);
	return 1;
    } else {
	#get nodes
	@nodes = noderange($nr);
	if (nodesmissed) {
	    my $rsp={};
	    $rsp->{data}->[0]= "Invalid nodes in noderange:".join(',',nodesmissed);
	    $callback->($rsp);
	    return 1;
	}
    }

    #let process _request to handle it
   my $reqcopy = {%$request};
    $reqcopy->{_xcatpreprocessed}->[0] = 1;
    $reqcopy->{vlanid}->[0]=$vlan_id;
    $reqcopy->{node} = \@nodes;
    $reqcopy->{delete}->[0] = $delete;
    if ($nic) { $reqcopy->{nic}->[0]=$nic; }
    return [$reqcopy];
}

sub preprocess_rmvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    my $command = $request->{command}->[0];
    my $args    = $request->{arg};

    # parse the options
    @ARGV=();
    if ($args) {
	@ARGV=@{$args};
    }
    Getopt::Long::Configure("bundling");
    Getopt::Long::Configure("no_pass_through");

    my $nodes;
    if(!GetOptions(
	    'h|help'      => \$::HELP,
	    'v|version'   => \$::VERSION,
       ))
    {
	&rmvlan_usage($callback);
	return 1;
    }
    # display the usage if -h or --help is specified
    if ($::HELP) {
	&rmvlan_usage($callback);
	return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($::VERSION)
    {
	my $rsp={};
	$rsp->{data}->[0]= xCAT::Utils->Version();
	$callback->($rsp);
	return 0;
    }

    if (@ARGV==0) {
	my $rsp={};
	$rsp->{data}->[0]= "Please specify a vlan id.";
	$callback->($rsp);
	return 1;
    }

    my $vlan_id=$ARGV[0];   

    #let process _request to handle it
    my $reqcopy = {%$request};
    $reqcopy->{_xcatpreprocessed}->[0] = 1;
    $reqcopy->{vlanid}->[0]=$vlan_id;
    return [$reqcopy];
}

sub preprocess_lsvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    my $command = $request->{command}->[0];
    my $args    = $request->{arg};

    # parse the options
    @ARGV=();
    if ($args) {
	@ARGV=@{$args};
    }
    Getopt::Long::Configure("bundling");
    Getopt::Long::Configure("no_pass_through");

    my $nodes;
    if(!GetOptions(
	    'h|help'      => \$::HELP,
	    'v|version'   => \$::VERSION,
       ))
    {
	&lsvlan_usage($callback);
	return 1;
    }
    # display the usage if -h or --help is specified
    if ($::HELP) {
	&lsvlan_usage($callback);
	return 0;
    }
    # display the version statement if -v or --verison is specified
    if ($::VERSION)
    {
	my $rsp={};
	$rsp->{data}->[0]= xCAT::Utils->Version();
	$callback->($rsp);
	return 0;
    }

    my $vlan_id=0;
    if (@ARGV>0) {
	$vlan_id=$ARGV[0];   
    }

    #let process _request to handle it
    my $reqcopy = {%$request};
    $reqcopy->{_xcatpreprocessed}->[0] = 1;
    $reqcopy->{vlanid}->[0]=$vlan_id;
    return [$reqcopy];
}


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

=head3  process_request

  Process the command

=cut

#-------------------------------------------------------
sub process_request
{
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;

    my $command = $request->{command}->[0];
    my $args    = $request->{arg};
    $::CALLBACK = $callback;

    if ($command eq "mkvlan") {
	return process_mkvlan($request,$callback,$sub_req);
    } elsif ($command eq "chvlanports"){
        return process_chvlanports($request,$callback,$sub_req);
    } elsif ($command eq "chvlan") {
	return process_chvlan($request,$callback,$sub_req);
    } elsif ($command eq "rmvlan") {
	return process_rmvlan($request,$callback,$sub_req);
    } elsif ($command eq "lsvlan") {
	return process_lsvlan($request,$callback,$sub_req);
    } else {
	my $rsp={};
	$rsp->{error}->[0]= "$command: unsupported command.";
	$callback->($rsp);
	return 1;
    }



    return 0;
}


sub process_mkvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    
    my $vlan_id=0;
    if (exists($request->{vlanid})) {
	$vlan_id=$request->{vlanid}->[0];
    }
    my @nodes=();
    if (exists($request->{node})) {
	@nodes=@{$request->{node}};
    }

    my $net;
    if (exists($request->{net})) {
	$net=$request->{net}->[0];
    }
    my $netmask;
    if (exists($request->{netmask})) {
	$netmask=$request->{netmask}->[0];
    }
    my $prefix;
    if (exists($request->{prefix})) {
	$prefix=$request->{prefix}->[0];
    } 

    my $nic;
    if (exists($request->{nic})) {
	$nic=$request->{nic}->[0];
    } 

    #check if the vlan is already defined on the table 
    my $nwtab=xCAT::Table->new("networks", -create =>1);
    if ($vlan_id > 0) {
	if ($nwtab) {
	    my @tmp1=$nwtab->getAllAttribs(('vlanid', 'net', 'mask'));
	    if ((@tmp1) && (@tmp1 > 0)) {
		foreach(@tmp1) {
		    if ($vlan_id eq $_->{vlanid}) {
			my $rsp={};
			$rsp->{error}->[0]= "The vlan $vlan_id is already used. Please choose another vlan id.";
			$callback->($rsp);
			return 1;
		    }
		}
	    }
	}
    }

    #make sure the vlan id is not currently used by another vlan
    #if no vlan id is supplied, automatically generate a new vlan id
    if ($vlan_id > 0) {
	if (!verify_vlanid($vlan_id, $callback)) { return 1; }
    } else {
	$vlan_id=get_next_vlanid($callback);
	if (!$vlan_id) { return 1;}
    }

    if (!$prefix) {
	$prefix="v". $vlan_id . "n"; #default
    }
    

    ####now get the switch ports for the nodes
    my %swinfo=();  # example: %swinfo=( switch1=>{ 23=>{ nodes: [node1]
                         #                                interface: eth0
                         #                               },
                         #                          24=>{ nodes: [node2,node3], 
                         #                                vmhost: kvm1
                         #                                interface: eth1
                         #                              }
                         #                         },
                         #               switch12=>{ 3=>{ nodes: [node4]},
                         #                           7=>{ nodes: [node4]
                         #                                interface: eth0 }, 
                         #                           9=>{ nodes: [node6]}
                         #                        }
                         #             )

    my %vminfo=();       # example: %vminfo=( kvm1=>{clients:[node1,node2...]},
                         #                    kvm2=>{clients:[node2,node3...]},
                         #                   )
                         #                  
    my @vmnodes=();      # vm clients
    my @snodes=();       # stand alone nodes

    
    #get the vm hosts  
    my $vmtab=xCAT::Table->new("vm", -create =>1);
    my $vmtmphash = $vmtab->getNodesAttribs(\@nodes, ['host', 'nics']) ;
    foreach my $node (@nodes) {
	my $host;
	my $ent=$vmtmphash->{$node}->[0];
	if (ref($ent) and defined $ent->{host}) { 
	    $host = $ent->{host}; 
	    if (exists($vminfo{$host})) {
		my $pa=$vminfo{$host}->{clients};
		push(@$pa, $node);
	    } else {
		$vminfo{$host}->{clients}=[$node];
	    }

	    push(@vmnodes, $node);
	}
    }

   
    if (@vmnodes > 0) {
	foreach my $node (@nodes) {
	    if (! grep /^$node$/, @vmnodes) {
		push(@snodes, $node);
	    }
	}
    } else {
	@snodes=@nodes;
    }
 
    #get the switch and port numbers for each node
    my @vmhosts=keys(%vminfo);
    my @anodes=(@snodes, @vmhosts); #nodes that connects to the switch
    my %swsetup=();
    my $swtab=xCAT::Table->new("switch", -create =>1);
    my $swtmphash = $swtab->getNodesAttribs(\@anodes, ['switch', 'port', 'vlan', 'interface']) ;
    my @missed_nodes=();
    foreach my $node (@anodes) {
	my $node_enties=$swtmphash->{$node}; 
	if ($node_enties) {
	    my $i=-1;
            my $use_this=0;
	    foreach my $ent (@$node_enties) {
		$i++;
		if (ref($ent) and defined $ent->{switch} and defined $ent->{port}) { 
		    my $switch;
		    my $port;
		    $switch = $ent->{switch};
		    $port = $ent->{port};
		    my $interface="primary";		    
		    if (defined $ent->{interface}) { $interface=$ent->{interface};}
                    # for primary nic, the interface can be empty, "primary" or "primary:eth0"
		    #print "***nic=$nic, interface=$interface\n";
		    if ($nic) {
			if ($interface =~ /primary/) {
			    $interface =~ s/primary(:)?//g;
			}
			if ($interface && ($interface eq $nic)) { $use_this=1; }
		    } else {
			if ($interface =~ /primary/) {  $use_this=1; }
		    } 

		    if (! $use_this) { 
			next; 
		    }
		    else { 
			$swsetup{$node}->{port}=$port;
			$swsetup{$node}->{switch}=$switch;
			if (defined $ent->{vlan}) { 
			    $swsetup{$node}->{vlan}=$ent->{vlan};
			} else {
			    $swsetup{$node}->{vlan}="";
			}
		    }

		    if ($interface) { 			
			$swinfo{$switch}->{$port}->{interface}=$interface;
		    }
		    
		    if (exists($vminfo{$node})) {
			$swinfo{$switch}->{$port}->{vmhost}=$node;
			$swinfo{$switch}->{$port}->{nodes}=$vminfo{$node}->{clients};
		    } else {
			$swinfo{$switch}->{$port}->{nodes}=[$node];
		    }
		    last;
		    
		} 
	    }
            if ( $use_this != 1 ) {
                push (@missed_nodes, $node);
            }
	}
    }

    if (@missed_nodes > 0) {
	my $rsp={};
	$rsp->{error}->[0]= "Cannot proceed, please define switch and port info on the switch table for the following nodes:\n  @missed_nodes\n";
	$callback->($rsp);
	return 1;
    }
    
    #print "vminfo=" . Dumper(%vminfo) . "\n";
    #print "swinfo=" . Dumper(%swinfo) . "\n";
    #print "snodes=" . Dumper(@snodes) . "\n";
    #print "anodes=" . Dumper(@anodes) . "\n";
    #print "vmnodes=" . Dumper(@vmnodes) . "\n";
    #print "swtmphash" . Dumper($swtmphash). "\n";

    ### verify the ports are not used by other vlans
    #if (!verify_switch_ports($vlan_id, \%swinfo, $callback)) { return 1;}
    
    ### now pick a network address for the vlan
    if (!$net) {
	($net, $netmask)=get_subnet($vlan_id, $callback);
    }


    ### save the vlan on the networks table
    my %key_col = (netname=>"vlan$vlan_id");
    my %tb_cols=(vlanid=>$vlan_id, net=>$net, mask=>$netmask);
    $nwtab->setAttribs(\%key_col, \%tb_cols);


    ### configure vlan on the switch
    if (!create_vlan($vlan_id, \%swinfo, $callback)) { return 1;}
    if (!add_ports($vlan_id, \%swinfo, $callback)) { return 1;}
    my @sws=keys(%swinfo);
    if (!add_crossover_ports($vlan_id, \@sws, $callback)) { return 1;}

    ### add the vlanid for the standalone nodes on the switch table
    ### append the vlan id for the vmhosts on the switch table
    add_vlan_to_switch_table(\%swsetup, $vlan_id);

    ### get node ip and vlan hostname from the hosts table. 
    #If it is not defined, put the default into the host table
    my @allnodes=(@anodes, @vmnodes);
    if (!add_vlan_ip_host($net, $netmask, $prefix, 1, \@allnodes, $callback)) { return 1;}

    ### for vm nodes, add an additional nic on the vm.nics
    if (@vmnodes > 0) {
	my %setupnics=();
	my $new_nic="vl$vlan_id";
	foreach my $node (@vmnodes) {
	    my $ent=$vmtmphash->{$node}->[0];
	    my $nics;
	    if (ref($ent) and defined $ent->{nics}) { 
		$nics=$ent->{nics};
		my @a=split(",", $nics);
		if (!grep(/^$new_nic$/, @a)) { $nics="$nics,$new_nic"; }
	    } else {
		$nics=$new_nic;
	    }
	    $setupnics{$node}={nics=>"$nics"};
	}
	$vmtab->setNodesAttribs(\%setupnics);
    }

    ### populate the /etc/hosts and make the DNS server on the mn aware this change
    $::CALLBACK = $callback;
    my $res = xCAT::Utils->runxcmd(  {
            command => ['makehosts'],
            }, $sub_req, 0, 1);
    my $rsp = {};
    $rsp->{data}->[0] = "Running makehosts...";
    $callback->($rsp);
    if ($res && (@$res > 0)) {
	$rsp = {};
	$rsp->{data} = $res;
	$callback->($rsp);
    }

    $::CALLBACK = $callback;
    my $res = xCAT::Utils->runxcmd(  {
            command => ['makedns'],
            }, $sub_req, 0, 1);
    my $rsp = {};
    $rsp->{data}->[0] = "Running makedns...";
    $callback->($rsp);
    if ($res && (@$res > 0)) {
	$rsp->{data} = $res;
	$callback->($rsp);
    }

    my $cmd = "service named restart";
    my $rc=system $cmd;

    ### now go to the nodes to configure the vlan interface
    $::CALLBACK = $callback;
    my $args = ["-P", "configvlan $vlan_id --keephostname"];
    my $res = xCAT::Utils->runxcmd(  {
            command => ['updatenode'],
	    node    => \@snodes,
	    arg     => $args
            }, $sub_req, 0, 1);
    my $rsp = {};
    $rsp->{data}->[0] = "Running updatenode...";
    $callback->($rsp);
    if ($res && (@$res > 0)) {
	$rsp->{data} = $res;
	$callback->($rsp);
    }

    ### add configvlan postscripts to the postscripts table for the node
    #   so that next time the node bootup, the vlan can get configured
    my @pnodes=(@snodes, @vmnodes);
    add_postscript($callback, \@pnodes);

    my $rsp={};
    $rsp->{data}->[0]= "The vlan is successfully configured. ";
    $rsp->{data}->[1]= "  vlan id: $vlan_id";
    $rsp->{data}->[2]= "  vlan subnet: $net";
    $rsp->{data}->[3]= "  vlan netmask: $netmask";
    #$rsp->{data}->[4]= "  vlan dhcp server:";
    #$rsp->{data}->[5]= "  vlan dns server:";
    #$rsp->{data}->[6]= "  vlan gateway:";
    $callback->($rsp);


    return 0;
}

#-------------------------------------------------------
=head3  add_vlan_to_switch_table

  It adds the vlan id to the switch.vlan for the given nodes.

=cut
#-------------------------------------------------------
sub add_vlan_to_switch_table {
    my $swsetup=shift;
    my $vlan_id=shift;

    my $swtab1 = xCAT::Table->new( 'switch', -create=>1, -autocommit=>0 );
    foreach my $node (keys(%$swsetup)) {
	my %keyhash=();
	my %updates=();
	$keyhash{'node'} = $node;
	$keyhash{'switch'}= $swsetup->{$node}->{switch};
	$keyhash{'port'} = $swsetup->{$node}->{port};
	$updates{'vlan'}=$vlan_id;
	my $vlan;
	if($swsetup->{$node}->{vlan}) { 
	    $vlan=$swsetup->{$node}->{vlan};
	    my @a=split(",", $vlan);
	    if (!grep(/^$vlan_id$/, @a)) { $vlan="$vlan,$vlan_id";}
	    $updates{'vlan'}=$vlan;
	}
	  
	$swtab1->setAttribs( \%keyhash,\%updates );
    }
    $swtab1->commit;
}

sub remove_vlan_from_switch_table {
    my $swsetup=shift;
    my $vlan_id=shift;
    #remove the vlan id from the switch table for standalone nodes 
    my $swtab1 = xCAT::Table->new('switch', -create=>1, -autocommit=>0 );
    foreach my $node (keys(%$swsetup)) {
	my %keyhash=();
	my %updates=();
	$keyhash{'node'} = $node;
	$keyhash{'switch'}= $swsetup->{$node}->{switch};
	$keyhash{'port'} = $swsetup->{$node}->{port};
	$updates{'vlan'} = "";
	if($swsetup->{$node}->{vlan}) {
	    my @a=split(',', $swsetup->{$node}->{vlan});
	    my @b=grep(!/^$vlan_id$/,@a);
	    if (@b>0) {
		$updates{'vlan'}=join(',', @b);
	    }
	}
	$swtab1->setAttribs( \%keyhash,\%updates );
    }
    $swtab1->commit;
}


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

  It adds the 'configvlan' postscript to the postscript table
  for the given nodes.

=cut
#-------------------------------------------------------
sub  add_postscript {
    my $callback=shift;
    my $anodes=shift;

    my $posttab=xCAT::Table->new("postscripts", -create =>1);
    if ($posttab) {
	(my $ref1) = $posttab->getAttribs({node => 'xcatdefaults'}, ('postscripts', 'postbootscripts'));
        #if configvlan is in xcadefaults, then do nothing
	if ($ref1) {
	    if ($ref1->{postscripts}) {
		my @a = split(/,/, $ref1->{postscripts});
		if (grep(/^configvlan$/, @a)) { next; }
	    }
	    if ($ref1->{postbootscripts}) {
		my @a = split(/,/, $ref1->{postbootscripts});
		if (grep(/^configvlan$/, @a)) { next; }
	    }
	}

	#now check for each node
	my %setup_hash;
	my $postcache = $posttab->getNodesAttribs($anodes,[qw(postscripts postbootscripts)]);
	foreach my $node (@$anodes) {
	    my $ref = $postcache->{$node}->[0]; 
	    if ($ref) {
		if (exists($ref->{postscripts})) {
		    my @a = split(/,/, $ref->{postscripts});
		    if (grep(/^configvlan$/, @a)) { next; }
		}

		if (exists($ref->{postbootscripts})) {
		    my $post=$ref->{postbootscripts};
		    my @old_a=split(',', $post);
		    if (grep(/^configvlan$/, @old_a)) {
			next;
		    } else {
			$setup_hash{$node}={postbootscripts=>"$post,configvlan"};
		    }
		} else {
		    $setup_hash{$node}={postbootscripts=>"configvlan"};
		}
	    } else {
		$setup_hash{$node}={postbootscripts=>"configvlan"};
	    }
	}
	if (keys(%setup_hash) > 0) {
	    $posttab->setNodesAttribs(\%setup_hash);
	}
    }   

    return 0;
}



#-------------------------------------------------------
=head3  add_vlan_ip_host

  It goes to the hosts.otherinterfaces to see if the vlan ip and hostname
  is defined. If not, it will add the default in the table. 
  The default is v<vlanid>n<node#>

=cut
#-------------------------------------------------------
sub  add_vlan_ip_host {
    my $subnet=shift;
    my $netmask=shift;
    my $prefix=shift;
    my $node_number=shift;
    my $nodes=shift;
    my $callback=shift;

    my $hoststab = xCAT::Table->new('hosts');
    my $hostscache = $hoststab->getNodesAttribs($nodes,[qw(node otherinterfaces)]);
    my %setup_hash;
    foreach my $node (@$nodes) {
	my $ref = $hostscache->{$node}->[0]; 
	my $found=0;
	my $otherinterfaces;
	if ($ref && exists($ref->{otherinterfaces})){
	    $otherinterfaces = $ref->{otherinterfaces};
	    my @itf_pairs=split(/,/, $otherinterfaces);
	    foreach (@itf_pairs) {
            	my ($name,$ip)=split(/:/, $_);
	    	if ($name =~ /^-/ ) {
	    	    $name = $node.$name;
	    	}
	    	if(xCAT::NetworkUtils->ishostinsubnet($ip, $netmask, $subnet)) {
	    	    $found=1;
	    	}
	    }	    
	}
	if (!$found) {
	    my $hostname=$prefix . "$node_number"; 
	    my $ip="";
	    if ($subnet =~ /\d+\.\d+\.\d+\.\d+/) {# ipv4 address
		$subnet =~ /([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/;
		my $netnum = ($1<<24)+($2<<16)+($3<<8)+$4;
		my $ipnum=$netnum + $node_number;
		my @a=();
		for (my $i=3; $i>-1; $i--) {
		    $a[$i]=$ipnum % 256;
		    $ipnum = int($ipnum / 256);
		}
		$ip= "$a[0].$a[1].$a[2].$a[3]";
		#print "ip=$ip\n";
	    } else {
		my $rsp={};
		$rsp->{error}->[0]= "Does not support IPV6 address yet.";
		$callback->($rsp);
		return 0; 
	    }
	    $node_number++;

	    if ($otherinterfaces) {
		$setup_hash{$node}={otherinterfaces=>"$hostname:$ip,$otherinterfaces"};
	    } else {
		$setup_hash{$node}={otherinterfaces=>"$hostname:$ip"};
	    }
	}
    } #foreach node

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

    return 1;
}


#-------------------------------------------------------
=head3 get_prefix_and_nodenumber

  It gets the prefix and max node number from the current nodes
  in the given vlan. 

=cut
#-------------------------------------------------------
sub get_prefix_and_nodenumber {
    my $vlan_id = shift;
    my $subnet = shift;
    my $netmask = shift;

    #get all the nodes that are in the vlan
    my $swtab=xCAT::Table->new("switch", -create =>0);
    my @nodes=();
    my @tmp1=$swtab->getAllAttribs(('node', 'vlan'));
    if ((@tmp1) && (@tmp1 > 0)) {
	foreach my $ent (@tmp1) {
	    my @nodes_tmp=noderange($ent->{node});
	    foreach my $node (@nodes_tmp) {
		if ($ent->{vlan}) {
		    my @a=split(",", $ent->{vlan});
		    if (grep(/^$vlan_id$/,@a)) {
			push(@nodes, $node);
		    }
		}
	    }
	}
    }


    #get all the vm clients if the node is a vm host
    my $vmtab=xCAT::Table->new("vm", -create =>0);
    my @vmnodes=();
    if ($vmtab) {
	my @tmp1=$vmtab->getAllAttribs('node', 'host');
	if ((@tmp1) && (@tmp1 > 0)) {
	    foreach(@tmp1) {
		my $host = $_->{host};
		if (grep(/^$host$/, @nodes)) {
		    my @nodes_tmp=noderange($_->{node});
		    foreach my $node (@nodes_tmp) {
			push(@vmnodes, $node);
		    }
		}
	    }
	}
    }
    
    @nodes=(@nodes, @vmnodes);
    #print "nodes=@nodes\n";	

    #now go to hosts table to get the prefix and max node number
    my $hoststab = xCAT::Table->new('hosts');
    my $hostscache = $hoststab->getNodesAttribs(\@nodes,[qw(node otherinterfaces)]);
    my $max=0;
    my $prefix;
    foreach my $node (@nodes) {
	my $ref = $hostscache->{$node}->[0]; 
	my $otherinterfaces;
	if ($ref && exists($ref->{otherinterfaces})){
	    $otherinterfaces = $ref->{otherinterfaces};
	    my @itf_pairs=split(/,/, $otherinterfaces);
	    my @itf_pairs2=();
	    foreach (@itf_pairs) {
            	my ($name,$ip)=split(/:/, $_);
	    	if(xCAT::NetworkUtils->ishostinsubnet($ip, $netmask, $subnet)) {
		   $name =~ /^(.*)([\d]+)$/;
                   if ($2 > $max) { $max=$2;}
		   if (!$prefix) { $prefix=$1;}
		   #print "name=$name\n, 1=$1, 2=$2\n";
	    	}
	    }
	}
    } #foreach node

    return ($prefix, $max);
}



#-------------------------------------------------------
=head3  remove_vlan_ip_host

  It goes to the hosts.otherinterfaces to see if the vlan ip and hostname
  is defined. If it is, it will remove it. It also remove the entried in 
  the /etc/hosts file

=cut
#-------------------------------------------------------
sub  remove_vlan_ip_host {
    my $subnet=shift;
    my $netmask=shift;
    my $nodes=shift;
    my $callback=shift;

    my $hoststab = xCAT::Table->new('hosts');
    my $hostscache = $hoststab->getNodesAttribs($nodes,[qw(node otherinterfaces)]);
    my %setup_hash;
    foreach my $node (@$nodes) {
	my $ref = $hostscache->{$node}->[0]; 
	my $otherinterfaces;
	if ($ref && exists($ref->{otherinterfaces})){
	    $otherinterfaces = $ref->{otherinterfaces};
	    my @itf_pairs=split(/,/, $otherinterfaces);
	    my @itf_pairs2=();
	    my $index=0;
	    foreach (@itf_pairs) {
            	my ($name,$ip)=split(/:/, $_);
	    	if(!xCAT::NetworkUtils->ishostinsubnet($ip, $netmask, $subnet)) {
	    	    $itf_pairs2[$index]=$_;
		    $index++;
	    	} else {
		    my $cmd="sed -i /$ip/d /etc/hosts";
		    my $rc=system $cmd;
		}
	    }
	    if (@itf_pairs2 > 0) {
		my $new_intf=join(",", @itf_pairs2);
		$setup_hash{$node}={otherinterfaces=>$new_intf}
	    } else {
		$setup_hash{$node}={otherinterfaces=>""};
	    }
	}
    } #foreach node

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

    return 1;
}

#-------------------------------------------------------
=head3  verify_vlanid

  It goes to all the switches to make sure that the vlan 
  id is not used by other vlans.
=cut
#-------------------------------------------------------
sub verify_vlanid {
    my $vlan_id=shift;
    my $callback=shift;

    my $switchestab=xCAT::Table->new('switches',-create=>0);
    my @tmp1=$switchestab->getAllAttribs(('switch'));
    if ((@tmp1) && (@tmp1 > 0)) {
	foreach(@tmp1) {
	    my @switches_tmp=noderange($_->{switch});
	    if (@switches_tmp==0) { push @switches_tmp, $_->{switch}; } #sometimes the switch name is not on the node list table.  
	    foreach my $switch (@switches_tmp) {
		my $swh;
		if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
		else {
		    $swh=new xCAT::SwitchHandler->new($switch);
		    $Switches{$switch}=$swh;
		}
		my @ids=$swh->get_vlan_ids();
		print "ids=@ids\n";
		foreach my $id (@ids) {
		    if ($id == $vlan_id) {
			my $rsp={};
			$rsp->{error}->[0]= "The vlan id $vlan_id already exists on switch $switch. Please choose another vlan id.\n";
			$callback->($rsp);
			return 0; 
		    }
		}
	    }
	}
    }
    return 1;
}

#-------------------------------------------------------
=head3  get_next_vlanid

  It automatically generates the vlan ID. It goes to all the
  switches, get the smallest common integer that is not used
  by any existing vlans. 
=cut
#-------------------------------------------------------
sub get_next_vlanid {
    my $callback=shift;
    my $switchestab=xCAT::Table->new('switches',-create=>0);
    my @tmp1=$switchestab->getAllAttribs(('switch'));
    my %vlanids=();
    if ((@tmp1) && (@tmp1 > 0)) {
	foreach(@tmp1) {
	    my @switches_tmp=noderange($_->{switch});
	    if (@switches_tmp==0) { push @switches_tmp, $_->{switch}; } #sometimes the switch name is not on the node list table.  
	    foreach my $switch (@switches_tmp) {
		my $swh;
		if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
		else {
		    $swh=new xCAT::SwitchHandler->new($switch);
		    $Switches{$switch}=$swh;
		}
		my @ids=$swh->get_vlan_ids();
		foreach my $id (@ids) {
		    $vlanids{$id}=1;
		}
	    }
	}
    }
    
    for (my $index=2; $index<255; $index++) {
	if (! exists($vlanids{$index})) { return $index; }
    }

    my $rsp={};
    $rsp->{data}->[0]= "No valid vlan ID can be used any more, Please remove unused vlans.\n";
    $callback->($rsp);
    
    return 0;
}

#-------------------------------------------------------
=head3  verify_switch_ports

  It checks if the switch ports to be configured are used by other vlans.

=cut
#-------------------------------------------------------
sub verify_switch_ports {
    my $vlan_id=shift;
    my $swinfo=shift;
    my $callback=shift;

    my $ret=1;
    foreach my $switch (keys %$swinfo) {
	my $porthash=$swinfo->{$switch};
	my $swh;
	if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
	else {
	    $swh=new xCAT::SwitchHandler->new($switch);
	    $Switches{$switch}=$swh;
	}
 	my $port_vlan_hash=$swh->get_vlanids_for_ports(keys(%$porthash));
	print "port_vlan_hash=" . Dumper($port_vlan_hash) . "\n";
	my @error_ports=();
	foreach my $port (keys(%$port_vlan_hash)) {
	    my $val=$port_vlan_hash->{$port};
	    foreach my $tmp_vid (@$val) {
		if (($tmp_vid != $vlan_id) && ($tmp_vid != 1) && ($tmp_vid ne 'NA')) {
        if (exists($porthash->{$port}->{vmhost})) { next; } #skip the vmhost, vmhost can have more than one vlans
		    push(@error_ports, $port);
		    last;
		}
	    }
	}
	if (@error_ports >0) {
	    $ret=0;
	    my $error_str;
	    foreach(@error_ports) {
		my @tmp=@{$porthash->{$_}->{nodes}};
		my $ids_tmp=$port_vlan_hash->{$_};
		$error_str .= "$_: vlan-ids=@$ids_tmp  nodes=@tmp\n";
	    }
	    my $rsp={};
	    $rsp->{error}->[0]= "The following ports on switch $switch are used by other vlans.\n$error_str";
	    $callback->($rsp);
	}
    }

    return $ret;
}

#-------------------------------------------------------
=head3  create_vlan

  It goes to the switches and create a new vlan. 
  Returns:  1 -- suggessful
            0 -- fail 
=cut
#-------------------------------------------------------
sub create_vlan {
    my $vlan_id=shift;
    my $swinfo=shift;
    my $callback=shift;
    my $ret=1;
    foreach my $switch (keys %$swinfo) {
	my $swh;
	if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
	else {
	    $swh=new xCAT::SwitchHandler->new($switch);
	    $Switches{$switch}=$swh;
	}
	#check if the vlan already exists on the switch
	my @ids=$swh->get_vlan_ids(); 
        my $vlan_exists=0;
	foreach my $id (@ids) {
	    if ($id == $vlan_id) { 
		$vlan_exists=1;
		last;
	    }
	}

	if (!$vlan_exists) {
	    #create the vlan
            print "create vlan $vlan_id on switch $switch\n";
	    my @ret=$swh->create_vlan($vlan_id);
	    if ($ret[0] != 0) {
		my $rsp={};
		$rsp->{error}->[0]= "create_vlan: $ret[1]";
		$callback->($rsp);
	    }
	}
    }


    return 1;
}


#-------------------------------------------------------
=head3  add_ports

  It adds the ports to the vlan.
  Returns:  1 -- suggessful
            0 -- fail 
=cut
#-------------------------------------------------------
sub add_ports {
    my $vlan_id=shift;
    my $swinfo=shift;
    my $callback=shift;
    my $portmode=shift;
    my $ret=1;
    foreach my $switch (keys %$swinfo) {
	my $porthash=$swinfo->{$switch};
	my $swh;
	if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
	else {
	    $swh=new xCAT::SwitchHandler->new($switch);
	    $Switches{$switch}=$swh;
	}

 	my @ret=$swh->add_ports_to_vlan($vlan_id, $portmode, keys(%$porthash));
	if ($ret[0] != 0) {
	    my $rsp={};
	    $rsp->{error}->[0]= "add_ports_to_vlan: $ret[1]";
	    $callback->($rsp);
	}
    }

    return 1;
}

#-------------------------------------------------------
=head3  add_crossover_ports

  It enables the vlan on the cross-over links.
  Returns:  1 -- suggessful
            0 -- fail 
=cut
#-------------------------------------------------------
sub add_crossover_ports {
    my $vlan_id=shift;
    my $psws=shift;
    my $callback=shift;    

    #now make sure the links between the switches allows this vlan to go through
    my @sws=@$psws;
    print "sws=@sws\n";
    if (@sws > 1) {
	foreach my $switch (@sws) {
	    my $swh;
	    if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
	    else {
		$swh=new xCAT::SwitchHandler->new($switch);
		$Switches{$switch}=$swh;
	    }

	    my @sws_b=grep(!/^$switch$/, @sws);
	    my @ret=$swh->add_crossover_ports_to_vlan($vlan_id, @sws_b);
	    if ($ret[0] != 0) {
		my $rsp={};
		$rsp->{error}->[0]= "add_crossover_ports: $ret[1]";
		$callback->($rsp);
	    } else {
		if ($ret[1]) {
		    my $rsp={};
		    $rsp->{data}->[0]= "add_crossover_ports: $ret[1]";
		    $callback->($rsp);
		}
	    }
	}
    }

    return 1;
}

#-------------------------------------------------------
=head3  remove_ports

  It goes to the switches and create a new vlan.
  Returns:  1 -- suggessful
            0 -- fail 
=cut
#-------------------------------------------------------
sub remove_ports {
    my $vlan_id=shift;
    my $swinfo=shift;
    my $callback=shift;
    my $novmhost=shift;
    my $ret=1;
    foreach my $switch (keys %$swinfo) {
	my $porthash=$swinfo->{$switch};
	my $swh;
	if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
	else {
	    $swh=new xCAT::SwitchHandler->new($switch);
	    $Switches{$switch}=$swh;
	}

	my @ports=();
	if ($novmhost) {  #skip the vm hosts for chvlan
	    foreach my $port (keys(%$porthash)) {
		if (!exists($porthash->{$port}->{vmhost})) {
		    push(@ports, $port);
		}
	    } 
	}else {
	    @ports=keys(%$porthash);
	}
 	my @ret=$swh->remove_ports_from_vlan($vlan_id, @ports);
	if ($ret[0] != 0) {
	    my $rsp={};
	    $rsp->{error}->[0]= "remove_ports_from_vlan: $ret[1]";
	    $callback->($rsp);
	}
    }

    return 1;
}


#-------------------------------------------------------
=head3   get_subnet

  It gets the subnet address and netmask for the given 
  vlan ID. The pattern is defined by "vlannets" and "vlanmask"
  on the site table.  The default is "10.<$vlanid>.0.0"/"255.255.0.0". 
=cut
#-------------------------------------------------------
sub get_subnet {
    my $vlan_id=shift;
    my $callback = shift;
    my $net;
    my $mask;

    #get vlannets and vlanidmask from the site table 
    my $vlannets="|(\\d+)|10.(\$1+0).0.0|";
    my $vlanmask="255.255.0.0";
    my $sitetab = xCAT::Table->new('site');
    my $sent = $sitetab->getAttribs({key=>'vlannets'},'value');
    if ($sent and ($sent->{value})) {
	$vlannets=$sent->{value};
    } 
    $sent = $sitetab->getAttribs({key=>'vlanmask'},'value');
    if ($sent and ($sent->{value})) {
	$vlanmask=$sent->{value};
    } 
    $mask = $vlanmask;

    if ($vlannets =~ /^\/[^\/]*\/[^\/]*\/$/)
    {
	my $exp = substr($vlannets, 1);
	chop $exp;
	my @parts = split('/', $exp, 2);
	$net=$vlan_id;
	$net =~ s/$parts[0]/$parts[1]/;
    }
    elsif ($vlannets =~ /^\|.*\|.*\|$/)
    {
	
	my $exp = substr($vlannets, 1);
	chop $exp;
	my @parts = split('\|', $exp, 2);
	my $curr;
	my $next;
	my $prev;
	my $retval = $parts[1];
	($curr, $next, $prev) =
	    extract_bracketed($retval, '()', qr/[^()]*/);
	
	unless($curr) { #If there were no paramaters to save, treat this one like a plain regex
	    undef $@; #extract_bracketed would have set $@ if it didn't return, undef $@
	    $retval = $vlan_id;
	    $retval =~ s/$parts[0]/$parts[1]/;
	}
	while ($curr)
	{
	    my $value = $vlan_id;
	    $value =~ s/$parts[0]/$curr/;
	    $value = $evalcpt->reval('use integer;'.$value);
	    $retval = $prev . $value . $next;
	    ($curr, $next, $prev) =
		extract_bracketed($retval, '()', qr/[^()]*/);
	}
	undef $@;
	$net = $vlan_id;
	$net =~ s/$parts[0]/$retval/;
    }
    return ($net, $mask);
}


# process_chvlanports only support physical nodes
# bond not supported and multi nics are not supported
sub process_chvlanports {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
	
	my $vlan_id=0;
    my $nic = "";
    my @nodes=();
    my $delete=0;
    
    # validate vlan id value.
    $vlan_id=$request->{vlanid}->[0];
    #debug message.
    xCAT::MsgUtils->message('S',"vlanid: $vlan_id");
    if ($vlan_id <= 0) {
        my $rsp={};
        $rsp->{error}->[0]= "Invalid vlan id: $vlan_id";
        $callback->($rsp);
        return;
    }
    #Check if the vlan is defined in networks table.
    my $net="";
    my $netmask="";
    my $nwtab=xCAT::Table->new("networks", -create =>1);
    if ($nwtab) {
        my @nwentires=$nwtab->getAllAttribs(('vlanid', 'net', 'mask'));
        foreach(@nwentires) {
            if ($vlan_id eq $_->{vlanid}) {
                $net=$_->{net};
                $netmask=$_->{mask};
            }
        }
    }
    if ((!$net) || (!$netmask)) {
        my $rsp = {};
        $rsp->{data}->[0] = "Can not find valid network/netmask definition from table networks for vlan $vlan_id.";
        $callback->($rsp);
        return 1;
    }
	
    $nic=$request->{nic}->[0];
    #debug message.
    xCAT::MsgUtils->message('S',"nic is: $nic");

    @nodes=@{$request->{node}};
    #debug message.
    my $nodesstr = Dumper(@nodes);
    xCAT::MsgUtils->message('S',"nodes are: $nodesstr");

    $delete=$request->{delete}->[0];
    #debug message.
    xCAT::MsgUtils->message('S',"delete flag: $delete");
	

	####now get the switch ports for the nodes
    my %swinfo=();  # example: %swinfo=( switch1=>{ 23=>{ nodes: [node1]},
                         #                          24=>{ nodes: [node2]},
                         #                         },
                         #               switch12=>{ 3=>{ nodes: [node4],
                         #                         }
                         #             )
    my %nodeswinfo=(); # example: %nodeswinfo=(
                         #               node1=>{eth0=>{switch => swith1,
                         #                              port => 1,
                         #                              vlanids => [2,3]},
                         #                       eth1=>{switch => switch1,
                         #                              port => 2,
                         #                              vlanids => [5]}}
                         #                   )
    my %swsetup=();

    #get the switch and port numbers for each node
    my $swtab=xCAT::Table->new("switch", -create =>1);
    my $swtmphash = $swtab->getNodesAttribs(\@nodes, ['switch', 'port', 'vlan', 'interface']);
    foreach my $node (keys (%$swtmphash)) {
        my $node_enties=$swtmphash->{$node}; 
        foreach my $ent (@$node_enties) {
            if (ref($ent) and defined $ent->{switch} and defined $ent->{port}){ 
                my $switch = $ent->{switch};
                my $port = $ent->{port};
                my $interface = "";
                if( defined $ent->{interface} ){ $interface = $ent->{interface}};
                my $vlan = "";
                if( defined $ent->{vlan}) {$vlan = $ent->{vlan}};
                
                if ($interface){
                    $nodeswinfo{$node}->{$interface}->{switch}=$switch;
                    $nodeswinfo{$node}->{$interface}->{port}=$port;
                    $nodeswinfo{$node}->{$interface}->{vlan} = $vlan;
                }
            }
        }
    }
    #debug message.
    my $nodesinfostr = Dumper(%nodeswinfo);
    xCAT::MsgUtils->message('S',"nodeswinfo: $nodesinfostr");

    # Validate node's switch info %nodeswinfo and build up %swinfo, %swsetup.
    my @missed_switch_nodes = ();
    my @missed_vlanid_nodes = ();
    foreach my $node (@nodes){
        # Check whether the switch, port and interface info defined for all nodes.
        if(defined $nodeswinfo{$node} && defined $nodeswinfo{$node}->{$nic}){
        } else{
            push(@missed_switch_nodes, $node);
            next;
        }
    
        if ($delete){
            # For delete mode, must make sure all node's has such a vlan ID defined for the interface.
            my @vlanids = split(",",$nodeswinfo{$node}->{$nic}->{vlan});
            if (@vlanids && (grep /^$vlan_id$/, @vlanids)){
                my $switch = $nodeswinfo{$node}->{$nic}->{switch};
                my $port = $nodeswinfo{$node}->{$nic}->{port};

                #setup swinfo and swsetup .
                $swinfo{$switch}->{$port}->{hosts} = [$node];
                $swsetup{$node}->{switch} = $switch;
                $swsetup{$node}->{port} = $port;
                $swsetup{$node}->{vlan} = $nodeswinfo{$node}->{$nic}->{vlan};
            }else{
                push(@missed_vlanid_nodes, $node);
                next;
            }
        } else{
            # non-delete mode, just setup swinfo directly.
            my $switch = $nodeswinfo{$node}->{$nic}->{switch};
            my $port = $nodeswinfo{$node}->{$nic}->{port};

            #setup swinfo and swsetup for add_ports, add_crossover_ports and add_vlan_to_switch_table call later.
            $swinfo{$switch}->{$port}->{hosts} = [$node];
            $swsetup{$node}->{switch} = $switch;
            $swsetup{$node}->{port} = $port;
            $swsetup{$node}->{vlan} = $nodeswinfo{$node}->{$nic}->{vlan};
        }
    }
    if (@missed_switch_nodes > 0) {
        my $rsp={};
        $rsp->{error}->[0]= "Cannot proceed, please define switch, port and interface info on the switch table for the following nodes:\n  @missed_switch_nodes\n";
        $callback->($rsp);
        return 1;
    }
    if (@missed_vlanid_nodes > 0) {
        my $rsp={};
        $rsp->{error}->[0]= "Cannot proceed, no such vlan ID $vlan_id defined for following nodes:\n @missed_vlanid_nodes\n";
        $callback->($rsp);
        return 1;
    }
    #debug message.
    my $swinfostr = Dumper(%swinfo);
    xCAT::MsgUtils->message('S',"swinfo: $swinfostr");
    my $swsetupstr = Dumper(%swsetup);
    xCAT::MsgUtils->message('S',"swsetup: $swsetupstr");
    
    # Do actual configurations on switches
    if (!$delete) {
        ### add ports to the vlan
        if (!add_ports($vlan_id, \%swinfo, $callback, 1)) { return 1;}
        xCAT::MsgUtils->message('S',"Adding ports to switch success!");

        ### add the cross-over ports to the vlan
        my @sws=keys(%swinfo);;
        #get all the switches  that are in the vlan
        my $swtab=xCAT::Table->new("switch", -create =>0);
        if ($swtab) {
            my @tmp1=$swtab->getAllAttribs('switch', 'vlan');
            if ((@tmp1) && (@tmp1 > 0)) {
                foreach my $item (@tmp1) {
                    my $vlan=$item->{vlan};
                    my $sw=$item->{switch};
                    if ($vlan) {
                        my @a=split(",",$vlan);
                        if (grep(/^$vlan_id$/, @a)) {
                            if (!grep(/^$sw$/, @sws)) {
                                push(@sws, $sw);
                            }
                        }
                    }
                }
            }
        }
        if (!add_crossover_ports($vlan_id, \@sws, $callback)) { return 1;}
        xCAT::MsgUtils->message('S',"Configuring cross over ports success!");
	
        #add the vlanid for the standalone nodes on the switch table
        #append the vlan id for the vmhosts on the switch table
        add_vlan_to_switch_table(\%swsetup, $vlan_id); 
        xCAT::MsgUtils->message('S',"Adding vlan to switch table success!");
        
        # done
        my $rsp={};
        $rsp->{data}->[0]= "The interface $nic of following nodes are added to the vlan $vlan_id:\n@nodes";
        $callback->($rsp);
        
    } else{
        ### remove ports from the vlan
        my $novmhost=1;
        if (!remove_ports($vlan_id, \%swinfo, $callback, $novmhost)) { return 1;}
        xCAT::MsgUtils->message('S',"Removing ports from vlan success!");
 
        #remove the vlan id from the switch table.
        remove_vlan_from_switch_table(\%swsetup,$vlan_id);
        xCAT::MsgUtils->message('S',"Removing ports from switch table success!");
        
        # done
        my $rsp={};
        $rsp->{data}->[0]= "The interface $nic of following nodes are removed from the vlan $vlan_id:\n@nodes";
        $callback->($rsp);
    }
    return 0;
}

sub process_chvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;

    my $vlan_id=0;
    if (exists($request->{vlanid})) {
        $vlan_id=$request->{vlanid}->[0];
    }
    if ($vlan_id == 0) {
        my $rsp={};
        $rsp->{error}->[0]= "Invalid vlan id: $vlan_id";
        $callback->($rsp);
        return;
    }
    
    my $nic;
    if (exists($request->{nic})) {
        $nic=$request->{nic}->[0];
    } 

    my @nodes=();
    if (exists($request->{node})) {
        @nodes=@{$request->{node}};
    }

    my $delete=0;
    if (exists($request->{delete})) {
        $delete=$request->{delete}->[0];
    }
    my $net;
    my $netmask;
    #check if the vlan is already defined on the table 
    my $found=0;
    my $nwtab=xCAT::Table->new("networks", -create =>1);
    if ($vlan_id > 0) {
        if ($nwtab) {
            my @tmp1=$nwtab->getAllAttribs(('vlanid', 'net', 'mask'));
            if ((@tmp1) && (@tmp1 > 0)) {
                foreach(@tmp1) {
                    if ($vlan_id eq $_->{vlanid}) {
                        $found=1;
                        $net=$_->{net};
                        $netmask=$_->{mask};
                    }
                }
	        }
        }
    }
    if (!$found) {
        my $rsp = {};
        $rsp->{data}->[0] = "The vlan $vlan_id does not exist.";
        $callback->($rsp);
        return 1;
    }

    if ((!$net) || (!$netmask)) {
        my $rsp = {};
        $rsp->{data}->[0] = "Please make sure subnet and netmask are specified on the networks table for vlan $vlan_id.";
        $callback->($rsp);
        return 1;
    }

    ####now get the switch ports for the nodes
    my %swinfo=();  # example: %swinfo=( switch1=>{ 23=>{ nodes: [node1]},
                         #                          24=>{ nodes: [node2,node3], 
                         #                                        vmhost: kvm1
                         #                              }
                         #                         },
                         #               switch12=>{ 3=>{ nodes: [node4]},
                         #                           7=>{ nodes: [node5]}, 
                         #                           9=>{ nodes: [node6]}
                         #                        }
                         #             )

    my %vminfo=();       # example: %vminfo=( kvm1=>{clients:[node1,node2...]},
                         #                    kvm2=>{clients:[node2,node3...]},
                         #                   )
                         #                  
    my @vmnodes=();      # vm clients
    my @snodes=();       # stand alone nodes

    
    #get the vm hosts  
    my $vmtab=xCAT::Table->new("vm", -create =>1);
    my $vmtmphash = $vmtab->getNodesAttribs(\@nodes, ['host','nics']) ;
    foreach(@nodes) {
        my $node=$_;
        my $host;
        my $ent=$vmtmphash->{$node}->[0];
        if (ref($ent) and defined $ent->{host}) { 
            $host = $ent->{host}; 
            if (exists($vminfo{$host})) {
                my $pa=$vminfo{$host}->{clients};
                push(@$pa, $node);
            } else {
                $vminfo{$host}->{clients}=[$node];
            }
	        push(@vmnodes, $node);
	    }
    }
   
    if (@vmnodes > 0) {
        foreach my $node (@nodes) {
            if (! grep /^$node$/, @vmnodes) {
                push(@snodes, $node);
            }
        }
    } else {
        @snodes=@nodes;
    }
 
    #get the switch and port numbers for each node
    my @vmhosts=keys(%vminfo);
    my @anodes=(@snodes, @vmhosts); #nodes that connects to the switch
    my %swsetup=();
    my $swtab=xCAT::Table->new("switch", -create =>1);
    my $swtmphash = $swtab->getNodesAttribs(\@anodes, ['switch', 'port', 'vlan', 'interface']) ;
    my @missed_nodes=();
    foreach my $node (@anodes) {
        my $switch;
        my $port;
        my $node_enties=$swtmphash->{$node}; 
        if ($node_enties) {
            my $i=-1;
            my $use_this=0;
            foreach my $ent (@$node_enties) {
                $i++;
                if (ref($ent) and defined $ent->{switch} and defined $ent->{port}) { 
                    $switch = $ent->{switch};
                    $port = $ent->{port};
                    my $interface="primary";		    
                    if (defined $ent->{interface}) { $interface=$ent->{interface};}
                    # for primary nic, the interface can be empty, "primary" or "primary:eth0"		   
                    if ($delete) {
                        if (defined($ent->{vlan})) {
                            my @a=split(',', $ent->{vlan});
                            if (grep(/^$vlan_id$/, @a)) {  $use_this=1; }
                        }			
                    } else {
                        if ($nic) {
                            if ($interface =~ /primary/) {
                                $interface =~ s/primary(:)?//g;
                            }
                            if ($interface && ($interface eq $nic)) { $use_this=1; }
                        } else {
                            if ($interface =~ /primary/) {  $use_this=1; }
                        } 
                    }
		    
                    if (! $use_this) { 
                        next; 
                    } else { 
                        $swsetup{$node}->{port}=$port;
                        $swsetup{$node}->{switch}=$switch;
                        if (defined $ent->{vlan}) { 
                            $swsetup{$node}->{vlan}=$ent->{vlan};
                        } else {
                            $swsetup{$node}->{vlan}="";
                        }
                    }

                    if ($interface) { 			
                        $swinfo{$switch}->{$port}->{interface}=$interface;
                    }
		    
                    if (exists($vminfo{$node})) {
                        $swinfo{$switch}->{$port}->{vmhost}=$node;
                        $swinfo{$switch}->{$port}->{nodes}=$vminfo{$node}->{clients};
                    } else {
                        $swinfo{$switch}->{$port}->{nodes}=[$node];
                    }
                    last;
                } 
            }
            if ( $use_this != 1 ) {
                push (@missed_nodes, $node);
            }
        }
    }

    if (@missed_nodes > 0) {
        my $rsp={};
        $rsp->{error}->[0]= "Cannot proceed, please define switch and port info on the switch table for the following nodes:\n  @missed_nodes\n";
        $callback->($rsp);
        return 1;
    }
    
    #print "vminfo=" . Dumper(%vminfo) . "\n";
    #print "swinfo=" . Dumper(%swinfo) . "\n";
    #print "anodes=" . Dumper(@anodes) . "\n";
    #print "vmnodes=" . Dumper(@vmnodes) . "\n";

    if (!$delete) {
        ### verify the ports are not used by other vlans
        #if (!verify_switch_ports($vlan_id, \%swinfo, $callback)) { return 1;}
	
        ###create the vlan if it does not exist 
         if (!create_vlan($vlan_id, \%swinfo, $callback)) { return 1;}

        ### add ports to the vlan
        if (!add_ports($vlan_id, \%swinfo, $callback)) { return 1;}

        ### add the cross-over ports to the vlan
        my @sws=keys(%swinfo);;
        #get all the switches  that are in the vlan
        my $swtab=xCAT::Table->new("switch", -create =>0);
        if ($swtab) {
            my @tmp1=$swtab->getAllAttribs('switch', 'vlan');
            if ((@tmp1) && (@tmp1 > 0)) {
                foreach my $item (@tmp1) {
                    my $vlan=$item->{vlan};
                    my $sw=$item->{switch};
                    if ($vlan) {
                        my @a=split(",",$vlan);
                        if (grep(/^$vlan_id$/, @a)) {
                            if (!grep(/^$sw$/, @sws)) {
                                push(@sws, $sw);
                            }
                        }
                    }
                }
            }
        }
        if (!add_crossover_ports($vlan_id, \@sws, $callback)) { return 1;}
	
        #add the vlanid for the standalone nodes on the switch table
        #append the vlan id for the vmhosts on the switch table
        add_vlan_to_switch_table(\%swsetup, $vlan_id);   
	
        #we'll derive the prefix and the node numbers from the existing
        #nodes on the vlan
        my ($prefix, $start_number)=get_prefix_and_nodenumber($vlan_id, $net, $netmask);
 
        ### get node ip and vlan hostname from the hosts table. 
        #If it is not defined, put the default into the host table
        my @allnodes=(@anodes, @vmnodes);
        if (!add_vlan_ip_host($net, $netmask, $prefix, $start_number+1, \@allnodes, $callback)) { return 1;}

        ### for vm nodes, add an additional nic on the vm.nics
        if (@vmnodes > 0) {
            my %setupnics=();
            my $new_nic="vl$vlan_id";
            foreach my $node (@vmnodes) {
                my $ent=$vmtmphash->{$node}->[0];
                my $nics;
                if (ref($ent) and defined $ent->{nics}) { 
                    $nics=$ent->{nics};
                    my @a=split(",", $nics);
                    if (!grep(/^$new_nic$/, @a)) { $nics="$nics,$new_nic"; }
                } else {
                    $nics=$new_nic;
                }
                $setupnics{$node}={nics=>"$nics"};
            }
            $vmtab->setNodesAttribs(\%setupnics);
        }

        ### populate the /etc/hosts and make the DNS server on the mn aware this change
        $::CALLBACK = $callback;
        my $res = xCAT::Utils->runxcmd({
                                        command => ['makehosts'],
                                       }, $sub_req, 0, 1);
        my $rsp = {};
        $rsp->{data}->[0] = "Running makehosts...";
        $callback->($rsp);
        if ($res && (@$res > 0)) {
            $rsp = {};
            $rsp->{data} = $res;
            $callback->($rsp);
        }
        $callback->($rsp);
	
        $::CALLBACK = $callback;
        my $res = xCAT::Utils->runxcmd({
                                        command => ['makedns'],
                                       }, $sub_req, 0, 1);
	
        my $rsp = {};
        $rsp->{data}->[0] = "Running makedns...";
        if ($res && (@$res > 0)) {
            $callback->($rsp);
            $rsp->{data} = $res;
            $callback->($rsp);
        }
	
        my $cmd = "service named restart";
        my $rc=system $cmd;
	
        ### now go to the nodes to configure the vlan interface
        $::CALLBACK = $callback;
        my $args = ["-P", "configvlan $vlan_id --keephostname"]; 
        my $res = xCAT::Utils->runxcmd( {
                                          command => ['updatenode'],
                                          node    => \@snodes,
                                          arg     => $args
                                        }, $sub_req, 0, 1);
        my $rsp = {};
        $rsp->{data}->[0] = "Running updatenode...";
        if ($res && (@$res > 0)) {
            $callback->($rsp);
            $rsp->{data} = $res;
            $callback->($rsp);
        }
	
        ### add configvlan postscripts to the postscripts table for the node
        my @pnodes=(@snodes, @vmnodes);
        add_postscript($callback, \@pnodes);
	
        # done
        my $rsp={};
        $rsp->{data}->[0]= "The following nodes are added to the vlan $vlan_id:\n@nodes";
        $callback->($rsp);
    } else {
        ### go to the nodes to de-configure the vlan interface
        if (@snodes > 0) {
            my $args = ["-P", "deconfigvlan $vlan_id"];
            my $res = xCAT::Utils->runxcmd(  {
                                              command => ['updatenode'],
                                              node    => \@snodes,
                                              arg     => $args
                                             }, $sub_req, 0, 1);
            my $rsp = {};
            $rsp->{data}->[0] = "Running updatenode...";
            if ($res && (@$res > 0)) {
                $callback->($rsp);
                $rsp->{data} = $res;
                $callback->($rsp);
            }
        }

        ### remove ports from the vlan
        my $novmhost=1;
        if (!remove_ports($vlan_id, \%swinfo, $callback, $novmhost)) { return 1;}
 
        #remove the vlan id from the switch table for standalone nodes
        #cannot call this function because %swsetup contains vmhosts
        #remove_vlan_from_switch_table(\%swsetup,$vlan_id); 
        #print "swsetup=". Dumper(%swsetup);
        my $swtab1 = xCAT::Table->new('switch', -create=>1, -autocommit=>0 );
        foreach my $node (@snodes) {
            if (exists($swsetup{$node})) {
                my %keyhash=();
                my %updates=();
                $keyhash{'node'} = $node;
                $keyhash{'switch'}= $swsetup{$node}->{switch};
                $keyhash{'port'} = $swsetup{$node}->{port};
                $updates{'vlan'} = "";
                if($swsetup{$node}->{vlan}) {
                    my @a=split(',', $swsetup{$node}->{vlan});
                    my @b=grep(!/^$vlan_id$/,@a);
                    if (@b>0) {
                        $updates{'vlan'}=join(',', @b);
                    }
                }
                $swtab1->setAttribs( \%keyhash,\%updates );
            }
        }
        $swtab1->commit;

        #remove the vlan from the vm.nic for vm clients
        if (@vmnodes > 0) {
            my %setupnics=();
            my $new_nic="vl$vlan_id";
            foreach my $node (@vmnodes) {
                my $ent=$vmtmphash->{$node}->[0];
                my $nics='';
                if (ref($ent) and defined $ent->{nics}) { 
                    $nics=$ent->{nics};
                    my @a=split(",", $nics);
                    my @b=grep(!/^$new_nic$/, @a);
                    if (@b>0) { $nics=join(',', @b); }
                }
                $setupnics{$node}={nics=>"$nics"};
            }
            $vmtab->setNodesAttribs(\%setupnics);
        }
	
        #remove the node's vlan hostname and the ip from the host table and /etc/hosts
        my @pnodes=(@snodes, @vmnodes);
        if (!remove_vlan_ip_host($net, $netmask, \@pnodes, $callback)) { return 1;}

        #refresh the DNS server
        my $res = xCAT::Utils->runxcmd(  {
                                           command => ['makedns'],
                                         }, $sub_req, 0, 1);
        my $rsp = {};
        $rsp->{data}->[0] = "Running makedns...";
        if ($res && (@$res > 0)) {
            $callback->($rsp);
            $rsp->{data} = $res;
            $callback->($rsp);
        }
        my $cmd = "service named restart";
        my $rc=system $cmd;
	
        # remove configvlan postscripts from the postscripts table for the node
        remove_postscript($callback, \@pnodes);	

        # done
        my $rsp={};
        $rsp->{data}->[0]= "The following nodes are removed from the vlan $vlan_id:\n@nodes";
        $callback->($rsp);
    }
    return 0;
}



sub process_rmvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    
    my $vlan_id=0;
    if (exists($request->{vlanid})) {
	$vlan_id=$request->{vlanid}->[0];
    }

    my @anodes=();
    my %swportinfo=();
    my %swsetup=();
    my $swtab=xCAT::Table->new("switch", -create =>0);
    if ($swtab) {
	my @tmp1=$swtab->getAllAttribs(('node', 'switch', 'port', 'vlan'));
	if ((@tmp1) && (@tmp1 > 0)) {
	    foreach my $ent (@tmp1) {
		my @nodes_tmp=noderange($ent->{node});
		foreach my $node (@nodes_tmp) {
		    my $switch=$ent->{switch};
		    my $port=$ent->{port};
		    if ($ent->{vlan}) {
			my @a=split(",", $ent->{vlan});
			if (grep(/^$vlan_id$/,@a)) {
			    push(@anodes, $node);
			    if (exists($swportinfo{$switch})) {
				my $pa=$swportinfo{$switch};
				push(@$pa, $port);
			    } else {
				$swportinfo{$switch}=[$port];
			    }
			    $swsetup{$node}->{port}=$port;
			    $swsetup{$node}->{switch}=$switch;
			    $swsetup{$node}->{vlan}=$ent->{vlan};
			}
		    }
		}
	    }
	}
    }

    my $switchestab=xCAT::Table->new('switches',-create=>0);
    if ($switchestab) {
	my @tmp1=$switchestab->getAllAttribs(('switch'));
	if ((@tmp1) && (@tmp1 > 0)) {
	    foreach(@tmp1) {
		my @switches_tmp=noderange($_->{switch});
		if (@switches_tmp==0) { push @switches_tmp, $_->{switch}; } #sometimes the switch name is not on the node list table.  
		foreach my $switch (@switches_tmp) {
		    my $ports=[];
		    if (exists($swportinfo{$switch})) {
			$ports = $swportinfo{$switch};
		    }
		    
		    my $swh;
		    if (exists($Switches{$switch})) { $swh=$Switches{$switch};}
		    else {
			$swh=new xCAT::SwitchHandler->new($switch);
			$Switches{$switch}=$swh;
		    }
		
		    print "switch=$switch, ports=@$ports\n";
		    if (@$ports > 0) {
			my @ret=$swh->remove_ports_from_vlan($vlan_id, @$ports);
			if ($ret[0] != 0) {
			    my $rsp={};
			    $rsp->{error}->[0]= "remove_ports_from_vlan: $ret[1]";
			    $callback->($rsp);
			}
		    
			my @ret=$swh->remove_vlan($vlan_id);
			if ($ret[0] != 0) {
			    my $rsp={};
			    $rsp->{error}->[0]= "remove_vlan: $ret[1]";
			    $callback->($rsp);
			}
		    } else { 
			#check if the vlan exists on the switch
			my @ids=$swh->get_vlan_ids(); 
			foreach my $id (@ids) {
			    if ($id == $vlan_id) { 
				#remove it if exists
				my @ret=$swh->remove_vlan($vlan_id);
				if ($ret[0] != 0) {
				    my $rsp={};
				    $rsp->{error}->[0]= "remove_vlan: $ret[1]";
				    $callback->($rsp);
				}
				last; 
			    }
			}
		    }
		}
	    }
	}
    }

    ### now go to the nodes to de-configure the vlan interface
    my $args = ["-P", "deconfigvlan $vlan_id"];
    my $res = xCAT::Utils->runxcmd(  {
            command => ['updatenode'],
	    node    => \@anodes,
	    arg     => $args
            }, $sub_req, 0, 1);
    my $rsp = {};
    $rsp->{data}->[0] = "Running updatenode...";
    if ($res && (@$res > 0)) {
	$callback->($rsp);
	$rsp->{data} = $res;
	$callback->($rsp);
    }

    #remove the vlan from the networks table
    my $nwtab=xCAT::Table->new("networks", -create =>1);
    my $sent = $nwtab->getAttribs({vlanid=>"$vlan_id"},'net','mask');
    my $net;
    my $netmask;
    if ($sent and ($sent->{net})) {
	$net=$sent->{net};
	$netmask=$sent->{mask};
    } 
    
    my %key_col = (vlanid=>$vlan_id);
    $nwtab->delEntries(\%key_col);
 
    #remove the vlan from the switch table for standalone nodes and vm hosts
    remove_vlan_from_switch_table(\%swsetup,$vlan_id);   

    #remove the vlan nic from vm.nics for the vm clients
    my @vmnodes=();
    my %vmsetup=();
    my $vmtab=xCAT::Table->new("vm", -create =>0);
    if ($vmtab) {
	my @tmp1=$vmtab->getAllAttribs(('node','host', 'nics'));
	if ((@tmp1) && (@tmp1 > 0)) {
	    foreach(@tmp1) {
		my @nodes_tmp=noderange($_->{node});
		my $nics=$_->{nics};
		my $new_nic="vl$vlan_id";
		if ($nics) {
		    foreach my $node (@nodes_tmp) {
			my @a=split(",", $nics);
			if (grep(/^$new_nic$/,@a)) {
			    push(@vmnodes, $node);
			    my @b=grep(!/^$new_nic$/,@a);
			    if (@b>0) {
				$vmsetup{$node}={nics=>join(',', @b)};
			    } else {
				$vmsetup{$node}={nics=>''};
			    }
			}
		    }
		}
	    }
	}
	if (keys(%vmsetup) > 0) {
	    $vmtab->setNodesAttribs(\%vmsetup);
	}
    }
    
 

    #remove the node's vlan hostname and the ip from the host table and /etc/hosts
    my @allnodes=(@anodes, @vmnodes);
    if (!remove_vlan_ip_host($net, $netmask, \@allnodes, $callback)) { return 1;}

    #refresh the DNS server
    my $res = xCAT::Utils->runxcmd(  {
            command => ['makedns'],
            }, $sub_req, 0, 1);
    my $rsp = {};
    $rsp->{data}->[0] = "Running makedns...";
    if ($res && (@$res > 0)) {
	$callback->($rsp);
	$rsp->{data} = $res;
	$callback->($rsp);
    }
    my $cmd = "service named restart";
    my $rc=system $cmd;

    ### remove configvlan postscripts from the postscripts table for the node
    #   note: if configvlan is in xcatdefaults, it will not get removed becase 
    #   it may affect other vlans
    #remove_postscript($callback, \@allnodes);  --- will not remove for multi-vlan support
}

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

    It removes configvlan postscripts from the postscripts table for the node
    Note: if configvlan is in xcatdefaults, it will not get removed becase 
       it may affect other vlans

=cut
#-------------------------------------------------------
sub  remove_postscript {
    my $callback=shift;
    my $anodes=shift;
    my $posttab=xCAT::Table->new("postscripts", -create =>0);
    if ($posttab) {
	my %setup_hash;
	my $postcache = $posttab->getNodesAttribs($anodes,[qw(postscripts postbootscripts)]);
	foreach my $node (@$anodes) {
	    my $ref = $postcache->{$node}->[0]; 
	    if ($ref) {
		if (exists($ref->{postbootscripts})) {
		    my $post=$ref->{postbootscripts};
		    my @old_a=split(',', $post);
		    my @new_a = grep (!/^configvlan$/, @old_a);
		    if (scalar(@new_a) != scalar(@old_a)) {
			#print "newa =@new_a\n";
			$setup_hash{$node}={postbootscripts=>join(',', @new_a)};
		    }
		}
		if (exists($ref->{postscripts})) {
		    my $post=$ref->{postscripts};
		    my @old_a=split(',', $post);
		    my @new_a = grep (!/^configvlan$/, @old_a);
		    if (scalar(@new_a) != scalar(@old_a)) {
			$setup_hash{$node}={postscripts=>join(',', @new_a)};
		    }
		}
	    }
	}
	if (keys(%setup_hash) > 0) {
	    $posttab->setNodesAttribs(\%setup_hash);
	}
    }   
}

sub process_lsvlan {
    my $request  = shift;
    my $callback = shift;
    my $sub_req  = shift;
    
    my $vlan_id=0;
    if (exists($request->{vlanid})) {
	$vlan_id=$request->{vlanid}->[0];
    }
   
    my %vlans=();
    #get all the vm clients if the node is a vm host
    my $nwtab=xCAT::Table->new("networks", -create =>0);
    if ($nwtab) {
	my @tmp1=$nwtab->getAllAttribs('net', 'mask', 'vlanid');
	if ((@tmp1) && (@tmp1 > 0)) {
	    foreach(@tmp1) {
		if (exists($_->{vlanid})) {
		    $vlans{$_->{vlanid}}->{net}=$_->{net};
	            $vlans{$_->{vlanid}}->{mask}=$_->{mask};
		}
	    }
	}
    }
   
    if($vlan_id !=0 && !exists($vlans{$vlan_id})) {
	my $rsp={};
        $rsp->{data}->[0] = "the vlan $vlan_id is not defined for the cluster nodes.";
        $rsp->{errorcode} = -1;
	$callback->($rsp);
        return;
    }
	
    if ($vlan_id == 0) { #just show the existing vlan ids
	my $rsp={};
	my $index=0;
	if (keys(%vlans) > 0) {
	    foreach my $id (sort keys(%vlans)) {
		$rsp->{data}->[$index] = "vlan $id:\n    subnet " . $vlans{$id}->{net}. "\n    netmask " . $vlans{$id}->{mask} . "\n";
		$index++;
	    }
	} else {
	    $rsp->{data}->[0] = "No vlans defined for the cluster nodes."
	}
	$callback->($rsp);

    } else { #shows the details
	#get all the nodes that are in the vlan
	my $swtab=xCAT::Table->new("switch", -create =>0);
	my @nodes=();
	if ($swtab) {
	    my @tmp1=$swtab->getAllAttribs('node', 'vlan', 'interface');
	    if ((@tmp1) && (@tmp1 > 0)) {
		foreach my $grp (@tmp1) {
		    my $vlan=$grp->{vlan};
		    my $nic="primary";
		    if ($grp->{interface}) { $nic=$grp->{interface};}

		    my @nodes_tmp=noderange($grp->{node});
		    if ($vlan) {
			my @a=split(",",$vlan);
			if (grep(/^$vlan_id$/, @a)) {
			    foreach my $node (@nodes_tmp) {
				push(@nodes, $node);
				$vlans{$vlan_id}->{node}->{$node}->{name} = $node;
				$vlans{$vlan_id}->{node}->{$node}->{interface} = $nic;
			    }
			}
		    }
		}
	    }
	}

	
	#get all the vm clients if the node is a vm host
	my $vmtab=xCAT::Table->new("vm", -create =>0);
	my @vmnodes=();
	if ($vmtab) {
	    my @tmp1=$vmtab->getAllAttribs('node', 'host', 'nics');
	    if ((@tmp1) && (@tmp1 > 0)) {
		my $new_nic="vl$vlan_id";
		foreach(@tmp1) {
		    my $host = $_->{host};
		    my $nics = $_->{nics};
		    if ($nics) {
			my @a=split(",", $nics);
			if (grep(/^$new_nic$/, @a)) {
			    my @nodes_tmp=noderange($_->{node});
			    foreach my $node (@nodes_tmp) {
				push(@vmnodes, $node);
				$vlans{$vlan_id}->{node}->{$node}->{name} = $node;
				$vlans{$vlan_id}->{node}->{$node}->{vmhost} = $host;
			    }
			}
		    }
		}
	    }
	}
	
	@nodes=(@nodes, @vmnodes);
	
	#now go to hosts table to get the host name and ip on the vlan
	my $hoststab = xCAT::Table->new('hosts');
	my $hostscache = $hoststab->getNodesAttribs(\@nodes,[qw(node otherinterfaces)]);
	my $max=0;
	my $prefix;
	foreach my $node (@nodes) {
	    my $ref = $hostscache->{$node}->[0]; 
	    my $otherinterfaces;
	    if ($ref && exists($ref->{otherinterfaces})){
		$otherinterfaces = $ref->{otherinterfaces};
		my @itf_pairs=split(/,/, $otherinterfaces);
		my @itf_pairs2=();
		foreach (@itf_pairs) {
		    my ($name,$ip)=split(/:/, $_);
		    if(xCAT::NetworkUtils->ishostinsubnet($ip, $vlans{$vlan_id}->{mask}, $vlans{$vlan_id}->{net})) {
			$vlans{$vlan_id}->{node}->{$node}->{ip}=$ip;
			$vlans{$vlan_id}->{node}->{$node}->{vname}=$name;
		    }
		}
	    }
	} #foreach node

	my $rsp={};
	$rsp->{data}->[0]="vlan $vlan_id";
        $rsp->{data}->[1]="    subnet " . $vlans{$vlan_id}->{net};
        $rsp->{data}->[2]="    netmask " . $vlans{$vlan_id}->{mask} . "\n";
	my $node_hash=$vlans{$vlan_id}->{node};
	#print Dumper($node_hash);
	if ($node_hash && keys(%$node_hash) > 0) {
	    $rsp->{data}->[3]="    hostname\tip address\tnode    \tvm host \tinterface";
	    my $index=4;
	    foreach (sort keys(%$node_hash)) {
		my $vname=$node_hash->{$_}->{vname};
		if (!$vname) { $vname="      ";}
		my $ip=$node_hash->{$_}->{ip};
		if (!$ip) { $ip="               "; }
		my $name=$node_hash->{$_}->{name};
		if (!$name) { $name="      ";}	   
		my $host=$node_hash->{$_}->{vmhost};
		if (!$host) { $host="        ";}	  
		my $nic=$node_hash->{$_}->{interface};
		$rsp->{data}->[$index] = "    $vname\t$ip\t$name\t$host\t$nic";
		$index++;
	    }
	}
	$callback->($rsp);
    } 
}

sub mkvlan_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: mkvlan -h";
    $rsp->{data}->[1]= "       mkvlan -v";
    $rsp->{data}->[2]= "       mkvlan [vlanid] -n noderange [-t net -m mask] [-p node_prefix] [-i nic]";

    $cb->($rsp);
}

sub rmvlan_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: rmvlan -h";
    $rsp->{data}->[1]= "       rmvlan -v";
    $rsp->{data}->[2]= "       rmvlan vlanid";

    $cb->($rsp);
}

sub chvlanports_usage{
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: chvlanports -h";
    $rsp->{data}->[1]= "       chvlanports -v";
    $rsp->{data}->[2]= "       chvlanports vlanid -n noderange -i nic";
    $rsp->{data}->[3]= "       chvlanports vlanid -n noderange -i nic -d";
    $cb->($rsp);
}
sub chvlan_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: chvlan -h";
    $rsp->{data}->[1]= "       chvlan -v";
    $rsp->{data}->[2]= "       chvlan vlanid -n noderange [-i nic]";
    $rsp->{data}->[3]= "       chvlan vlanid -n noderange -d";
    $cb->($rsp);
}

sub lsvlan_usage {
    my $cb=shift;
    my $rsp={};

    $rsp->{data}->[0]= "Usage: lsvlan -h";
    $rsp->{data}->[1]= "       lsvlan -v";
    $rsp->{data}->[2]= "       lsvlan";
    $rsp->{data}->[3]= "       lsvlan vlanid";

    $cb->($rsp);
}

#-------------------------------------------------------
=head3  getNodeVlanConfData
   This function is called by Postage.pm to collect all the 
   environmental variables for setting up a vlan for a given 
   node.  
=cut
#-------------------------------------------------------
sub getNodeVlanConfData {
    my $node=shift;
    if ($node =~ /xCAT_plugin::vlan/) {
	$node=shift;
    }

    my @scriptd=();
    my $swtab = xCAT::Table->new("switch", -create => 0);
    if ($swtab) {
	my $tmp_switch = $swtab->getNodesAttribs([$node], ['vlan','interface'],prefetchcache=>1);
        #print Dumper($tmp_switch);
	if (defined($tmp_switch) && (exists($tmp_switch->{$node})) && (defined($tmp_switch->{$node}->[0]))) { 
	    my $tmp_node_array=$tmp_switch->{$node};
	    my $index=0;
	    foreach my $tmp (@$tmp_node_array) {
		if (exists($tmp->{vlan})) {
		    my $nic="primary";
		    if (exists($tmp->{interface})) { $nic=$tmp->{interface};}
		    my @vlanid_array = split(',', $tmp->{vlan});
		    foreach my $vlan (@vlanid_array) {
			$index++;
			push @scriptd, "VLANID_$index='" . $vlan . "'\n";
			push @scriptd, "export VLANID_$index\n";
			push @scriptd, "VLANNIC_$index='" . $nic . "'\n";
			push @scriptd, "export VLANNIC_$index\n";
			my @temp_data=getNodeVlanOtherConfData($node, $vlan, $index);
			@scriptd = (@scriptd,@temp_data);
		    } 
		}
	    }
	    if ($index > 0) { 
		push @scriptd, "VLANMAXINDEX='" . $index . "'\n";
		push @scriptd, "export VLANMAXINDEX\n";
	    }   
	} else {
	    my $vmtab = xCAT::Table->new("vm", -create => 0);
	    if ($vmtab) {
		my $tmp1 = $vmtab->getNodeAttribs($node, ['nics','host'],prefetchcache=>1);
		
		my $vlan;
		my $index=0;
		if (defined($tmp1) && ($tmp1) && $tmp1->{nics})
		{
		    push @scriptd, "VMNODE='YES'\n";
		    push @scriptd, "export VMNODE\n";
		    push @scriptd, "VMNICS='" . $tmp1->{nics} . "'\n";
		    push @scriptd, "export VMNICS\n";
		    
		    my @nics=split(',', $tmp1->{nics});

		    #get the vlan id and interface from the host
		    my $host=$tmp1->{host};
		    #my $host_vlan_info=get_vm_host_vlan_info($host);
                    my $nic_position=0;
		    foreach my $nic (@nics) {
			$nic_position++;
			if ($nic =~ /^vl([\d]+)$/) {
			    $vlan = $1;
			    $index++;
			    push @scriptd, "VLANID_$index='" . $vlan . "'\n";
			    push @scriptd, "export VLANID_$index\n";
			    push @scriptd, "VLAN_VMNICPOS_$index='" . $nic_position . "'\n";
			    push @scriptd, "export VLAN_VMNICPOS_$index\n";
			    #if ($host_vlan_info && (exists($host_vlan_info->{$vlan}))) {
			    #	push @scriptd, "HOST_VLANNIC_$index='" . $host_vlan_info->{$vlan} . "'\n";
			    #	push @scriptd, "export HOST_VLANNIC_$index\n";
			    #}
			    my @temp_data=getNodeVlanOtherConfData($node, $vlan, $index);
			    @scriptd = (@scriptd,@temp_data); 
			}
   		    } #end foreach
		}
		if ($index > 0) { 
		    push @scriptd, "VLANMAXINDEX='" . $index . "'\n";
		    push @scriptd, "export VLANMAXINDEX\n";
		}		
	    }
	}
    }
    
    return @scriptd;
}

sub getNodeVlanOtherConfData {
    my $node=shift;
    if ($node =~ /xCAT_plugin::vlan/) {
	$node=shift;
    }
    my $vlan=shift;
    my $index=shift;

    my @scriptd=();
    my $nwtab=xCAT::Table->new("networks", -create =>0);
    if ($nwtab) {
	my $sent = $nwtab->getAttribs({vlanid=>"$vlan"},'net','mask');
	my $subnet;
	my $netmask;
	if ($sent and ($sent->{net})) {
	    $subnet=$sent->{net};
	    $netmask=$sent->{mask};
	} 
	if (($subnet) && ($netmask)) {
	    my $hoststab = xCAT::Table->new("hosts", -create => 0);
	    if ($hoststab) {
		my $tmp = $hoststab->getNodeAttribs($node, ['otherinterfaces'],prefetchcache=>1);
		if (defined($tmp) && ($tmp) && $tmp->{otherinterfaces})
		{
		    my $otherinterfaces = $tmp->{otherinterfaces};
		    my @itf_pairs=split(/,/, $otherinterfaces);
		    foreach (@itf_pairs) {
			my ($name,$ip)=split(/:/, $_);
			if(xCAT::NetworkUtils->ishostinsubnet($ip, $netmask, $subnet)) {
			    if ($name =~ /^-/ ) {
				$name = $node.$name;
			    }
			    push @scriptd, "VLANHOSTNAME_$index='" . $name . "'\n";
			    push @scriptd, "export VLANHOSTNAME_$index\n";
			    push @scriptd, "VLANIP_$index='" . $ip . "'\n";
			    push @scriptd, "export VLANIP_$index\n";
			    push @scriptd, "VLANSUBNET_$index='" . $subnet . "'\n";
			    push @scriptd, "export VLANSUBNET_$index\n";
			    push @scriptd, "VLANNETMASK_$index='" . $netmask . "'\n";
			    push @scriptd, "export VLANNETMASK_$index\n";
			    last;
			}
		    }	    
		}
	    }
	}
    }
    
    return @scriptd;
}

#-------------------------------------------------------
=head3  get_vm_host_vlan_info
   This function returns a hash pointer that has the vlan id
   and the interface info for the given KVM host. A host can
   support more than one vlans for a interface. For example:
   {1=>"eth0", 2=>"eth0", 3=>"eth1" ...}
=cut
#-------------------------------------------------------
sub get_vm_host_vlan_info {
    my $host=shift;
    my $host_vlan_info={};
    my $swtab = xCAT::Table->new("switch", -create => 0);
    if ($swtab) {
	my $tmp_switch = $swtab->getNodesAttribs([$host], ['vlan','interface'],prefetchcache=>1);
	if (defined($tmp_switch) && (exists($tmp_switch->{$host}))) { 
	    my $tmp_node_array=$tmp_switch->{$host};
	    foreach my $tmp (@$tmp_node_array) {
		if (exists($tmp->{vlan})) {
		    my $vlans = $tmp->{vlan};
		    my $nic="primary";
		    if (exists($tmp->{interface})) {
			$nic=$tmp->{interface};
		    }
		    foreach my $vlan (split(',',$vlans)) {
			$host_vlan_info->{$vlan}=$nic;
		    }
		}
	    }
	}
	return $host_vlan_info;  
    }
}