# IBM(c) 2012 EPL license http://www.eclipse.org/legal/epl-v10.html
package xCAT::ProfiledNodeUtils;

use strict;
use warnings;
use Socket;
use File::Path qw/mkpath/;
use File::Temp qw/tempfile/;
use Fcntl qw(:flock);
require xCAT::Table;
require xCAT::TableUtils;
require xCAT::NodeRange;
require xCAT::NetworkUtils;
require xCAT::DBobjUtils;


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

=head1    xCAT::ProfiledNodeUtils

=head2    Package Description

This program module file, is a set of node management utilities for Profile based nodes.

=cut

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

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

=head3 get_allocable_staticips_innet
      Description : Get allocable IPs from a network.
      Arguments   : $netname - network name
                    $exclude_ips_ref - excluded IPs list reference.
      Returns     : Reference of allocable IPs list
=cut

#-------------------------------------------------------------------------------
sub get_allocable_staticips_innet
{
    my $class = shift;
    my $netname = shift;
    my $exclude_ips_ref = shift;
    my %iphash;
    my @allocableips;

    foreach (@$exclude_ips_ref){
        $iphash{$_} = 0;
    }

    my $networkstab = xCAT::Table->new('networks');
    my $netentry = ($networkstab->getAllAttribsWhere("netname = '$netname'", 'ALL'))[0];
    my ($startip, $endip) =  split('-', $netentry->{'staticrange'});
    my $incremental = $netentry->{'staticrangeincrement'};
    my $netmask = $netentry->{'mask'};
    my $gateway = $netentry->{'gateway'};
    my $validipsref;
    if ($incremental and $startip and $endip){
        $validipsref = xCAT::NetworkUtils->get_allips_in_range($startip, $endip, $incremental);
    }
    
    my $broadcastip = xCAT::NetworkUtils->getBroadcast($startip, $netmask);
    foreach (@$validipsref){
        #Remove ip which is broadcast ip, exclude ip, ips ended with 0, gateway ip
        if (exists($iphash{$_}) or $_ eq $broadcastip or $_ eq $gateway 
            or $_ =~ /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(0)$/){
            next;
        }
        push @allocableips, $_;
    }
    return \@allocableips;
}

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

=head3 genhosts_with_numric_tmpl
      Description : Generate numric hostnames using numric template name.
      Arguments   : $format - The hostname format string..
                    $rank - The start number.
                    $amount - The total hostname number to be generated.
      Returns     : numric hostname list
      Example     : 
              calling  genhosts_with_numric_tmpl("compute#NNnode") will return a list like:
              ("compute00node", "compute01node", ..."compute98node", "compute99node")
=cut

#-------------------------------------------------------------------------------
sub genhosts_with_numric_tmpl
{
    my ($class, $format, $rank, $amount) = @_;

    my ($prefix, $appendix, $len) = xCAT::ProfiledNodeUtils->split_hostname($format, 'N');
    return xCAT::ProfiledNodeUtils->gen_numric_hostnames($prefix, $appendix, $len, $rank, $amount);
}

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

=head3 split_hostname
      Description : Split hostname format as prefix, appendix and number length.
      Arguments   : $format - hostname format
                    $patt_char - pattern char, we always use "N" to indicate numric pattern
      Returns     : ($prefix, $appendix, $numlen)
                    $prefix - the prefix string of hostname format.
                    $appendix - the appendix string of hostname format
                    $numlen - The number length in hostname format.
      Example     : 
              calling  split_hostname("compute#NNnode") will return a list like:
              ("compute", "node", 2)
=cut

#-------------------------------------------------------------------------------
sub split_hostname
{
    my ($class, $format, $patt_char) = @_;

    my $idx = index $format, "#$patt_char";
    my @array_format = split(//, $format);
    my $pos = $idx+2;
    while ( $pos <= (scalar(@array_format) - 1)){
        if ($array_format[$pos] eq "$patt_char"){
            $pos++;
        }else{
            last;
        }
    }
    my $ridx = $pos - 1;

    my $prefix = "";
    $prefix = substr $format, 0, $idx;
    my $appendix = "";
    if (($ridx + 1) != scalar(@array_format)){
        $appendix = substr $format, $ridx + 1;
    }
    return $prefix, $appendix, ($ridx - $idx);
}

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

=head3 gen_numric_hostnames
      Description : Generate numric hostnames.
      Arguments   : $prefix - The prefix string of the hostname.
                    $appendix - The appendix string of the hostname.
                    $len - the numric number length in hostname.
                    $rank - the start number for numric part
                    $amount - the amount of hostnames to be generated.
      Returns     : numric hostname list
      Example     : 
              calling  gen_numric_hostnames("compute", "node",2) will return a list like:
              ("compute00node", "compute01node", ..."compute98node", "compute99node")
=cut

#-------------------------------------------------------------------------------
sub gen_numric_hostnames
{
    my ($class, $prefix, $appendix, $len, $rank, $amount) = @_;
    my @hostnames;
    my $cnt = 0;

    if ($rank){
        $cnt = $rank;
    } 
    my $maxnum = 10 ** $len;
    while($cnt < $maxnum)
    {
        my $fullnum = $maxnum + $cnt;
        my $hostname = $prefix.(substr $fullnum, 1).$appendix;
        push (@hostnames, $hostname);
        if ($amount && (@hostnames == $amount)){
            last;
        }
        $cnt++;
    }
    return \@hostnames;
}

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

=head3 get_hostname_format_type
      Description : Get hostname format type.
      Arguments   : $format - hostname format
      Returns     : hostname format type value:
                    "numric" - numric hostname format.
                    "rack" - rack info hostname format.
      Example     : 
              calling  get_hostname_format_type("compute#NNnode") will return "numric"
              calling  get_hostname_format_type("compute-#RR-#NN") will return "rack" 
=cut

#-------------------------------------------------------------------------------
sub get_hostname_format_type{
    my ($class, $format) =  @_;
    my $type;
    my ($prefix, $appendix, $rlen, $nlen);

    my $ridx = index $format, "#R";
    my $nidx = index $format, "#N";
    my $simpname = "";
    if ($ridx >= 0){
        ($prefix, $appendix, $rlen) = xCAT::ProfiledNodeUtils->split_hostname($format, 'R');
        $simpname = $prefix."0".$appendix;
        ($prefix, $appendix, $nlen) = xCAT::ProfiledNodeUtils->split_hostname($simpname, 'N');
        $simpname = $prefix."0".$appendix;
        if ($rlen >= 10 || $nlen >= 10 || $nlen == 0){
            $type = "unknown";
        } else{
            $type = "rack";
        }
    } elsif ($nidx >= 0){
        ($prefix, $appendix, $nlen) = xCAT::ProfiledNodeUtils->split_hostname($format, 'N');
        $simpname = $prefix."0".$appendix;
        if ($nlen >= 10){
            $type = "unknown";
        } else{
            $type = "numric";
        }
    } else{
        $type = "unknown";
    }
    # validate whether hostname format includes other invalid characters.
    if ($type ne "unknown"){
        if (! xCAT::NetworkUtils->isValidHostname($simpname)){
            $type = "unknown";
        }
    }

    return $type;
}

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

=head3 rackformat_to_numricformat
      Description : convert rack hostname format into numric hostname format.
      Arguments   : $format - rack hostname format
                    $racknum - rack number.
      Returns     : numric hostname format.
      Example     : 
           calling  rackformat_to_numricformat("compute-#RR-#NN", 1) will return "compute-01-#NN" 
=cut

#-------------------------------------------------------------------------------
sub rackformat_to_numricformat{
    my ($class, $format, $rackname) = @_;
    my ($prefix, $appendix, $len) = xCAT::ProfiledNodeUtils->split_hostname($format, 'R');

    my %objhash = xCAT::DBobjUtils->getobjdefs({$rackname, "rack"});
    my $racknum = $objhash{$rackname}{"num"};
    my $maxnum = 10 ** $len;
    if ($racknum >= $maxnum ){
        return undef;
    }

    my $fullnum = $maxnum + $racknum;
    return $prefix.(substr $fullnum, 1).$appendix;
}

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

=head3 get_nodes_nic_attrs
      Description : Get nodes NIC attributes and return a dict.
      Arguments   : $nodelist - nodes list ref.
      Returns     : A hash ref of %nicsattrs for node's nics attributes.
                    keys of %nicsattrs are node names.
                    values of %nicsattrs are nics attrib ref.
                    For each nic attrib ref, the keys are nic names, like: ib0, eth0, bmc...
                    values are attributes of a specific nic, like:
                        type : nic type
                        hostnamesuffix: hostname suffix
                        hostnameprefix: hostname prefix
                        customscript: custom script for this nic
                        network: network name for this nic
                        ip: ip address of this nic.
=cut

#-------------------------------------------------------------------------------
sub get_nodes_nic_attrs{
    my $class = shift;
    my $nodes = shift;

    my $nicstab = xCAT::Table->new( 'nics');
    my $entry = $nicstab->getNodesAttribs($nodes, ['nictypes', 'nichostnamesuffixes', 'nichostnameprefixes', 'niccustomscripts', 'nicnetworks', 'nicips', 'nicextraparams']);

    my %nicsattrs;
    my @nicattrslist;

    foreach my $node (@$nodes){
        if ($entry->{$node}->[0]->{'nictypes'}){
            @nicattrslist = split(",", $entry->{$node}->[0]->{'nictypes'});
            foreach (@nicattrslist){
				my @nicattrs;
				if ($_  =~ /!/) {
					@nicattrs = split("!", $_);
				} else {
					@nicattrs = split(":", $_);
				}
                $nicsattrs{$node}{$nicattrs[0]}{'type'} = $nicattrs[1];
            }
        }

        if($entry->{$node}->[0]->{'nichostnamesuffixes'}){
            @nicattrslist = split(",", $entry->{$node}->[0]->{'nichostnamesuffixes'});
            foreach (@nicattrslist){
				my @nicattrs;
				if ($_  =~ /!/) {
					@nicattrs = split("!", $_);
				} else {
					@nicattrs = split(":", $_);
				}
                $nicsattrs{$node}{$nicattrs[0]}{'hostnamesuffix'} = $nicattrs[1];
            }
        }

        if($entry->{$node}->[0]->{'nichostnameprefixes'}){

            @nicattrslist = split(",", $entry->{$node}->[0]->{'nichostnameprefixes'});
            foreach (@nicattrslist){
                               my @nicattrs;
                               if ($_  =~ /!/) {
                                       @nicattrs = split("!", $_);
                               } else {
                                       @nicattrs = split(":", $_);
                               }
                $nicsattrs{$node}{$nicattrs[0]}{'hostnameprefix'} = $nicattrs[1];
            }
        }

        if($entry->{$node}->[0]->{'niccustomscripts'}){
            @nicattrslist = split(",", $entry->{$node}->[0]->{'niccustomscripts'});
            foreach (@nicattrslist){
				my @nicattrs;
				if ($_  =~ /!/) {
					@nicattrs = split("!", $_);
				} else {
					@nicattrs = split(":", $_);
				}
                $nicsattrs{$node}{$nicattrs[0]}{'customscript'} = $nicattrs[1];
            }
        }

        if($entry->{$node}->[0]->{'nicnetworks'}){
            @nicattrslist = split(",", $entry->{$node}->[0]->{'nicnetworks'});
            foreach (@nicattrslist){
				my @nicattrs;
				if ($_  =~ /!/) {
					@nicattrs = split("!", $_);
				} else {
					@nicattrs = split(":", $_);
				}
                $nicsattrs{$node}{$nicattrs[0]}{'network'} = $nicattrs[1];
            }
        }

        if($entry->{$node}->[0]->{'nicips'}){
            @nicattrslist = split(",", $entry->{$node}->[0]->{'nicips'});
            foreach (@nicattrslist){
				my @nicattrs;
				if ($_  =~ /!/) {
					@nicattrs = split("!", $_);
				} else {
					@nicattrs = split(":", $_);
				}
                $nicsattrs{$node}{$nicattrs[0]}{'ip'} = $nicattrs[1];
            }
        }

        if($entry->{$node}->[0]->{'nicextraparams'}){
            @nicattrslist = split(",", $entry->{$node}->[0]->{'nicextraparams'});
            foreach (@nicattrslist){
				my @nicattrs;
				if ($_  =~ /!/) {
					@nicattrs = split("!", $_);
				} else {
					@nicattrs = split(":", $_);
				}
                $nicsattrs{$node}{$nicattrs[0]}{'extraparams'} = $nicattrs[1];
            }
        }
    }

    return \%nicsattrs;
}

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

=head3 get_netprofile_bmcnet
      Description : Get bmc network name of a network profile.
      Arguments   : $nettmpl - network profile name 
      Returns     : bmc network name of this network profile.
=cut

#-------------------------------------------------------------------------------
sub get_netprofile_bmcnet{
    my ($class, $netprofilename) = @_;

    my $netprofile_nicshash_ref = xCAT::ProfiledNodeUtils->get_nodes_nic_attrs($netprofilename)->{$netprofilename};
    my %netprofile_nicshash = %$netprofile_nicshash_ref;
    if (exists $netprofile_nicshash{'bmc'}{"network"}){
        return $netprofile_nicshash{'bmc'}{"network"}
    }else{
        return undef;
    }
}

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

=head3 get_netprofile_provisionnet
      Description : Get deployment network of a network profile.
      Arguments   : $nettmpl - network profile name 
      Returns     : deployment network name of this network profile.
=cut

#-------------------------------------------------------------------------------
sub get_netprofile_provisionnet{
    my ($class, $netprofilename) = @_;

    my $netprofile_nicshash_ref = xCAT::ProfiledNodeUtils->get_nodes_nic_attrs([$netprofilename])->{$netprofilename};
    my %netprofile_nicshash = %$netprofile_nicshash_ref;
    my $restab = xCAT::Table->new('noderes');
    my $installnicattr = $restab->getNodeAttribs($netprofilename, ['installnic']);
    my $installnic = $installnicattr->{'installnic'};

    if ($installnic){
        if (exists $netprofile_nicshash{$installnic}{"network"}){
            return $netprofile_nicshash{$installnic}{"network"}
        }
    }
    return undef;
}

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

=head3 get_output_filename
      Description : Generate a temp file name for placing output details for profiled node management operations.
                    We make this file generated under /install/ so that clients can access it through http.
      Arguments   : N/A
      Returns     : A temp filename placed under /install/pcm/work/
=cut

#-------------------------------------------------------------------------------
sub get_output_filename
{
    my $installdir = xCAT::TableUtils->getInstallDir();
    my $pcmworkdir = $installdir."/pcm/work/";
    if (! -d $pcmworkdir)
    {
        mkpath($pcmworkdir);
    }
    return tempfile("hostinfo_result_XXXXXXX", DIR=>$pcmworkdir);
}

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

=head3 get_all_chassis
      Description : Get all chassis in system.
      Arguments   : hashref: if not set, return a array ref.
                             if set, return a hash ref.
                    type   : "all", get all chassis, 
                             "cmm", get all chassis whose type is cmm
                    if type not specify, it is 'all'
      Returns     : ref for chassis list.
      Example     : 
                    my $arrayref = xCAT::ProfiledNodeUtils->get_all_chassis();
                    my $hashref = xCAT::ProfiledNodeUtils->get_all_chassis(1);
                    my $hashref = xCAT::ProfiledNodeUtils->get_all_chassis(1, 'cmm');
=cut

#-------------------------------------------------------------------------------
sub get_all_chassis
{
    my $class = shift;
    my $hashref = shift;
    my $type = shift;
    my %chassishash;
    my %chassistype = ('all' => '__Chassis', 'cmm' => '__Chassis_IBM_Flex_chassis');

    if (not $type) {
        $type = 'all';
    }
    my @chassis = xCAT::NodeRange::noderange($chassistype{$type});
    if ($hashref){
        foreach (@chassis){
            $chassishash{$_} = 1;
        }
        return \%chassishash;
    } else{
        return \@chassis;
    }
}

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

=head3 get_all_rack
      Description : Get all rack in system.
      Arguments   : hashref: if not set, return a array ref.
                             if set, return a hash ref.
      Returns     : ref for rack list.
      Example     : 
                    my $arrayref = xCAT::ProfiledNodeUtils->get_all_rack();
                    my $hashref = xCAT::ProfiledNodeUtils->get_all_rack(1);
=cut

#-------------------------------------------------------------------------------
sub get_all_rack
{
    my $class = shift;
    my $hashref = shift;
    my %rackhash = ();
    my @racklist = ();

    my $racktab = xCAT::Table->new('rack');
    my @racks = $racktab->getAllAttribs(('rackname'));
    foreach (@racks){
        if($_->{'rackname'}){
            if ($hashref){
                $rackhash{$_->{'rackname'}} = 1;
            }else {
                push @racklist, $_->{'rackname'};
            }
        }
    }
   
    if ($hashref){
        return \%rackhash;
    }else{
        return \@racklist;
    }
}

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

=head3 get_racks_for_chassises
      Description : Get rack info for a chassis list.
      Arguments   : $chassislistref - chassis list reference.
      Returns     : A dict ref. keys are chassis name, values are rack name for each chassis.
=cut

#-------------------------------------------------------------------------------
sub get_racks_for_chassises
{
    my $class = shift;
    my $chassislistref = shift;
    my %rackinfodict = ();

    my $nodepostab = xCAT::Table->new('nodepos');
    my $racksref = $nodepostab->getNodesAttribs($chassislistref, ['rack']);
    foreach (@$chassislistref){
        $rackinfodict{$_} = $racksref->{$_}->[0]->{'rack'};
    }
    return \%rackinfodict;
}

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

=head3 get_allnode_singleattrib_hash
      Description : Get all records of a column from a table, then return a hash.
                    The return hash's keys are the records of this attribute 
                    and values are all set as 1.
      Arguments   : $tabname - the table name.
                    $attr - the attribute name.
      Returns     : Reference of the records hash.
=cut

#-------------------------------------------------------------------------------
sub get_allnode_singleattrib_hash
{
    my $class = shift;
    my $tabname = shift;
    my $attr = shift;
    my $table = xCAT::Table->new($tabname);
    my @entries = $table->getAllNodeAttribs([$attr]);
    my %allrecords;
    foreach (@entries) {
        if ($_->{$attr}){
            $allrecords{$_->{$attr}} = 0;
        }
    }
    return \%allrecords;
}

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

=head3 get_db_swtiches
      Description : Get all records of switch config from a table, then return a string list.
      Arguments   : $tabname - the table name.
      Returns     : Reference of the records hash.
=cut

#-------------------------------------------------------------------------------
sub get_db_switches
{
    my $class = shift;
    my $table = xCAT::Table->new("switches");
    my @attribs = ("switch");
    my @entries = $table->getAllAttribs(@attribs);
    $table->close();
    my %allrecords;
    foreach (@entries) 
    {
        if ($_->{'switch'}){
            $allrecords{$_->{'switch'}} = 0;
        }
    }
    return \%allrecords;
}

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

=head3 get_db_swtichports
      Description : Get all records of switch config from a table, then return a string list.
      Arguments   : $tabname - the table name.
      Returns     : Reference of the records hash.
=cut

#-------------------------------------------------------------------------------
sub get_db_switchports
{
    my $class = shift;
    my $table = xCAT::Table->new("switch");
    my @attribs = ("switch", "port");
    my @entries = $table->getAllAttribs(@attribs);
    $table->close();
    my %allrecords;
    foreach (@entries) 
    {
        $allrecords{$_->{'switch'} . "_" . $_->{'port'}} = 0;
    }
    return \%allrecords;
}

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

=head3 get_all_cecs
      Description : Get all CEC objects name in system.
      Arguments   : hashref: if not set, return a array ref.
                             if set, return a hash ref.
      Returns     : ref for CECs list.
      Example     : 
                    my $arrayref = xCAT::ProfiledNodeUtils->get_all_cecs();
                    my $hashref = xCAT::ProfiledNodeUtils->get_all_cecs(1);
=cut

#-------------------------------------------------------------------------------
sub get_all_cecs
{
    my $hashref = shift;
    my %cecshash;
    my @cecslist;

    my $ppctab = xCAT::Table->new('ppc');
    my @cecs = $ppctab->getAllAttribsWhere("nodetype = 'cec'", 'node');
    foreach (@cecs) {
        if($_->{'node'}) {
            if ($hashref) {
                $cecshash{$_->{'node'}} = 1;
            } else {
                push @cecslist, $_->{'node'};
            }
        }
    }
    $ppctab->close();

    # Return the ref accordingly 
    if ($hashref) {
        return \%cecshash;
    } else {
        return \@cecslist;
    }
}

#-------------------------------------------------------------------------------
 
=head3 get_all_lparids
      Description : Get all LPAR ids  in system.
      Arguments   : ref of all cecs
      Returns     : ref for LPAR ids hash.
      Example     : 
                    my $arrayref = xCAT::ProfiledNodeUtils->get_all_lparids(\%allcecs);
=cut

#-------------------------------------------------------------------------------
sub get_all_lparids
{
    my $class= shift;
    my $cecsref = shift;
    my %allcecs = %$cecsref;
    my %lparids;

    my $ppctab = xCAT::Table->new('ppc');
    foreach my $cec (keys  %allcecs) {
        my @ids = $ppctab->getAllAttribsWhere("hcp = '$cec'", 'id');
        foreach (@ids) {
            if ( $_->{'id'} ){
                $lparids{$cec}{$_->{'id'}} = 0;
            }
        }
    }
    $ppctab->close();
    
    return \%lparids;
}


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

=head3 is_discover_started
      Description : Judge whether profiled nodes discovering is running or not.
      Arguments   : NA
      Returns     : 1 - Discover is running
                    0 - Discover is not started.
=cut

#-------------------------------------------------------------------------------
sub is_discover_started
{
    my @sitevalues = xCAT::TableUtils->get_site_attribute("__PCMDiscover");
    if (! $sitevalues[0]){
        return 0;
    }
    return 1;
}

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

=head3 get_node_profiles
      Description : Get nodelist's profile and return a hash ref.
      Arguments   : node list.
      Returns     : nodelist's profile hash.
                    keys are node names.
                    values are hash ref. This hash ref is placing the node's profile information:
                        keys can be followings: "NetworkProfile", "ImageProfile", "HardwareProfile"
                        values are the profile names.
=cut

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

sub get_nodes_profiles
{
    my $class = shift;
    my $nodelistref = shift;
    my $groupnamemode = shift;
    my %profile_dict;

    my $nodelisttab = xCAT::Table->new('nodelist');
    my $groupshashref = $nodelisttab->getNodesAttribs($nodelistref, ['groups']);
    my %groupshash = %$groupshashref;

    foreach (keys %groupshash){
        my $value = $groupshash{$_};
        my $groups = $value->[0]->{'groups'};
        # groups looks like "__Managed,__NetworkProfile_default_cn,__ImageProfile_rhels6.3-x86_64-install-compute"
        my @grouplist = split(',', $groups);
        my @profilelist = ("NetworkProfile", "ImageProfile", "HardwareProfile");
        foreach my $group (@grouplist){
            foreach my $profile (@profilelist){
                my $idx = index ($group, $profile);
                # The Group starts with __, so index will be 2.
                if ( $idx == 2 ){
                    # The group string will like @NetworkProfile_<profile name>
                    # So, index should +3, 2 for '__', 1 for _.
                    if ($groupnamemode) { 
                        $profile_dict{$_}{$profile} = $group;
                    } else{
                        my $append_index = length($profile) + 3;
                        $profile_dict{$_}{$profile} = substr $group, $append_index;
                    }
                    last;
                }
            }
        }
    }
    return \%profile_dict;
}

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

=head3 get_imageprofile_prov_method
      Description : Get A node's provisioning method from its imageprofile attribute.
      Arguments   : $imgprofilename - imageprofile name
      Returns     : node's provisioning method: install, netboot...etc
=cut

#-------------------------------------------------------------------------------
sub get_imageprofile_prov_method
{

    # For imageprofile, we can get node's provisioning method through:
    # nodetype table: node (imageprofile name), provmethod (osimage name)
    # osimage table: imagename (osimage name), provmethod (node deploy method: install, netboot...)
    my $class = shift;
    my $imgprofilename = shift;

    my $nodetypestab = xCAT::Table->new('nodetype');
    my $entry = ($nodetypestab->getAllAttribsWhere("node = '$imgprofilename'", 'ALL' ))[0];
    return $entry->{'provmethod'};

    #my $osimgtab = xCAT::Table->new('osimage');
    #my $osimgentry = ($osimgtab->getAllAttribsWhere("imagename = '$osimgname'", 'ALL' ))[0];
    #return $osimgentry->{'provmethod'};
}

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

=head3 get_imageprofile_prov_osvers
      Description : Get A node's provisioning os version and profile from its imageprofile attribute.
      Arguments   : $imgprofilename - imageprofile name
      Returns     : node's osversion and profile
=cut

#-------------------------------------------------------------------------------
sub get_imageprofile_prov_osvers
{

    my $class = shift;
    my $imgprofilename = shift;
    my $osimgtab = xCAT::Table->new('osimage');
    my $osimgentry = ($osimgtab->getAllAttribsWhere("imagename = '$imgprofilename'", 'ALL' ))[0];
    my $osversion = $osimgentry->{'osvers'};
    my $profile = $osimgentry->{'profile'};
    return ($osversion, $profile);
}

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

=head3 check_profile_consistent
      Description : Check if three profile consistent
      Arguments   : $imageprofile - image profile name
                    $networkprofile - network profile name
                    $hardwareprofile - harware profile name
      Returns     : returncode, errmsg - consistent
                    returncode=1 - consistent
                    returncode=0 - not consistent
=cut

#-------------------------------------------------------------------------------
sub check_profile_consistent{
    my $class = shift;
    my $imageprofile = shift;
    my $networkprofile = shift;
    my $hardwareprofile = shift;
    
    # Check the profiles are existing in DB.
    my @nodegrps = xCAT::TableUtils->list_all_node_groups();
    unless(grep{ $_ eq $imageprofile} @nodegrps){
        return 0, "Image profile not defined in DB."
    }
    unless(grep{ $_ eq $networkprofile} @nodegrps){
        return 0, "Network profile not defined in DB."
    }
    if ($hardwareprofile){
        unless(grep{ $_ eq $hardwareprofile} @nodegrps){
            return 0, "Hardware profile not defined in DB."
        }
    }

    # Get Imageprofile arch
    my $nodetypetab = xCAT::Table->new('nodetype');
    my $nodetypeentry = $nodetypetab->getNodeAttribs($imageprofile, ['os','arch']);
    my $os = $nodetypeentry->{'os'};
    my $arch = $nodetypeentry->{'arch'};
    $nodetypetab->close();
    
    # Get Imageprofile pkgdir
    my $osdistroname = $os . "-" . $arch;
    my $osdistrotab = xCAT::Table->new('osdistro');
    my $osdistroentry = ($osdistrotab->getAllAttribsWhere("osdistroname = '$osdistroname'", 'ALL' ))[0];
    my $pkgdir = $osdistroentry->{'dirpaths'};
    $osdistrotab->close();
    
    # Get networkprofile netboot and installnic
    my $noderestab = xCAT::Table->new('noderes');
    my $noderesentry = $noderestab->getNodeAttribs($networkprofile, ['netboot', 'installnic']);
    my $netboot = $noderesentry->{'netboot'};
    my $installnic = $noderesentry->{'installnic'}; 
    $noderestab->close();
    
    # Get networkprofile nictypes
    my $netprofile_nicshash_ref = xCAT::ProfiledNodeUtils->get_nodes_nic_attrs([$networkprofile])->{$networkprofile};
    my %netprofile_nicshash = %$netprofile_nicshash_ref;
    my $nictype = undef;
    foreach (keys %netprofile_nicshash) {
        my $value = $netprofile_nicshash{$_}{'type'};
        if (($value eq 'FSP') or ($value eq 'BMC')) {
            $nictype = $value;
        }
    }
    
    #Get hardwareprofile mgt
    my $nodehmtab = xCAT::Table->new('nodehm');
    my $mgtentry = $nodehmtab->getNodeAttribs($hardwareprofile, ['mgt']);  
    my $mgt = undef;
    $mgt = $mgtentry->{'mgt'} if ($mgtentry->{'mgt'});
    $nodehmtab->close();

    #Get hardwareprofile nodetype
    my $ppctab = xCAT::Table->new('ppc');
    my $ntentry = $ppctab->getNodeAttribs($hardwareprofile, ['nodetype']);
    my $nodetype = undef;
    $nodetype = $ntentry->{'nodetype'} if ($ntentry->{'nodetype'});
    $ppctab->close(); 
    
    # Checking whether netboot initrd image for Ubuntu ppc64
    # This image should be downloaded from internet
    if ($arch =~ /ppc64/i and $os =~ /ubuntu/i and !(-e "$pkgdir/install/netboot/initrd.gz")){
        return 0, "The netboot initrd is not found in $pkgdir/install/netboot, please download it firstly.";
    }
 
    # Check if exists provision network
    if (not ($installnic and exists $netprofile_nicshash{$installnic}{"network"})){
        return 0, "Provisioning network not defined for network profile."
    }

    # Remove check mechanism about arch and netboot attribute
    # Attribute 'neboot' will be generated based on arch, management method, os
    
    # Profile consistent keys, arch=>netboot,  mgt=>nictype
    #my $ppc_netboot = 'yaboot';
    #if( $os =~ /rhels7/ ){
    #    $ppc_netboot = 'grub2';
    #}
    #my %profile_dict = ('x86' => 'xnba','x86_64' => 'xnba', 'ppc64' => $ppc_netboot,
    #                    'ppc64el' => $ppc_netboot,
    #                    'fsp' => 'FSP', 'ipmi' => 'BMC');
    # Check if imageprofile is consistent with networkprofile
    #if ($profile_dict{$arch} ne $netboot) {
    #    return 0, "Imageprofile's arch is not consistent with networkprofile's netboot."
    #}
    
    # Check if networkprofile is consistent with hardwareprofile
    if (not $hardwareprofile) { # Not define hardwareprofile
        if (not $nictype) {  # Networkprofile is not fsp or bmc
            return 1, "";
        }elsif ($nictype eq 'FSP' or $nictype eq 'BMC') {
            return 0, "$nictype networkprofile must use with hardwareprofile.";
        }
    }
    
    my %mgt_dict = ('fsp' => 'FSP', 'ipmi' => 'BMC', 'kvm' => '');
       
    if ($mgt eq 'vm') {
        return 1, "";
    }
    
    if ($nodetype eq 'lpar') {
        if ($nictype) {
            # Can not associate FSP/BMC network if the node type is lpar
            return 0, "The node with hardware type $nodetype can not use with $nictype networkprofile.";
        }
        return 1, ""
    }
    
    if ($mgt and $mgt_dict{$mgt} ne $nictype) {
        my $errmsg = "$mgt hardwareprofile must use with $mgt_dict{$mgt} networkprofile.";
        if ( $mgt eq 'kvm' ) {
            $errmsg = "$mgt hardwareprofile must use with non-BMC and non-FSP networkprofile."
        }
        return 0, $errmsg;
    }
            
    return 1, "";
}

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

=head3 is_fsp_node
      Description : Judge whether nodes use fsp.
      Arguments   : $node - node name
      Returns     : 1 - Use fsp
                    0 - Not use fsp
=cut

#-------------------------------------------------------------------------------
sub is_fsp_node
{
    my $class = shift;
    my $node = shift;
    my $nicstab = xCAT::Table->new('nics');
    my $entry = $nicstab->getNodeAttribs($node, ['nictypes']);
    $nicstab->close();
 
    if ($entry->{'nictypes'}){
        my @nicattrslist = split(",", $entry->{'nictypes'});
        foreach (@nicattrslist){
			my @nicattrs;
			if ($_  =~ /!/) {
				@nicattrs = split("!", $_);
			} else {
				@nicattrs = split(":", $_);
			}
            if ($nicattrs[1] eq 'FSP'){
                return 1;
            }
        }
    }

    return 0;
}

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

=head3 is_kvm_node
      Description : Judge whether nodes are KVM nodes.
      Arguments   : $hardwareprofile - hardwareprofile name
      Returns     : 1 - KVM nodes
                    0 - Not KVM nodes
=cut

#-------------------------------------------------------------------------------
sub is_kvm_node
{
    my $class = shift;
    my $hardwareprofile = shift;
    
    if (not $hardwareprofile) {
        return 0;
    }
 
    #Get hardwareprofile mgt
    my $nodehmtab = xCAT::Table->new('nodehm');
    my $mgtentry = $nodehmtab->getNodeAttribs($hardwareprofile, ['mgt']);  
    my $mgt = undef;
    $mgt = $mgtentry->{'mgt'} if ($mgtentry->{'mgt'});
    $nodehmtab->close();
    
    if ($mgt eq 'kvm') {
        return 1;
    } 
    
    return 0;
}

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

=head3 is_kvm_hypv_node
      Description : Judge whether nodes are KVM nodes.
      Arguments   : $imageprofile - imageprofile name
      Returns     : 1 - KVM hypervisor nodes
                    0 - Not KVM hypervisor nodes
=cut

#-------------------------------------------------------------------------------
sub is_kvm_hypv_node
{
    my $class = shift;
    my $imageprofile = shift;
    
    # Get provmethod
    my $provmethod = xCAT::ProfiledNodeUtils->get_imageprofile_prov_method($imageprofile);
    unless ($provmethod ){
        return 0;
    }
    
    my $osimage_tab = xCAT::Table->new('osimage');
    my $osimage_tab_entry = $osimage_tab->getAttribs({'imagename'=> $provmethod},('osdistroname'));
    my $osdistroname = $osimage_tab_entry->{'osdistroname'};
    $osimage_tab->close();
    
    if ($osdistroname and $osdistroname =~ /^pkvm/ ) {
        return 1;
    }
    
    return 0;
}

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

=head3 get_nodes_cmm
      Description : Get the CMM of nodelist 
      Arguments   : $nodelist - the ref of node list array
      Returns     : $cmm - the ref of hash like
                    {
                      "cmm1" => 1,
                      "cmm2" => 1                          
                    }
=cut

#-------------------------------------------------------------------------------
sub get_nodes_cmm
{
    my $class = shift;
    my $nodelistref = shift;
    my @nodes = @$nodelistref;
    my %returncmm;
    
    my $mptab = xCAT::Table->new('mp');
    my $entry = $mptab->getNodesAttribs($nodelistref, ['mpa']);
    $mptab->close();
    
    foreach (@nodes) {
        my $mpa = $entry->{$_}->[0]->{'mpa'};
        if ($mpa and not exists $returncmm{$mpa}){
            $returncmm{$mpa} = 1;
        }
    }
    
    return \%returncmm
}

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

=head3 parse_nodeinfo_file
    Description: Parse node info file content. And put node info into 2 global
                 vals: @::profiledNodeObjNames and %::profiledNodeAttrs.
                 @::profiledNodeObjNames: recording all nodes' names.
                 %::profiledNodeAttrs: recording all nodes' attributes.
    Arguments: $filedata: node info file content string.
    Returns: ($retcode, $msgstr).
              $retcode = 1. Parse success, the format of this file is OK.
              $retcode = 0. Parse failed, there are some errors in this file.
                            Detailed errors will be set in $msgstr.
=cut

#-------------------------------------------------------------------------------
sub parse_nodeinfo_file
{
    my($class, $filedata) = @_;
    @::profiledNodeObjNames = ();
    %::profiledNodeAttrs = ();

    my @lines = split /\n/, $filedata;
    my $obj_found = 0;
    my $attr_found = 0;
    my $null_obj;
    my ($objname, $append);

    foreach my $line (@lines){
        # skip blank and comment lines
        next if ($line =~ /^\s*$/ || $line =~ /^\s*#/);

        # The line ends with :
        if (grep(/:\s*$/, $line)){
            $attr_found = 0;
            $null_obj = $line;
            ($objname, $append) = split(/:/, $line);
            $objname =~ s/^\s*//;    # Remove any leading whitespace
            $objname =~ s/\s*$//;    # Remove any trailing whitespace

            # OK we've found one object.
            if ($objname){
                $obj_found = 1;
                push(@::profiledNodeObjNames, $objname);
            }else{
                return 0, "No node name defined in line \'$line\'";
            }
        } # The line has =
        elsif (($line =~ /^\s*(.*?)\s*=\s*(.*)\s*/)){
            # No one object clarified yet. So this file format is illegal.
            if (! $obj_found){
                return 0, "No node defined before line \'$line\'";
            }
            $attr_found = 1;

            my $attr = $1;
            my $val  = $2;
            $attr =~ s/^\s*//;    # Remove any leading whitespace
            $attr =~ s/\s*$//;    # Remove any trailing whitespace
            $val  =~ s/^\s*//;
            $val  =~ s/\s*$//;

            # remove spaces and quotes
            $val =~ s/^\s*"\s*//;
            $val =~ s/\s*"\s*$//;

            if($attr && $val){
                $::profiledNodeAttrs{$objname}{$attr} = $val;
            }else{
                return 0, "Line \'$line\' does not contain a valid key and value";
            }

        } #invalid line.
        else{
            return 0, "Invalid Line \'$line\' found";
        }
    }
    
    # Defined object has no attributes
    if (! $attr_found){
        return 0, "Invalid Line \'$null_obj\' found";
    }
    
    return 1, "";
}

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

=head3  update the table prodkey, in order to support windows
        per node license key

    Returns: $retcode.
              $retcode = 1. update failed, the value is undef
              $retcode = 0. save into db is OK..
=cut
#-------------------------------------------------------

sub update_windows_prodkey
{
    my $class   = shift;
    my $node    = shift;
    my $product = shift;
    my $key     = shift;
    unless(defined($node) && defined($product) && defined($key))
    {
        return 1;
    }
    # please notice this db usage
    my %keyhash;
    my %updates;
    $keyhash{'node'}             = $node;
    $updates{'product'}          = $product;
    $updates{'key'}              = $key;
    my $tab = xCAT::Table->new('prodkey', -create=>1, -autocommit=>0);
    $tab->setAttribs( \%keyhash,\%updates );
    $tab->commit;
    $tab->close; 
    return 0;
}

#-------------------------------------------------------------------------------
=head3 check_nicips
    Description: Check if the nicips defined in MAC file is correct
                 format
    Arguments: $installnic: the installnic defined in networkprofile 
               $netprofileattrsref: the attributes of all nics in networkprofile
               $freeipshash:  the hash of networks' staticrange
               $nicips: the string of nicips defined in MAC file
    Returns: ($retcode, $output, $errmsg).
              $retcode = 1. Parse failed, there are some errors in nicips string. Detailed errors will be set in $errmsg.
              $retcode = 0. Parse success, the format of nicips is OK..

=cut
#-------------------------------------------------------------------------------
sub check_nicips{
    my $class = shift;
    my $installnic  = shift;
    my $netprofileattrsref = shift;
    my $freeipshash = shift;
    my $othernics = shift;
    
    my $errmsg = "";
    my %nics_hash = ();
    my %netprofileattr = %$netprofileattrsref;
    
    foreach my $nic_ips (split(/,/, $othernics)) {
        my @nic_and_ips = ();
        my $nic = "";
        my $nic_ip = "";
        if($nic_ips =~ /!/ and $nic_ips !~ /!$/) {
            @nic_and_ips = split(/!/, $nic_ips);
            my $len = @nic_and_ips;
            $nic = $nic_and_ips[0];
            $nic_ip = $nic_and_ips[1];
            
            if (exists $nics_hash{$nic} or $len ne 2) {
                $errmsg = "The specified nicips is incorrect. It must be formatted correctly, in the form: <nic1>!<nic-ip1>,<nic2>!<nic-ip2>,...";
                return (1, "", $errmsg);
            }
            
            # Check whether other interfaces contain provision nic
            if ($nic eq $installnic) {
                $errmsg = "The specified nicips cannot contain NICs used for provisioning.";
                return (1, "", $errmsg);
            }
            
            # Check whether this interface is defined in networkprofile
            unless (exists $netprofileattr{$nic}){
                $errmsg = "The specified nicips contains NICs that are not defined in the network profile.";
                return (1, "", $errmsg);
            }
 
            # Check whether specified IP is in each network's static range
            my $nicnetwork = $netprofileattr{$nic}{'network'};
            my $freeipsref = $freeipshash->{$nicnetwork};
            unless (grep{ $_ eq $nic_ip} @$freeipsref){
                $errmsg = "Specified IP address $nic_ip not in static range of network $netprofileattr{$nic}{'network'}";
                return (1, "", $errmsg);
            }
        }else {
            $errmsg = "The specified nicips is incorrect. It must be formatted correctly, in the form: <nic1>!<nic-ip1>,<nic2>!<nic-ip2>,...";
            return (1, "", $errmsg);
        }
        $nics_hash{$nic} = $nic_ip;
    }
    
    return (0, \%nics_hash, "");
}

#-------------------------------------------------------------------------------
=head3 gen_chain_for_profiles
    Description: Generate a chain string based on Network/Hardware/Image profiles.
    Arguments: $profiles_hash: The reference for profiles hash.
             For example: 
             $profiles_hash = { 'HardwareProfile' => 'IBM_NeXtScale_M4',
                                'ImageProfile' => 'rhels6.5-x86_64-stateful-compute',
                                'NetworkProfile' => 'default_network_profile',
                              }
             $hw_reconfig: the flag shows whether we need re-configure all hardware
                           relative settings or not: like runcmds, runimg...etc
    Returns: ($retcode, $chain)
              $retcode = 1. Generate chain failed, $chain stands for error message.
              $retcode = 0. Generate chain OK. $chain stands for the chain string.

=cut
#-------------------------------------------------------------------------------
sub gen_chain_for_profiles{
    my $class = shift;
    my $profiles_hashref = shift;
    my $hw_reconfig = shift;
    my $final_chain = "";
    if (! $profiles_hashref){
        return (1, "Missing parameter for gen_chain_for_profiles.");
    }
    # A node must have at least imageprofile and network profile.
    unless (defined $profiles_hashref->{'ImageProfile'}){
        return (1, "No imageprofile specified in profiles hash.");
    }
    unless (defined $profiles_hashref->{'NetworkProfile'}){
        return (1, "No networkprofile specified in profiles hash.");
    }
    my $hwprofile = $profiles_hashref->{'HardwareProfile'};
    my $imgprofile = $profiles_hashref->{'ImageProfile'};
    my $netprofile = $profiles_hashref->{'NetworkProfile'};

    # Get node's provisioning method
    my $provmethod = xCAT::ProfiledNodeUtils->get_imageprofile_prov_method($imgprofile);
    unless ($provmethod ){
        return (1, "Can not get provisioning method for image profile $imgprofile");
    }
    my $netprofileattr = xCAT::ProfiledNodeUtils->get_nodes_nic_attrs([$netprofile])->{$netprofile};
    unless ($netprofileattr){
        return (1, "Can not get attributes for network profile $netprofile");
    }
    
    # Get node's netboot attribute
    my ($retcode, $retval) = xCAT::ProfiledNodeUtils->get_netboot_attr($imgprofile, $hwprofile);
    if (not $retcode) {
        return (1, $retval);
    }
    my $netboot = $retval;

    $final_chain = 'osimage='.$provmethod.":--noupdateinitrd";
    # get the chain attribute from hardwareprofile and insert it to node.
    if (defined $hwprofile and $hwprofile and $hw_reconfig){
        my $chaintab = xCAT::Table->new('chain');
        my $chain = $chaintab->getNodeAttribs($hwprofile, ['chain']);
        if (exists $chain->{'chain'}) {
               my $hw_chain = $chain->{'chain'};
               $final_chain = $hw_chain.',osimage='.$provmethod.":--noupdateinitrd";
        }
    }
    #run bmcsetups.
    #PowerNV nodes can't use 'runcmd=bmcsetup' to set BMC.
    if ((exists $netprofileattr->{"bmc"}) and $hw_reconfig and $netboot ne 'petitboot'){ 
        if (index($final_chain, "runcmd=bmcsetup") == -1){
            $final_chain = 'runcmd=bmcsetup,'.$final_chain.':reboot4deploy';
        }
        else{
            $final_chain = $final_chain.':reboot4deploy';
        }
    }
    return (0, $final_chain);
}

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

=head3 get_all_vmhosts
      Description : Get all vm hosts/hypervisor from DB. 
      Arguments   : N/A
      Returns     : ref for vm hosts/hypervisor hash.
      Example     : 
                    my $hashref = xCAT::ProfiledNodeUtils->get_all_vmhosts();
=cut

#-------------------------------------------------------------------------------
sub get_all_vmhosts
{
    my %vmhostshash;

    my $nodelisttab = xCAT::Table->new('nodelist');
    # groups like '__Hypervisor_pkvm' means this node is Power KVM hypervisor
    my @vmhosts = $nodelisttab->getAllAttribsWhere("groups like '%__Hypervisor_kvm%'", 'node');
    foreach (@vmhosts) {
        if($_->{'node'}) {
            $vmhostshash{$_->{'node'}} = 1;
        }
    }
    $nodelisttab->close();

    # Return the ref accordingly 
    return \%vmhostshash;
}

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

=head3 get_netboot_attr
      Description : Get netboot attribute for node
      Arguments   : $imageprofile - image profile name, mandatory. e.g. "__ImageProfile_rhels7.0-x86_64-stateful-mgmtnode"
                    $hardwareprofile - harware profile name, optional. e.g. "__HardwareProfile_IBM_System_x_M4"
      Returns     : (returncode, netboot)
                    returncode=0 - can not get netboot value,netboot is the error message
                    returncode=1 - can get netboot value,netboot is the right value
=cut

#-------------------------------------------------------------------------------
sub get_netboot_attr{
    my $class = shift;
    my $imageprofile = shift;
    my $hardwareprofile = shift;
    my $netboot;

    my @nodegrps = xCAT::TableUtils->list_all_node_groups();
    unless(grep{ $_ eq $imageprofile} @nodegrps)
    {
        return 0, "Image profile not defined in DB."
    }
    $imageprofile =~ s/^__ImageProfile_//;

    if ($hardwareprofile){
        unless(grep{ $_ eq $hardwareprofile} @nodegrps)
        {
            return 0, "Hardware profile not defined in DB."
        }
    }
    else
    {
        $hardwareprofile = '*';
    }

    # Get os name, os major version, osarch
    my $osimage_tab = xCAT::Table->new('osimage');
    my $osimage_tab_entry = $osimage_tab->getAttribs({'imagename'=> $imageprofile},('osdistroname'));
    my $osdistroname = $osimage_tab_entry->{'osdistroname'};
    $osimage_tab->close();

    my $osdistro_tab = xCAT::Table->new('osdistro');
    my $osdistro_tab_entry = $osdistro_tab->getAttribs({'osdistroname'=> $osdistroname},('basename', 'majorversion', 'arch'));
    my $os_name = $osdistro_tab_entry->{'basename'};
    my $os_major_version = $osdistro_tab_entry->{'majorversion'};
    my $os_arch = $osdistro_tab_entry->{'arch'};
    $osdistro_tab->close;

    # Treate os name rhel,centos,rhelhpc same as rhels
    if ($os_name eq 'centos' || $os_name eq 'rhelhpc' || $os_name eq 'rhel')
    {
        $os_name = 'rhels';
    }
    # Treate arch ppc64el same as ppc64le,x86 same as x86_64
    if ($os_arch eq 'ppc64el')
    {
        $os_arch = 'ppc64le';
    }elsif ($os_arch eq 'x86')
    {
        $os_arch = 'x86_64';
    }
    
    # Identify whether this node is PowerKVM or PowerNV if os arch is ppc64le
    # If hardware profile is defined 
    my $mgt = '*';
    if ($os_arch eq 'ppc64le' and $hardwareprofile ne '*') {
        my $nodehmtab = xCAT::Table->new('nodehm');
        my $nodehmtab_entry = $nodehmtab->getNodeAttribs($hardwareprofile, ['mgt']);
        if (defined $nodehmtab_entry->{'mgt'}) {
            $mgt = $nodehmtab_entry->{'mgt'};
        }
    }
    

# Rule for netboot attribute.If update the rule,just update %netboot_dict and @condition_array
# It's sequence sensitive: os arch -> os name -> os major version -> hardware profile
# Priority |  Arch       | OS Name | OS Major Version | Management method | Noderes.netboot  |
# 1        |  x86_64/x86 | *       | *                | *                 | xnba             |
# 2        |  ppc64      | rhels   | 7                | *                 | grub2            |
# 2        |  ppc64      | pkvm    | *                | *                 | petitboot        |
# 3        |             | *       | *                | *                 | yaboot           |
# 4        |  ppc64le/el | *       | *                | *                 | grub2
# 4        |  ppc64le/el | *       | *                | ipmi              | petitboot
#          arch          osname       version  hardware           netboot
    my %netboot_dict = ( 'x86_64'                                             => 'xnba', 
                         'ppc64'   => { 
                                        'rhels' => { 
                                                     '7'                      => 'grub2', 
                                                     '*'                      => 'yaboot',
                                                   }, 
                                        'pkvm'                                => 'petitboot',
                                        '*'                                   => 'yaboot', 
                                      },                                  
                         'ppc64le' => {
                                        '*'    =>  { 
                                                     '*' => { 
                                                              '*'    => 'grub2',
                                                              'ipmi' => 'petitboot',
                                                            },
                                                   },
                                      },
                       );
    my $condition_array_ref = [$os_arch, $os_name, $os_major_version, $mgt];
    $netboot = cal_netboot(\%netboot_dict, $condition_array_ref);
    if($netboot eq '0')
    {
        return 0, "Can not get the netboot attribute";
    }
    else
    {    
        return 1, $netboot;
    }
}
#-------------------------------------------------------------------------------

=head3 cal_netboot
      Description : Calculate netboot attribute by conditions recursively, internal use.
      Arguments   : $netboot_dict_ref
                    $condition_array_ref
      Returns     : netboot
                    returncode=0 - can not get netboot value
=cut

#-------------------------------------------------------------------------------
sub cal_netboot{
    my $netboot_dict_ref = shift;
    my $condition_array_ref = shift;
    my $condition_array_len = scalar @$condition_array_ref;
    
    if( $condition_array_len == 0 ){
        return 0;
    }

    my $condition = shift @$condition_array_ref;
    if( (exists($netboot_dict_ref->{$condition})) || (exists($netboot_dict_ref->{'*'})) )
    {
        if(!exists($netboot_dict_ref->{$condition}))
        {
            $condition = '*';
        }
        if(ref($netboot_dict_ref->{$condition}) eq 'HASH')
        {
            if($condition_array_len > 1)
            {
                return cal_netboot($netboot_dict_ref->{$condition}, $condition_array_ref);
            }
            else
            {
                return 0;
            }
        }
        else
        {
            return $netboot_dict_ref->{$condition};
        }
    }
    else
    {
        return 0;
    }
}