ce4e807a04
git-svn-id: https://svn.code.sf.net/p/xcat/code/xcat-core/trunk@15782 8638fb3e-16cb-4fca-ae20-7b5d299a9bcd
2763 lines
96 KiB
Perl
2763 lines
96 KiB
Perl
#!/usr/bin/env perl -w
|
|
# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
|
|
|
|
#####################################################
|
|
#
|
|
# Utility subroutines that can be used to manage xCAT data object
|
|
# definitions.
|
|
#
|
|
#
|
|
#####################################################
|
|
package xCAT::DBobjUtils;
|
|
|
|
require xCAT::NodeRange;
|
|
require xCAT::Schema;
|
|
require xCAT::Table;
|
|
require xCAT::Utils;
|
|
require xCAT::MsgUtils;
|
|
require xCAT::NetworkUtils;
|
|
require xCAT::ServiceNodeUtils;
|
|
use strict;
|
|
|
|
# IPv6 not yet implemented - need Socket6
|
|
use Socket;
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 getObjectsOfType
|
|
|
|
Get a list of data objects of the given type.
|
|
|
|
Arguments:
|
|
Returns:
|
|
undef
|
|
@objlist - list of objects of this type
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
Comments:
|
|
|
|
@objlist = xCAT::DBobjUtils->getObjectsOfType($type);
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub getObjectsOfType
|
|
{
|
|
my ($class, $type) = @_;
|
|
|
|
my @objlist;
|
|
|
|
# special case for site table
|
|
if ($type eq 'site')
|
|
{
|
|
push(@objlist, 'clustersite');
|
|
return @objlist;
|
|
}
|
|
|
|
# The database may be changed between getObjectsOfType calls
|
|
# do not use cache %::saveObjList if --nocache is specified
|
|
if ($::saveObjList{$type} && !$::opt_c)
|
|
{
|
|
@objlist = @{$::saveObjList{$type}};
|
|
}
|
|
else
|
|
{
|
|
|
|
# get the key for this type object
|
|
# ex. for "network" type the key is "netname"
|
|
# get the data type spec from Schema.pm
|
|
my $datatype = $xCAT::Schema::defspec{$type};
|
|
|
|
# get the key for this type object
|
|
# ex. for "network" type the key is "netname"
|
|
my $objkey = $datatype->{'objkey'};
|
|
|
|
my $table;
|
|
my $tabkey;
|
|
foreach my $this_attr (@{$datatype->{'attrs'}})
|
|
{
|
|
my $attr = $this_attr->{attr_name};
|
|
if ($attr eq $objkey)
|
|
{
|
|
# get the table & key for to lookup
|
|
# get the actual attr name to use in the table
|
|
# - may be different then the attr name used for the object.
|
|
($table, $tabkey) = split('\.', $this_attr->{tabentry});
|
|
last;
|
|
}
|
|
}
|
|
|
|
# get the whole table and add each entry in the objkey column
|
|
# to the list of objects.
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable($table);
|
|
|
|
foreach (@TableRowArray)
|
|
{
|
|
push(@objlist, $_->{$tabkey});
|
|
|
|
}
|
|
|
|
# if this is type "group" we need to check the nodelist table
|
|
my @nodeGroupList=();
|
|
if ($type eq 'group')
|
|
{
|
|
my $table = "nodelist";
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable($table);
|
|
foreach (@TableRowArray)
|
|
{
|
|
my @tmplist = split(',', $_->{'groups'});
|
|
push(@nodeGroupList, @tmplist);
|
|
}
|
|
foreach my $n (@nodeGroupList)
|
|
{
|
|
if (!grep(/^$n$/, @objlist) ) {
|
|
push(@objlist, $n);
|
|
}
|
|
}
|
|
}
|
|
|
|
@{$::saveObjList{$type}} = @objlist;
|
|
}
|
|
|
|
return @objlist;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 getobjattrs
|
|
|
|
Get data from tables
|
|
|
|
$type_hash: objectname=>objtype hash
|
|
$attrs_ref: only get the specific attributes,
|
|
this can be useful especially for performance considerations
|
|
Arguments:
|
|
Returns:
|
|
undef
|
|
hash ref - (ex. $tabhash{$table}{$objname}{$attr} = $value)
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
%tabhash = xCAT::DBobjUtils->getobjattrs(\%typehash);
|
|
|
|
Comments:
|
|
For now - only support tables that have 'node' as key !!!
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub getobjattrs
|
|
{
|
|
my $class = shift;
|
|
my $ref_hash = shift;
|
|
my @attrs;
|
|
# The $attrs is an optional argument
|
|
if (ref $_[0]) {
|
|
@attrs = @{shift()};
|
|
}
|
|
my %typehash = %$ref_hash;
|
|
|
|
my %tableattrs;
|
|
my %tabhash;
|
|
|
|
# get a list of object names for each type
|
|
my %objtypelist;
|
|
foreach my $objname (sort (keys %typehash)) {
|
|
# get list of objects for each type
|
|
# $objtypelist{$typehash{$objname}}=$objname;
|
|
push @{$objtypelist{$typehash{$objname}}}, $objname;
|
|
}
|
|
|
|
# go through each object type and look up all the info for each object
|
|
foreach my $objtype (keys %objtypelist) {
|
|
|
|
# only do node type for now
|
|
if ($objtype eq 'node') {
|
|
# find the list of tables and corresponding attrs
|
|
# - for this object type
|
|
# get the object type decription from Schema.pm
|
|
my $datatype = $xCAT::Schema::defspec{$objtype};
|
|
foreach my $this_attr (@{$datatype->{'attrs'}}) {
|
|
my $attr = $this_attr->{attr_name};
|
|
if (scalar(@attrs) > 0) { # Only query specific attributes
|
|
if (!grep(/^$attr$/, @attrs)) {
|
|
next; # This attribute is not needed
|
|
}
|
|
}
|
|
|
|
# table_attr is the attr that actually appears in the
|
|
# table which could possibly be different then the attr
|
|
# used in the node def
|
|
# ex. 'nodetype.arch'
|
|
my ($lookup_table, $table_attr) = split('\.', $this_attr->{tabentry});
|
|
if (!grep(/^$table_attr$/, @{$tableattrs{$lookup_table}})) {
|
|
push @{$tableattrs{$lookup_table}}, $table_attr;
|
|
}
|
|
}
|
|
|
|
# foreach table look up the list of attrs for this
|
|
# list of object names
|
|
foreach my $table (keys %tableattrs) {
|
|
# open the table
|
|
my $thistable = xCAT::Table->new($table, -create => 1, -autocommit => 0);
|
|
if (!$thistable) {
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "Could not open the \'$table\' table.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
next;
|
|
}
|
|
|
|
my @objlist = @{$objtypelist{$objtype}};
|
|
|
|
my $rec = $thistable->getNodesAttribs(\@objlist, @{$tableattrs{$table}});
|
|
|
|
# fill in %tabhash with any values that are set
|
|
foreach my $n (@objlist) {
|
|
my $tmp1=$rec->{$n}->[0];
|
|
foreach $a (@{$tableattrs{$table}}) {
|
|
if (defined($tmp1->{$a})) {
|
|
$tabhash{$table}{$n}{$a} = $tmp1->{$a};
|
|
#print "obj = $n, table = $table, attr =$a, val = $tabhash{$table}{$n}{$a}\n";
|
|
} else {
|
|
# Add a has been searched flag to improve the performance
|
|
$tabhash{$table}{$n}{"$a"."_hassearched"} = 1;
|
|
}
|
|
}
|
|
}
|
|
#$thistable->commit;
|
|
}
|
|
}
|
|
}
|
|
return %tabhash;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 getobjdefs
|
|
|
|
Get object definitions from the DB.
|
|
|
|
$type_hash: objectname=>objtype hash
|
|
$verbose: optional
|
|
$attrs_ref: only get the specific attributes,
|
|
this can be useful especially for performance considerations
|
|
$chname_ref: used to get the table entries for changing the object name
|
|
Arguments:
|
|
Returns:
|
|
undef - error
|
|
hash ref - $objecthash{objectname}{attrname} = value
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
To use create hash for objectname and object type
|
|
ex. $objhash{$obj} = $type;
|
|
|
|
- then call as follows:
|
|
%myhash = xCAT::DBobjUtils->getobjdefs(\%objhash);
|
|
|
|
Comments:
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub getobjdefs
|
|
{
|
|
my ($class, $hash_ref, $verbose, $attrs_ref, $chname_ref) = @_;
|
|
my %objhash;
|
|
my %typehash = %$hash_ref;
|
|
my %tabhash;
|
|
my @attrs;
|
|
if (ref($attrs_ref))
|
|
{
|
|
@attrs = @$attrs_ref;
|
|
}
|
|
|
|
@::foundTableList = ();
|
|
|
|
if ($::ATTRLIST eq "none") {
|
|
# just return the list of obj names
|
|
foreach my $objname (sort (keys %typehash))
|
|
{
|
|
my $type = $typehash{$objname};
|
|
$objhash{$objname}{'objtype'} = $type;
|
|
}
|
|
return %objhash;
|
|
}
|
|
|
|
# see if we need to get any objects of type 'node'
|
|
my $getnodes=0;
|
|
foreach my $objname (keys %typehash) {
|
|
if ($typehash{$objname} eq 'node') {
|
|
$getnodes=1;
|
|
}
|
|
}
|
|
|
|
# if so then get node info from tables now
|
|
# still may need to look up values in some tables using
|
|
# other keys - also need to figure out what tables to take
|
|
# values from when using 'only_if' - see below
|
|
# - but this saves lots of time
|
|
if ($getnodes) {
|
|
if (scalar(@attrs) > 0) # Only get specific attributes of the node
|
|
{
|
|
# find the onlyif key for the attributes
|
|
REDO: my $datatype = $xCAT::Schema::defspec{'node'};
|
|
foreach my $this_attr (@{$datatype->{'attrs'}}) {
|
|
my $attr = $this_attr->{attr_name};
|
|
if (exists($this_attr->{only_if})) {
|
|
my ($onlyif_key, $onlyif_value) = split('\=', $this_attr->{only_if});
|
|
if (!grep (/^$onlyif_key$/, @attrs)) {
|
|
push @attrs, $onlyif_key;
|
|
goto REDO;
|
|
}
|
|
}
|
|
}
|
|
%tabhash = xCAT::DBobjUtils->getobjattrs(\%typehash, \@attrs);
|
|
}
|
|
else
|
|
{
|
|
%tabhash = xCAT::DBobjUtils->getobjattrs(\%typehash);
|
|
}
|
|
}
|
|
|
|
# Classify the nodes with type
|
|
my %type_obj = ();
|
|
foreach my $objname (keys %typehash) {
|
|
push @{$type_obj{$typehash{$objname}}}, $objname;
|
|
}
|
|
|
|
foreach my $objtype (sort (keys %type_obj)) {
|
|
if ($objtype eq 'site') {
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable('site');
|
|
foreach my $objname (sort @{$type_obj{$objtype}}) {
|
|
if (@TableRowArray)
|
|
{
|
|
my $foundinfo = 0;
|
|
foreach (@TableRowArray)
|
|
{
|
|
if ($_->{key})
|
|
{
|
|
if (defined($_->{value}) ) {
|
|
$foundinfo++;
|
|
if ($verbose == 1) {
|
|
$objhash{$objname}{$_->{key}} = "$_->{value}\t(Table:site - Key:$_->{key})";
|
|
} else {
|
|
$objhash{$objname}{$_->{key}} = $_->{value};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ($foundinfo)
|
|
{
|
|
$objhash{$objname}{'objtype'} = 'site';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] ="Could not read the \'$objname\' object from the \'site\' table.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
}
|
|
}
|
|
} elsif ($objtype eq 'monitoring') {
|
|
# need a special case for the monitoring table
|
|
# - need to check the monsetting table for entries that contain
|
|
# the same name as the monitoring table entry.
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable('monsetting');
|
|
foreach my $objname (sort @{$type_obj{$objtype}}) {
|
|
if (@TableRowArray) {
|
|
my $foundinfo = 0;
|
|
foreach (@TableRowArray) {
|
|
if ($_->{name} eq $objname ) {
|
|
if ($_->{key})
|
|
{
|
|
if (defined($_->{value}) ) {
|
|
$foundinfo++;
|
|
if ($verbose == 1) {
|
|
$objhash{$objname}{$_->{key}} = "$_->{value}\t(Table:monsetting)";
|
|
} else {
|
|
$objhash{$objname}{$_->{key}} = $_->{value};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ($foundinfo)
|
|
{
|
|
$objhash{$objname}{'objtype'} = 'monitoring';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] ="Could not read the \'$objname\' object from the \'monsetting\' table.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
}
|
|
}
|
|
} elsif (($objtype eq 'auditlog') || ($objtype eq 'eventlog')) {
|
|
# Special case for auditlog/eventlog
|
|
# All the auditlog/eventlog attributes are in auditlog/eventlog table,
|
|
# Do not need to read the table multiple times for each attribute.
|
|
# The auditlog/eventlog is likely be very big over time,
|
|
# performance is a big concern with the general logic
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable($objtype);
|
|
foreach my $objname (sort @{$type_obj{$objtype}}) {
|
|
if (@TableRowArray)
|
|
{
|
|
my $foundinfo = 0;
|
|
foreach my $entry (@TableRowArray)
|
|
{
|
|
if ($entry->{recid} eq $objname)
|
|
{
|
|
foreach my $k (keys %{$entry})
|
|
{
|
|
# recid is the object name, do not need to be in the attributes list
|
|
if ($k eq 'recid') { next; }
|
|
if (defined($entry->{$k}) ) {
|
|
$foundinfo++;
|
|
if ($verbose == 1) {
|
|
$objhash{$objname}{$k} = "$entry->{$k}\t(Table:$objtype - Key:$k)";
|
|
} else {
|
|
$objhash{$objname}{$k} = $entry->{$k};
|
|
}
|
|
}
|
|
}
|
|
if ($foundinfo)
|
|
{
|
|
$objhash{$objname}{'objtype'} = $objtype;
|
|
}
|
|
# There should not be multiple entries with the same recid
|
|
last;
|
|
} # end if($entry->
|
|
} # end foreach my $entry
|
|
} # end if(@TableTowArray
|
|
} # end foreach my $objname
|
|
} else {
|
|
# get the object type decription from Schema.pm
|
|
my $datatype = $xCAT::Schema::defspec{$objtype};
|
|
# get the key to look for, for this object type
|
|
my $objkey = $datatype->{'objkey'};
|
|
|
|
# go through the list of valid attrs
|
|
foreach my $this_attr (@{$datatype->{'attrs'}})
|
|
{
|
|
my $ent;
|
|
my $attr = $this_attr->{attr_name};
|
|
|
|
# skip the key attr ???
|
|
if ($attr eq $objkey)
|
|
{
|
|
next;
|
|
}
|
|
# skip the attributes that does not needed for node type
|
|
if ($getnodes) {
|
|
if (scalar(@attrs) > 0 && !grep(/^$attr$/, @attrs)) {
|
|
next;
|
|
}
|
|
}
|
|
|
|
# OK - get the info needed to access the DB table
|
|
# - i.e. table name, key name, attr names
|
|
|
|
# need the actual table attr name corresponding
|
|
# to the object attr name
|
|
# ex. noderes.nfsdir
|
|
my ($tab, $tabattr) = split('\.', $this_attr->{tabentry});
|
|
|
|
foreach my $objname (sort @{$type_obj{$objtype}}) {
|
|
# get table lookup info from Schema.pm
|
|
# !!!! some tables depend on the value of certain attrs
|
|
# we need to look up attrs in the correct order or we will
|
|
# not be able to determine what tables to look
|
|
# in for some attrs.
|
|
if (exists($this_attr->{only_if}))
|
|
{
|
|
my ($check_attr, $check_value) = split('\=', $this_attr->{only_if});
|
|
# if the object value is not the value we need
|
|
# to match then try the next only_if value
|
|
next if ( !($objhash{$objname}{$check_attr} =~ /\b$check_value\b/) );
|
|
}
|
|
|
|
|
|
$objhash{$objname}{'objtype'} = $objtype;
|
|
my %tabentry = ();
|
|
# def commands need to support multiple keys in one table
|
|
# the subroutine parse_access_tabentry is used for supporting multiple keys
|
|
my $rc = xCAT::DBobjUtils->parse_access_tabentry($objname,
|
|
$this_attr->{access_tabentry}, \%tabentry);
|
|
if ($rc != 0)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"access_tabentry \'$this_attr->{access_tabentry}\' is not valid.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
next;
|
|
}
|
|
#
|
|
# Only allow one table in the access_tabentry
|
|
# use multiple tables to look up tabentry does not make any sense
|
|
my $lookup_table = $tabentry{'lookup_table'};
|
|
my $intabhash = 0;
|
|
my $notsearched = 0;
|
|
foreach my $lookup_attr (keys %{$tabentry{'lookup_attrs'}})
|
|
{
|
|
# Check whether the attribute is already in %tabhash
|
|
# The %tabhash is for performance considerations
|
|
if ( ($lookup_attr eq 'node') && ($objtype eq 'node') ){
|
|
if (defined($tabhash{$lookup_table}{$objname}{$tabattr})) {
|
|
if ($verbose == 1)
|
|
{
|
|
$objhash{$objname}{$attr} = "$tabhash{$lookup_table}{$objname}{$tabattr}\t(Table:$lookup_table - Key:$lookup_attr - Column:$tabattr)";
|
|
}
|
|
else
|
|
{
|
|
$objhash{$objname}{$attr} = $tabhash{$lookup_table}{$objname}{$tabattr};
|
|
}
|
|
if (defined $chname_ref) {
|
|
push @{$chname_ref->{$lookup_table}}, ($tabentry{'lookup_attrs'}, $lookup_attr);
|
|
}
|
|
$intabhash = 1;
|
|
last;
|
|
} elsif (! defined($tabhash{$lookup_table}{$objname}{"$tabattr"."_hassearched"})) {
|
|
$notsearched = 1;
|
|
}
|
|
} else {
|
|
$notsearched = 1;
|
|
}
|
|
}
|
|
|
|
# Not in tabhash,
|
|
# Need to lookup the table
|
|
if ($intabhash == 0 && $notsearched == 1)
|
|
{
|
|
# look up attr values
|
|
my @rows = xCAT::DBobjUtils->getDBtable($lookup_table);
|
|
if (@rows)
|
|
{
|
|
foreach my $rowent (@rows)
|
|
{
|
|
my $match = 1;
|
|
my $matchedattr;
|
|
# Again, multiple keys support needs the "foreach"
|
|
foreach my $lookup_attr (keys %{$tabentry{'lookup_attrs'}})
|
|
{
|
|
if ($rowent->{$lookup_attr} ne $tabentry{'lookup_attrs'}{$lookup_attr})
|
|
{
|
|
$match = 0;
|
|
last;
|
|
}
|
|
}
|
|
if ($match == 1)
|
|
{
|
|
if ($verbose == 1)
|
|
{
|
|
my @lookup_attrs = keys %{$tabentry{'lookup_attrs'}};
|
|
$objhash{$objname}{$attr} = "$rowent->{$tabattr}\t(Table:$lookup_table - Key: @lookup_attrs - Column:$tabattr)";
|
|
}
|
|
else
|
|
{
|
|
$objhash{$objname}{$attr} = $rowent->{$tabattr};
|
|
}
|
|
if (defined $chname_ref) {
|
|
push @{$chname_ref->{$lookup_table}}, ($tabentry{'lookup_attrs'}, (keys %{$tabentry{'lookup_attrs'}}) [0]);
|
|
}
|
|
} #end if ($match...
|
|
} #end foreach
|
|
} # end if (defined...
|
|
} #end if ($intabhash...
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
} #foreach my $objtype
|
|
|
|
return %objhash;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 getDBtable
|
|
|
|
Get a DB table, cache it , & return list of rows from the table.
|
|
|
|
Arguments:
|
|
Returns:
|
|
undef - error
|
|
@rows - of table
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
call as follows
|
|
my @TableRowArray= xCAT::DBobjUtils->getDBtable($tablename);
|
|
|
|
Comments:
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub getDBtable
|
|
{
|
|
my ($class, $table) = @_;
|
|
my @rows = [];
|
|
|
|
# save this table info - in case this subr gets called multiple times
|
|
# --nocache flag specifies not to use cahe
|
|
if (grep(/^$table$/, @::foundTableList) && !$::opt_c)
|
|
{
|
|
|
|
# already have this
|
|
@rows = @{$::TableHash{$table}};
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
# need to get info from DB
|
|
my $thistable = xCAT::Table->new($table, -create => 1, -autocommit => 0);
|
|
if (!$thistable)
|
|
{
|
|
return undef;
|
|
}
|
|
|
|
#@rows = $thistable->getTable;
|
|
@rows = @{$thistable->getAllEntries()};
|
|
|
|
# !!!! this routine returns rows even if the table is empty!!!!!!
|
|
|
|
# keep track of the fact that we checked this table
|
|
# - even if it's empty!
|
|
push(@::foundTableList, $thistable->{tabname});
|
|
|
|
@{$::TableHash{$table}} = @rows;
|
|
|
|
#$thistable->commit;
|
|
|
|
} # end if not cached
|
|
|
|
if (@rows)
|
|
{
|
|
return @rows;
|
|
}
|
|
else
|
|
{
|
|
return undef;
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 setobjdefs
|
|
|
|
Set the object definitions in the DB.
|
|
- Handles the Schema lookup and updating the DB tables.
|
|
|
|
Arguments:
|
|
Returns:
|
|
1 - error
|
|
0 - OK
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
To use:
|
|
-create hash for objectname and object type
|
|
ex. $objhash{$object}{$attribute} = value;
|
|
|
|
-then call as follows:
|
|
if (xCAT::DBobjUtils->setobjdefs(\%objhash) != 0)
|
|
|
|
Comments:
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub setobjdefs
|
|
{
|
|
my ($class, $hash_ref) = @_;
|
|
my %objhash = %$hash_ref;
|
|
my %settableref;
|
|
my $ret = 0;
|
|
my %allupdates;
|
|
my $setattrs=0;
|
|
|
|
# get the attr=vals for these objects from the DB - if any
|
|
# - so we can figure out where to put additional attrs
|
|
# The getobjdefs call was in the foreach loop,
|
|
# it caused mkdef/chdef performance issue,
|
|
# so it is moved out of the foreach loop
|
|
|
|
my %DBhash;
|
|
my @attrs;
|
|
foreach my $objname (keys %objhash)
|
|
{
|
|
my $type = $objhash{$objname}{objtype};
|
|
$DBhash{$objname} = $type;
|
|
@attrs = keys %{$objhash{$objname}};
|
|
}
|
|
|
|
my %DBattrvals;
|
|
%DBattrvals = xCAT::DBobjUtils->getobjdefs(\%DBhash, 0, \@attrs);
|
|
|
|
# for each object figure out:
|
|
# - what tables to update
|
|
# - which table attrs correspond to which object attrs
|
|
# - what the keys are for each table
|
|
# update the tables a row at a time
|
|
foreach my $objname (keys %objhash)
|
|
{
|
|
|
|
# get attr=val that are set in the DB ??
|
|
my $type = $objhash{$objname}{objtype};
|
|
|
|
# handle the monitoring table as a special case !!!!!
|
|
if ($type eq 'monitoring')
|
|
{
|
|
|
|
# Get the names of the attrs stored in monitoring table
|
|
# get the object type decription from Schema.pm
|
|
my $datatype = $xCAT::Schema::defspec{$type};
|
|
|
|
# get a list of valid attr names
|
|
# for this type object
|
|
my @attrlist;
|
|
foreach my $entry (@{$datatype->{'attrs'}})
|
|
{
|
|
push(@attrlist, $entry->{'attr_name'});
|
|
}
|
|
|
|
# open the tables (monitoring and monsetting)
|
|
my $montable = xCAT::Table->new('monitoring', -create => 1, -autocommit => 0);
|
|
if (!$montable)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "Could not set the \'$montable\' table.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
return 1;
|
|
}
|
|
# open the table
|
|
my $monsettable = xCAT::Table->new('monsetting', -create => 1, -autocommit => 0);
|
|
if (!$monsettable)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "Could not set the \'$monsettable\' table.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
return 1;
|
|
}
|
|
|
|
my %keyhash;
|
|
my %updates;
|
|
|
|
foreach my $attr (keys %{$objhash{$objname}})
|
|
{
|
|
my $val;
|
|
if ($attr eq 'objtype')
|
|
{
|
|
next;
|
|
}
|
|
|
|
# determine the value if we have plus or minus
|
|
if ($::plus_option)
|
|
{
|
|
# add new to existing - at the end - comma separated
|
|
if (defined($DBattrvals{$objname}{$attr}))
|
|
{
|
|
$val = "$DBattrvals{$objname}{$attr},$objhash{$objname}{$attr}";
|
|
}
|
|
else
|
|
{
|
|
$val = "$objhash{$objname}{$attr}";
|
|
}
|
|
}
|
|
elsif ($::minus_option)
|
|
{
|
|
# remove the specified list of values from the current
|
|
# attr values.
|
|
if ($DBattrvals{$objname}{$attr})
|
|
{
|
|
# get the list of attrs to remove
|
|
my @currentList = split(/,/, $DBattrvals{$objname}{$attr});
|
|
my @minusList = split(/,/, $objhash{$objname}{$attr});
|
|
|
|
# make a new list without the one specified
|
|
my $first = 1;
|
|
my $newlist;
|
|
foreach my $i (@currentList)
|
|
{
|
|
chomp $i;
|
|
if (!grep(/^$i$/, @minusList))
|
|
{
|
|
# set new groups list for node
|
|
if (!$first)
|
|
{
|
|
$newlist .= ",";
|
|
}
|
|
$newlist .= $i;
|
|
$first = 0;
|
|
}
|
|
}
|
|
$val = $newlist;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#just set the attr to what was provided! - replace
|
|
$val = $objhash{$objname}{$attr};
|
|
}
|
|
|
|
if (grep(/^$attr$/, @attrlist)) {
|
|
# if the attr belong in the monitoring tabel
|
|
%keyhash=(name=>$objname);
|
|
%updates=($attr=>$val);
|
|
$montable->setAttribs(\%keyhash, \%updates);
|
|
} else {
|
|
# else it belongs in the monsetting table
|
|
$keyhash{name} = $objname;
|
|
$keyhash{key} = $attr;
|
|
$updates{value} = $val;
|
|
$monsettable->setAttribs(\%keyhash, \%updates);
|
|
}
|
|
}
|
|
|
|
$montable->commit;
|
|
$monsettable->commit;
|
|
next;
|
|
} #if ($type eq 'monitoring')
|
|
|
|
# handle the site table as a special case !!!!!
|
|
if ($type eq 'site')
|
|
{
|
|
# open the table
|
|
my $thistable =
|
|
xCAT::Table->new('site', -create => 1, -autocommit => 0);
|
|
if (!$thistable)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "Could not set the \'$thistable\' table.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
return 1;
|
|
}
|
|
|
|
foreach my $attr (keys %{$objhash{$objname}})
|
|
{
|
|
if ($attr eq 'objtype')
|
|
{
|
|
next;
|
|
}
|
|
|
|
my %keyhash;
|
|
$keyhash{key} = $attr;
|
|
|
|
my $val;
|
|
if ($::plus_option)
|
|
{
|
|
# add new to existing - at the end - comma separated
|
|
if (defined($DBattrvals{$objname}{$attr}))
|
|
{
|
|
$val =
|
|
"$DBattrvals{$objname}{$attr},$objhash{$objname}{$attr}";
|
|
}
|
|
else
|
|
{
|
|
$val = "$objhash{$objname}{$attr}";
|
|
}
|
|
}
|
|
elsif ($::minus_option)
|
|
{
|
|
# remove the specified list of values from the current
|
|
# attr values.
|
|
if ($DBattrvals{$objname}{$attr})
|
|
{
|
|
# get the list of attrs to remove
|
|
my @currentList = split(/,/, $DBattrvals{$objname}{$attr});
|
|
my @minusList = split(/,/, $objhash{$objname}{$attr});
|
|
|
|
# make a new list without the one specified
|
|
my $first = 1;
|
|
my $newlist;
|
|
foreach my $i (@currentList)
|
|
{
|
|
chomp $i;
|
|
if (!grep(/^$i$/, @minusList))
|
|
{
|
|
# set new groups list for node
|
|
if (!$first)
|
|
{
|
|
$newlist .= ",";
|
|
}
|
|
$newlist .= $i;
|
|
$first = 0;
|
|
}
|
|
}
|
|
$val = $newlist;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
#just set the attr to what was provided! - replace
|
|
$val = $objhash{$objname}{$attr};
|
|
|
|
}
|
|
|
|
if ( $val eq "") { # delete the line
|
|
$thistable->delEntries(\%keyhash);
|
|
} else { # change the attr
|
|
|
|
my %updates;
|
|
$updates{value} = $val;
|
|
|
|
my ($rc, $str) = $thistable->setAttribs(\%keyhash, \%updates);
|
|
if (!defined($rc))
|
|
{
|
|
if ($::verbose)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"Could not set the \'$attr\' attribute of the \'$objname\' object in the xCAT database.";
|
|
$rsp->{data}->[1] =
|
|
"Error returned is \'$str->errstr\'.";
|
|
xCAT::MsgUtils->message("I", $rsp, $::callback);
|
|
}
|
|
$ret = 1;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
$thistable->commit;
|
|
|
|
next;
|
|
} #if ($type eq 'site')
|
|
|
|
|
|
|
|
#
|
|
# handle the rest of the object types
|
|
#
|
|
|
|
# get the object type decription from Schema.pm
|
|
my $datatype = $xCAT::Schema::defspec{$type};
|
|
|
|
# get the object key to look for, for this object type
|
|
my $objkey = $datatype->{'objkey'};
|
|
|
|
# get a list of valid attr names
|
|
# for this type object
|
|
my %attrlist;
|
|
foreach my $entry (@{$datatype->{'attrs'}})
|
|
{
|
|
#push(@{$attrlist{$type}}, $entry->{'attr_name'});
|
|
$attrlist{$type}{$entry->{'attr_name'}} = 1;
|
|
}
|
|
|
|
my @attrprovided=();
|
|
|
|
# check FINALATTRS to see if all the attrs are valid
|
|
foreach my $attr (keys %{$objhash{$objname}})
|
|
{
|
|
|
|
if ($attr eq $objkey)
|
|
{
|
|
next;
|
|
}
|
|
|
|
if ($attr eq "objtype")
|
|
{
|
|
# objtype not stored in object definition
|
|
next;
|
|
}
|
|
|
|
if (!defined($attrlist{$type}{$attr}))
|
|
{
|
|
if ($::verbose)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"\'$attr\' is not a valid attribute for type \'$type\'.";
|
|
$rsp->{data}->[1] = "Skipping to the next attribute.";
|
|
xCAT::MsgUtils->message("I", $rsp, $::callback);
|
|
}
|
|
next;
|
|
}
|
|
push(@attrprovided, $attr);
|
|
}
|
|
|
|
# we need to figure out what table to
|
|
# store each attr
|
|
# And we must do this in the order given in defspec!!
|
|
|
|
my @setattrlist=();
|
|
my %checkedattrs;
|
|
my $invalidattr;
|
|
|
|
foreach my $this_attr (@{$datatype->{'attrs'}})
|
|
{
|
|
my %keyhash;
|
|
my %updates;
|
|
my %tabentry;
|
|
my ($lookup_table, $lookup_attr, $lookup_data);
|
|
my $attr_name = $this_attr->{attr_name};
|
|
|
|
if ($attr_name eq $objkey)
|
|
{
|
|
next;
|
|
}
|
|
|
|
# if we have a value for this attribute then process it
|
|
# - otherwise go to the next attr
|
|
if (defined($objhash{$objname}{$attr_name}))
|
|
{
|
|
# check the defspec to see where this attr goes
|
|
|
|
# the table for this attr might depend on the
|
|
# value of some other attr
|
|
# need to check the only_if entries to find one where the
|
|
# other attr value matches what we have
|
|
# ex. like if I want to set hdwctrlpoint I will have
|
|
# to match the right value for mgtmethod
|
|
if (exists($this_attr->{only_if}))
|
|
{
|
|
my ($check_attr, $check_value) =
|
|
split('\=', $this_attr->{only_if});
|
|
|
|
# if my attr value for the attr to check doesn't
|
|
# match this then try the next one
|
|
# ex. say I want to set hdwctrlpoint, the table
|
|
# will depend on the mgtmethod attr - so I need
|
|
# to find the 'only_if' that matches the value
|
|
# specified for that attr (ex. mgtmethod=hmc)
|
|
|
|
# need to check the attrs we are setting for the object
|
|
# as well as the attrs for this object that may be
|
|
# already set in DB
|
|
|
|
if ( !($objhash{$objname}{$check_attr}) && !($DBattrvals{$objname}{$check_attr}) ) {
|
|
# if I didn't already check for this attr
|
|
my $rsp;
|
|
if (!defined($checkedattrs{$attr_name})) {
|
|
push @{$rsp->{data}}, "Cannot set the \'$attr_name\' attribute unless a value is provided for \'$check_attr\'.";
|
|
|
|
foreach my $tmp_attr (@{$datatype->{'attrs'}}) {
|
|
my $attr = $tmp_attr->{attr_name};
|
|
if ($attr eq $check_attr) {
|
|
my ($tab, $at) = split(/\./, $tmp_attr->{tabentry});
|
|
my $schema = xCAT::Table->getTableSchema($tab);
|
|
my $desc = $schema->{descriptions}->{$at};
|
|
push @{$rsp->{data}}, "$check_attr => $desc";
|
|
}
|
|
}
|
|
}
|
|
xCAT::MsgUtils->message("I", $rsp, $::callback);
|
|
$checkedattrs{$attr_name} = 1;
|
|
if ( $invalidattr->{$attr_name}->{valid} ne 1 ) {
|
|
$invalidattr->{$attr_name}->{valid} = 0;
|
|
$invalidattr->{$attr_name}->{condition} = "\'$check_attr=$check_value\'";
|
|
}
|
|
|
|
next;
|
|
}
|
|
|
|
if ( !($objhash{$objname}{$check_attr} =~ /\b$check_value\b/) && !($DBattrvals{$objname}{$check_attr} =~ /\b$check_value\b/) )
|
|
{
|
|
if ( $invalidattr->{$attr_name}->{valid} ne 1 ) {
|
|
$invalidattr->{$attr_name}->{valid} = 0;
|
|
$invalidattr->{$attr_name}->{condition} = "\'$check_attr=$check_value\'";
|
|
|
|
}
|
|
|
|
next;
|
|
}
|
|
}
|
|
$invalidattr->{$attr_name}->{valid} = 1;
|
|
|
|
# get the info needed to write to the DB table
|
|
#
|
|
# get the actual attr name to use in the table
|
|
# - may be different then the attr name used for the object.
|
|
my $ntab;
|
|
($ntab, $::tabattr) = split('\.', $this_attr->{tabentry});
|
|
|
|
my $rc = xCAT::DBobjUtils->parse_access_tabentry($objname,
|
|
$this_attr->{access_tabentry}, \%tabentry);
|
|
if ($rc != 0)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"access_tabentry \'$this_attr->{access_tabentry}\' is not valid.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
next;
|
|
}
|
|
$lookup_table = $tabentry{'lookup_table'};
|
|
# Set the lookup criteria for this attribute into %allupdates
|
|
# the key is 'lookup_attrs'
|
|
foreach my $lookup_attr (keys %{$tabentry{'lookup_attrs'}})
|
|
{
|
|
$allupdates{$lookup_table}{$objname}{$attr_name}{'lookup_attrs'}{$lookup_attr}
|
|
=$tabentry{'lookup_attrs'}{$lookup_attr};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
next;
|
|
}
|
|
|
|
my $val;
|
|
my $delim = ',';
|
|
if(($type eq 'group') && ($DBattrvals{$objname}{'grouptype'} eq 'dynamic'))
|
|
{
|
|
# dynamic node group selection string use "::" as delimiter
|
|
$delim = '::';
|
|
}
|
|
|
|
if ($::plus_option)
|
|
{
|
|
|
|
# add new to existing - at the end - comma separated
|
|
if (defined($DBattrvals{$objname}{$attr_name}))
|
|
{
|
|
# add the attr into the list if it's not already in the list!
|
|
# and avoid the duplicate values
|
|
my @DBattrarray = split(/$delim/, $DBattrvals{$objname}{$attr_name});
|
|
my @objhasharray = split(/$delim/, $objhash{$objname}{$attr_name});
|
|
foreach my $objattr (@objhasharray)
|
|
{
|
|
if (!grep(/^\Q$objattr\E$/, @DBattrarray))
|
|
{
|
|
push @DBattrarray, $objattr;
|
|
}
|
|
}
|
|
$val = join($delim, @DBattrarray);
|
|
}
|
|
else
|
|
{
|
|
$val = "$objhash{$objname}{$attr_name}";
|
|
}
|
|
|
|
}
|
|
elsif ($::minus_option)
|
|
{
|
|
|
|
# remove the specified list of values from the current
|
|
# attr values.
|
|
if ($DBattrvals{$objname}{$attr_name})
|
|
{
|
|
|
|
# get the list of attrs to remove
|
|
my @currentList =
|
|
split(/$delim/, $DBattrvals{$objname}{$attr_name});
|
|
my @minusList = split(/$delim/, $objhash{$objname}{$attr_name});
|
|
|
|
foreach my $em (@minusList)
|
|
{
|
|
if (!(grep {$_ eq $em} @currentList))
|
|
{
|
|
if (($::opt_t eq 'group') && ($DBattrvals{$objname}{'grouptype'} ne 'dynamic'))
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "$objname is not a member of \'$em\'.";
|
|
xCAT::MsgUtils->message("W", $rsp, $::callback);
|
|
} else {
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "$em is not in the attribute of \'$attr_name\' for the \'$objname\' definition.";
|
|
xCAT::MsgUtils->message("W", $rsp, $::callback);
|
|
}
|
|
}
|
|
}
|
|
# make a new list without the one specified
|
|
my $first = 1;
|
|
my $newlist;
|
|
foreach my $i (@currentList)
|
|
{
|
|
chomp $i;
|
|
if (!grep(/^\Q$i\E$/, @minusList))
|
|
{
|
|
|
|
# set new list for node
|
|
if (!$first)
|
|
{
|
|
$newlist .= "$delim";
|
|
}
|
|
$newlist .= $i;
|
|
$first = 0;
|
|
}
|
|
}
|
|
$val = $newlist;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
#just set the attr to what was provided! - replace
|
|
$val = $objhash{$objname}{$attr_name};
|
|
|
|
}
|
|
|
|
# Set the values into %allupdates
|
|
# the key is 'tabattrs'
|
|
$allupdates{$lookup_table}{$objname}{$attr_name}{'tabattrs'}{$::tabattr} = $val;
|
|
$setattrs=1;
|
|
|
|
push(@setattrlist, $attr_name);
|
|
|
|
} # end - foreach attribute
|
|
|
|
my $rsp;
|
|
foreach my $att (keys %$invalidattr) {
|
|
if ( $invalidattr->{$att}->{valid} ne 1) {
|
|
my $tt = $invalidattr->{$att}->{valid};
|
|
push @{$rsp->{data}}, "Cannot set the attr=\'$att\' attribute unless $invalidattr->{$att}->{condition}.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
}
|
|
}
|
|
|
|
|
|
# TODO - need to get back to this
|
|
if (0) {
|
|
#
|
|
# check to see if all the attrs got set
|
|
#
|
|
|
|
my @errlist;
|
|
foreach $a (@attrprovided)
|
|
{
|
|
# is this attr was not set then add it to the error list
|
|
if (!grep(/^$a$/, @setattrlist))
|
|
{
|
|
push(@errlist, $a);
|
|
$ret = 2;
|
|
}
|
|
|
|
}
|
|
if ($ret == 2) {
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "Could not set the following attributes for the \'$objname\' definition in the xCAT database: \'@errlist\'";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
}
|
|
|
|
}
|
|
|
|
} # end - foreach object
|
|
#==========================================================#
|
|
#%allupdates structure:
|
|
# for command: chdef -t node -o node1 groups=all
|
|
# usercomment=ddee passwd.HMC=HMC
|
|
# passwd.admin=cluster passwd.general=abc123
|
|
# the %allupdates will be:
|
|
#0 'ppcdirect'
|
|
#1 HASH(0x12783d30)
|
|
# 'node1' => HASH(0x12783cc4)
|
|
# 'passwd.HMC' => HASH(0x12783ed4)
|
|
# 'lookup_attrs' => HASH(0x12783f70)
|
|
# 'hcp' => 'node1'
|
|
# 'username' => 'HMC'
|
|
# 'tabattrs' => HASH(0x12783e8c)
|
|
# 'password' => 'HMC'
|
|
# 'passwd.admin' => HASH(0x12783c64)
|
|
# 'lookup_attrs' => HASH(0x12784000)
|
|
# 'hcp' => 'node1'
|
|
# 'username' => 'admin'
|
|
# 'tabattrs' => HASH(0x12783f64)
|
|
# 'password' => 'cluster'
|
|
# 'passwd.general' => HASH(0x12783a6c)
|
|
# 'lookup_attrs' => HASH(0x12784198)
|
|
# 'hcp' => 'node1'
|
|
# 'username' => 'general'
|
|
# 'tabattrs' => HASH(0x12783aa8)
|
|
# 'password' => 'abc123'
|
|
#2 'nodelist'
|
|
#3 HASH(0x127842b8)
|
|
# 'node1' => HASH(0x12784378)
|
|
# 'groups' => HASH(0x12784090)
|
|
# 'lookup_attrs' => HASH(0x127844bc)
|
|
# 'node' => 'node1'
|
|
# 'tabattrs' => HASH(0x1277fd34)
|
|
# 'groups' => 'all'
|
|
# 'usercomment' => HASH(0x12784318)
|
|
# 'lookup_attrs' => HASH(0x12780550)
|
|
# 'node' => 'node1'
|
|
# 'tabattrs' => HASH(0x127842f4)
|
|
# 'comments' => 'ddee'
|
|
#=================================================================#
|
|
# now set the attribute values in the tables
|
|
# - handles all except site, monitoring & monsetting for now
|
|
if ($setattrs) {
|
|
foreach my $table (keys %allupdates) {
|
|
|
|
# get the keys for this table
|
|
my $schema = xCAT::Table->getTableSchema($table);
|
|
my $keys = $schema->{keys};
|
|
|
|
# open the table
|
|
my $thistable = xCAT::Table->new($table, -create => 1, -autocommit => 0);
|
|
if (!$thistable) {
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "Could not set the \'$thistable\' table.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
return 1;
|
|
}
|
|
|
|
# Special case for the postscripts table
|
|
# Does not set the postscripts to the postscripts table
|
|
# if the postscripts already in xcatdefaults
|
|
# for code logic, it will be clearer to put the special case into defch,
|
|
# but putting it into defch will introduce additional table access for postscripts table.
|
|
# accessing table is time consuming.
|
|
if ($table eq "postscripts") {
|
|
my $xcatdefaultsps;
|
|
my $xcatdefaultspbs;
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable('postscripts');
|
|
if (@TableRowArray)
|
|
{
|
|
foreach my $tablerow (@TableRowArray)
|
|
{
|
|
if(($tablerow->{node} eq 'xcatdefaults') && !($tablerow->{disable}))
|
|
{
|
|
$xcatdefaultsps = $tablerow->{postscripts};
|
|
$xcatdefaultspbs = $tablerow->{postbootscripts};
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
my @xcatdefps = split(/,/, $xcatdefaultsps);
|
|
my @xcatdefpbs = split(/,/, $xcatdefaultspbs);
|
|
foreach my $obj(keys %{$allupdates{$table}}) {
|
|
if ($obj eq 'xcatdefaults') {
|
|
#xcatdefaults can be treated as a node?
|
|
next;
|
|
}
|
|
my @newps;
|
|
if (defined($allupdates{$table}{$obj}{'postscripts'})
|
|
&& defined($allupdates{$table}{$obj}{'postscripts'}{'tabattrs'}{'postscripts'})) {
|
|
foreach my $tempps (split(/,/, $allupdates{$table}{$obj}{'postscripts'}{'tabattrs'}{'postscripts'})) {
|
|
if (grep(/^$tempps$/, @xcatdefps)) {
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "$obj: postscripts \'$tempps\' is already included in the \'xcatdefaults\'.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
} else {
|
|
push @newps, $tempps;
|
|
}
|
|
}
|
|
$allupdates{$table}{$obj}{'postscripts'}{'tabattrs'}{'postscripts'} = join(',', @newps);
|
|
}
|
|
my @newpbs;
|
|
if (defined($allupdates{$table}{$obj}{'postbootscripts'})
|
|
&& defined($allupdates{$table}{$obj}{'postbootscripts'}{'tabattrs'}{'postbootscripts'})) {
|
|
foreach my $temppbs (split(/,/, $allupdates{$table}{$obj}{'postbootscripts'}{'tabattrs'}{'postbootscripts'})) {
|
|
if (grep(/^$temppbs$/, @xcatdefpbs)) {
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "$obj: postbootscripts \'$temppbs\' is already included in the \'xcatdefaults\'.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
} else {
|
|
push @newpbs, $temppbs;
|
|
}
|
|
}
|
|
$allupdates{$table}{$obj}{'postbootscripts'}{'tabattrs'}{'postbootscripts'} = join(',', @newpbs);
|
|
}
|
|
}
|
|
}
|
|
|
|
my $commit_manually = 0;
|
|
my %node_updates;
|
|
OBJ: foreach my $obj (keys %{$allupdates{$table}}) {
|
|
my %keyhash;
|
|
my %updates;
|
|
my $firsttime = 1;
|
|
ROW: foreach my $row (keys %{$allupdates{$table}{$obj}}) {
|
|
# make sure we have a value for each key
|
|
foreach my $k (@$keys) {
|
|
if (!$allupdates{$table}{$obj}{$row}{'lookup_attrs'}) {
|
|
my $rsp;
|
|
$rsp->{data}->[0] = "\nMissing required attribute values for the \'$obj\' object. The required attributes are: @$keys";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
$ret = 1;
|
|
next ROW;
|
|
}
|
|
}
|
|
|
|
if ($firsttime) {
|
|
# lookup keys in %hashkey
|
|
# ex. $keyhash{'hcp'} = node1
|
|
foreach my $key (keys %{$allupdates{$table}{$obj}{$row}{'lookup_attrs'}}) {
|
|
$keyhash{$key} = $allupdates{$table}{$obj}{$row}{'lookup_attrs'}{$key};
|
|
}
|
|
$firsttime = 0;
|
|
} else {
|
|
# check if the look_attrs is the same as the %keyhash
|
|
foreach my $key (keys %{$allupdates{$table}{$obj}{$row}{'lookup_attrs'}}) {
|
|
# The lookup_attrs can be different for tables with more than one keys such as ppcdirect
|
|
if ((scalar(keys %keyhash) != scalar(keys %{$allupdates{$table}{$obj}{$row}{'lookup_attrs'}}))
|
|
|| !defined($keyhash{$key})
|
|
||($keyhash{$key} ne $allupdates{$table}{$obj}{$row}{'lookup_attrs'}{$key})) {
|
|
# different keys, set the existing attributes into database
|
|
# update the %keyhash and clean up the %updates hash
|
|
if (%updates) {
|
|
$commit_manually = 1;
|
|
my ($rc, $str) = $thistable->setAttribs(\%keyhash, \%updates);
|
|
}
|
|
foreach my $key (keys %{$allupdates{$table}{$obj}{$row}{'lookup_attrs'}}) {
|
|
$keyhash{$key} = $allupdates{$table}{$obj}{$row}{'lookup_attrs'}{$key};
|
|
}
|
|
%updates = ();
|
|
}
|
|
}
|
|
}
|
|
|
|
# set values in %updates
|
|
# ex. $updates{'groups'} = 'all,lpar'
|
|
foreach my $attr (keys %{$allupdates{$table}{$obj}{$row}{'tabattrs'}}) {
|
|
if (scalar(keys %keyhash) == 0 && $keyhash{'node'} && $keyhash{'node'} eq "node") {
|
|
$node_updates{$obj}{$attr} = $allupdates{$table}{$obj}{$row}{'tabattrs'}{$attr};
|
|
} else {
|
|
$updates{$attr} = $allupdates{$table}{$obj}{$row}{'tabattrs'}{$attr};
|
|
}
|
|
}
|
|
|
|
} #end foreach my $row
|
|
# only uses the setAttribs to set attribute one by one when the obj type is NOT 'node'
|
|
if (%updates) {
|
|
$commit_manually = 1;
|
|
my ($rc, $str) = $thistable->setAttribs(\%keyhash, \%updates);
|
|
}
|
|
} #end foreach my $obj
|
|
if ($commit_manually) {
|
|
$thistable->commit;
|
|
}
|
|
if (%node_updates) {
|
|
$thistable->setNodesAttribs(\%node_updates);
|
|
}
|
|
} #end forach my $table
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 rmobjdefs
|
|
|
|
Remove object definitions from the DB.
|
|
|
|
Arguments:
|
|
Returns:
|
|
0 - OK
|
|
1 - error
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
To use create hash for object name and object type
|
|
ex. $objhash{$obj} = $type;
|
|
- then call as follows:
|
|
xCAT::DBobjUtils->rmobjdefs(\%objhash);
|
|
|
|
Comments:
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub rmobjdefs
|
|
{
|
|
my ($class, $hash_ref) = @_;
|
|
|
|
my %tablehash;
|
|
|
|
my %typehash = %$hash_ref;
|
|
|
|
# get the attr=vals for these objects so we know how to
|
|
# find what tables have to be modified
|
|
|
|
foreach my $objname (sort (keys %typehash))
|
|
{
|
|
my $type = $typehash{$objname};
|
|
|
|
# special handling for site table
|
|
if ($type eq 'site')
|
|
{
|
|
my %DBattrvals = xCAT::DBobjUtils->getobjdefs(\%typehash);
|
|
my $thistable =
|
|
xCAT::Table->new('site', -create => 1, -autocommit => 0);
|
|
my %keyhash;
|
|
foreach my $attr (keys %{$DBattrvals{$objname}})
|
|
{
|
|
|
|
# ex. key = attr
|
|
$keyhash{key} = $attr;
|
|
|
|
$thistable->delEntries(\%keyhash);
|
|
|
|
}
|
|
$thistable->commit();
|
|
next;
|
|
}
|
|
|
|
# get the object type decription from Schema.pm
|
|
my $datatype = $xCAT::Schema::defspec{$type};
|
|
|
|
# go through the list of valid attrs
|
|
# - need to delete the row with a $key value of $objname from $table
|
|
# - make a hash containing $delhash{$table}{$key}= $objname
|
|
foreach my $this_attr (@{$datatype->{'attrs'}})
|
|
{
|
|
my $attr = $this_attr->{attr_name};
|
|
|
|
# get table lookup info from Schema.pm
|
|
# def commands need to support multiple keys in one table
|
|
# the subroutine parse_access_tabentry is used for supporting multiple keys
|
|
my %tabentry = ();
|
|
my $rc = xCAT::DBobjUtils->parse_access_tabentry($objname, $this_attr->{access_tabentry}, \%tabentry);
|
|
if ($rc != 0)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"access_tabentry \'$this_attr->{access_tabentry}\' is not valid.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
next;
|
|
}
|
|
|
|
# Only allow one table in the access_tabentry
|
|
# use multiple tables to look up tabentry does not make any sense
|
|
my $lookup_table = $tabentry{'lookup_table'};
|
|
# The attr_name is the *def attribute name instead of db column
|
|
my $attr_name = $this_attr->{'attr_name'};
|
|
# we'll need table name, object name, attribute name and the lookup entries
|
|
# put this info in a hash - we'll process it later - below
|
|
foreach my $lookup_attr (keys %{$tabentry{'lookup_attrs'}})
|
|
{
|
|
$tablehash{$lookup_table}{$objname}{$attr_name}{$lookup_attr}
|
|
= $tabentry{'lookup_attrs'}{$lookup_attr};
|
|
}
|
|
|
|
}
|
|
}
|
|
#=============================================#
|
|
# The tablehash looks like this
|
|
# DB<5> x %tablehash
|
|
# 'bootparams'
|
|
# HASH(0x1280828c)
|
|
# 'node1' => HASH(0x127bca50)
|
|
# 'addkcmdline' => HASH(0x127fb114)
|
|
# 'node' => 'node1'
|
|
# 'initrd' => HASH(0x127bcb40)
|
|
# 'node' => 'node1'
|
|
# 'kcmdline' => HASH(0x127fb24c)
|
|
# 'node' => 'node1'
|
|
# 'kernel' => HASH(0x127b2e80)
|
|
# 'node' => 'node1'
|
|
# 'testfsp' => HASH(0x1280e71c)
|
|
# 'addkcmdline' => HASH(0x1280e7a0)
|
|
# 'node' => 'testfsp'
|
|
# 'initrd' => HASH(0x1280e740)
|
|
# 'node' => 'testfsp'
|
|
# 'kcmdline' => HASH(0x1280e77c)
|
|
# 'node' => 'testfsp'
|
|
# 'kernel' => HASH(0x1280e758)
|
|
# 'node' => 'testfsp'
|
|
#...
|
|
# 'ppcdirect'
|
|
# HASH(0x1278fe1c)
|
|
# 'node1' => HASH(0x12808370)
|
|
# 'passwd.HMC' => HASH(0x128083e8)
|
|
# 'hcp' => 'node1'
|
|
# 'username' => 'HMC'
|
|
# 'passwd.admin' => HASH(0x128081c0)
|
|
# 'hcp' => 'node1'
|
|
# 'username' => 'admin'
|
|
# 'passwd.general' => HASH(0x128075d8)
|
|
# 'hcp' => 'node1'
|
|
# 'username' => 'general'
|
|
# 'testfsp' => HASH(0x12790620)
|
|
# 'passwd.HMC' => HASH(0x1280ee84)
|
|
# 'hcp' => 'testfsp'
|
|
# 'username' => 'HMC'
|
|
# 'passwd.admin' => HASH(0x128082f8)
|
|
# 'hcp' => 'testfsp'
|
|
# 'username' => 'admin'
|
|
# 'passwd.general' => HASH(0x1280843c)
|
|
# 'hcp' => 'testfsp'
|
|
# 'username' => 'general'
|
|
#...
|
|
##=========================================================#
|
|
# now for each table - clear the entry
|
|
foreach my $table (keys %tablehash)
|
|
{
|
|
my @all_keyhash;
|
|
|
|
my $thistable =
|
|
xCAT::Table->new($table, -create => 1, -autocommit => 0);
|
|
|
|
foreach my $obj (keys %{$tablehash{$table}}) {
|
|
my %keyhash;
|
|
foreach my $attr (keys %{$tablehash{$table}{$obj}})
|
|
{
|
|
foreach my $key (keys %{$tablehash{$table}{$obj}{$attr}})
|
|
{
|
|
|
|
#multiple keys support
|
|
if (defined($keyhash{$key}) && ($keyhash{$key} ne $tablehash{$table}{$obj}{$attr}{$key}))
|
|
{
|
|
my %tmpkeyhash;
|
|
# copy hash
|
|
foreach my $hashkey (keys %keyhash)
|
|
{
|
|
$tmpkeyhash{$hashkey} = $keyhash{$hashkey};
|
|
}
|
|
push @all_keyhash, \%tmpkeyhash;
|
|
#$thistable->delEntries(\@all_keyhash);
|
|
}
|
|
# ex. $keyhash{node}=c68m3hvp01
|
|
$keyhash{$key} = $tablehash{$table}{$obj}{$attr}{$key};
|
|
}
|
|
}
|
|
push @all_keyhash, \%keyhash;
|
|
}
|
|
# ex. delete the c68m3hvp01 entry of the node column in the
|
|
# nodelist table
|
|
$thistable->delEntries(\@all_keyhash);
|
|
|
|
$thistable->commit();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 readFileInput
|
|
|
|
Process the command line input piped in from a file.
|
|
(Support stanza or xml format.)
|
|
|
|
Arguments:
|
|
Returns:
|
|
0 - OK
|
|
1 - error
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
Comments:
|
|
Set @::fileobjtypes, @::fileobjnames, %::FILEATTRS
|
|
(i.e.- $::FILEATTRS{objname}{attr}=val)
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub readFileInput
|
|
{
|
|
my ($class, $filedata) = @_;
|
|
my ($objectname, $junk1, $junk2);
|
|
|
|
@::fileobjnames = ();
|
|
|
|
my @lines = split /\n/, $filedata;
|
|
|
|
my $header = $lines[0];
|
|
|
|
# to do
|
|
#if ($header =~/<xCAT data object stanza file>/) {
|
|
# do stanza file parsing
|
|
# } elsis ($header =~/<xCAT data object XML file>/) {
|
|
# do XML parsing
|
|
#}
|
|
|
|
my $look_for_colon = 1; # start with first line that has a colon
|
|
my $objtype;
|
|
|
|
foreach my $l (@lines)
|
|
{
|
|
|
|
# skip blank and comment lines
|
|
next if ($l =~ /^\s*$/ || $l =~ /^\s*#/);
|
|
|
|
# see if it's a stanza name
|
|
if (grep(/:\s*$/, $l))
|
|
{
|
|
|
|
$look_for_colon = 0; # ok - we have a colon
|
|
|
|
($objectname, $junk2) = split(/:/, $l);
|
|
|
|
# if $junk2 is defined or there's an =
|
|
if ($junk2 || grep(/=/, $objectname))
|
|
{
|
|
|
|
# error - invalid header $line in node definition file
|
|
# skipping to next node stanza
|
|
# Skipping to the next valid header.
|
|
$look_for_colon++;
|
|
next;
|
|
}
|
|
|
|
$objectname =~ s/^\s*//; # Remove any leading whitespace
|
|
$objectname =~ s/\s*$//; # Remove any trailing whitespace
|
|
|
|
# could have different default stanzas for different object types
|
|
|
|
if ($objectname =~ /default/)
|
|
{
|
|
|
|
($junk1, $objtype) = split(/-/, $objectname);
|
|
|
|
if ($objtype)
|
|
{
|
|
$objectname = 'default';
|
|
}
|
|
|
|
next;
|
|
}
|
|
|
|
push(@::fileobjnames, $objectname);
|
|
|
|
}
|
|
elsif (($l =~ /^\s*(.*?)\s*=\s*(.*)\s*/) && (!$look_for_colon))
|
|
{
|
|
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 so createnode won't get upset
|
|
$val =~ s/^\s*"\s*//;
|
|
$val =~ s/\s*"\s*$//;
|
|
|
|
if ($objectname eq "default")
|
|
{
|
|
|
|
# set the default for this attribute
|
|
$::defAttrs{$objtype}{$attr} = $val;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
# set the value in the hash for this object
|
|
$::FILEATTRS{$objectname}{$attr} = $val;
|
|
|
|
# if the attr being set is "objtype" then check
|
|
# to see if we have any defaults set for this type
|
|
# the objtype should be the first etntry in each stanza
|
|
# so after we set the defaults they will be overwritten
|
|
# by any values that appear in the rest of the stanza
|
|
if ($attr eq 'objtype')
|
|
{
|
|
push(@::fileobjtypes, $val);
|
|
|
|
# $val will be the object type ex. site, node etc.
|
|
foreach my $a (keys %{$::defAttrs{$val}})
|
|
{
|
|
|
|
# set the default values for this object hash
|
|
$::FILEATTRS{$objectname}{$a} = $::defAttrs{$val}{$a};
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
# error - invalid line in node definition file
|
|
$look_for_colon++;
|
|
}
|
|
|
|
} # end while - go to next line
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 getGroupMembers
|
|
|
|
Get the list of members for the specified group.
|
|
|
|
Arguments:
|
|
Returns:
|
|
undef - error
|
|
$members - comma-separated list of group members
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
To use:
|
|
- create hash for objectname and and attr values (need group
|
|
name (object), and grouptype & members attr values at a
|
|
minimum.)
|
|
|
|
ex. $objhash{$obj}{$attr} = value;
|
|
|
|
- then call as follows:
|
|
xCAT::DBobjUtils->getGroupMembers($objectname, \%objhash);
|
|
|
|
Comments:
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub getGroupMembers
|
|
{
|
|
my ($class, $objectname, $hash_ref) = @_;
|
|
|
|
my $members;
|
|
|
|
my %objhash = %$hash_ref;
|
|
|
|
# set 'static' as the dafault of nodetype
|
|
if (!defined($objhash{$objectname}{'grouptype'}) ||
|
|
$objhash{$objectname}{'grouptype'} eq "") {
|
|
$objhash{$objectname}{'grouptype'} = 'static';
|
|
}
|
|
|
|
if ($objhash{$objectname}{'grouptype'} eq 'static')
|
|
{
|
|
|
|
my $table = "nodelist";
|
|
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable($table);
|
|
|
|
my $first = 1;
|
|
foreach (@TableRowArray)
|
|
{
|
|
|
|
# if find the group name in the "groups" attr value then add the
|
|
# node name to the member list
|
|
#if ($_->{'groups'} =~ /$objectname/)
|
|
|
|
my @nodeGroupList = split(',', $_->{'groups'});
|
|
if (grep(/^$objectname$/, @nodeGroupList))
|
|
|
|
{
|
|
chomp($_->{'node'});
|
|
if (!$first)
|
|
{
|
|
$members .= ",";
|
|
}
|
|
$members .= $_->{'node'};
|
|
$first = 0;
|
|
}
|
|
}
|
|
|
|
}
|
|
elsif ($objhash{$objectname}{'grouptype'} eq 'dynamic')
|
|
{
|
|
|
|
# find all nodes that satisfy the criteria specified in "wherevals"
|
|
# value
|
|
my %whereHash;
|
|
my %tabhash;
|
|
|
|
# remove spaces and quotes so createnode won't get upset
|
|
#$val =~ s/^\s*"\s*//;
|
|
#$val =~ s/\s*"\s*$//;
|
|
|
|
my @tmpWhereList = split('::', $objhash{$objectname}{'wherevals'});
|
|
my $rc = xCAT::Utils->parse_selection_string(\@tmpWhereList, \%whereHash);
|
|
if ($rc != 0)
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"The \'-w\' option has an incorrect attr*val pair.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
}
|
|
|
|
# see what nodes have these attr=values
|
|
# get a list of all nodes
|
|
my @tmplist = xCAT::DBobjUtils->getObjectsOfType('node');
|
|
|
|
# create a hash of obj names and types
|
|
my %tmphash;
|
|
foreach my $n (@tmplist)
|
|
{
|
|
$tmphash{$n} = 'node';
|
|
}
|
|
|
|
# Only get the specific attributes of the node
|
|
my @whereattrs = keys %whereHash;
|
|
my %nodeattrhash = xCAT::DBobjUtils->getobjdefs(\%tmphash, 0, \@whereattrs);
|
|
|
|
# The attribute 'node' can be used as a key of selection string,
|
|
# however, the 'node' attribute is not included in the getobjdefs hash
|
|
foreach my $objname (keys %nodeattrhash)
|
|
{
|
|
$nodeattrhash{$objname}{'node'} = $objname;
|
|
}
|
|
my $first = 1;
|
|
foreach my $objname (keys %nodeattrhash)
|
|
{
|
|
if (xCAT::Utils->selection_string_match(\%nodeattrhash, $objname, \%whereHash))
|
|
{
|
|
chomp($objname);
|
|
if (!$first)
|
|
{
|
|
$members .= ",";
|
|
}
|
|
$members .= $objname;
|
|
$first = 0;
|
|
}
|
|
}
|
|
|
|
}
|
|
return $members;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 getNetwkInfo
|
|
|
|
Get the network info from the database for a list of nodes.
|
|
|
|
Arguments:
|
|
Returns:
|
|
undef
|
|
hash ref - ex. $nethash{nodename}{networks attr name} = value
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
%nethash = xCAT::DBobjUtils->getNetwkInfo(\@targetnodes);
|
|
|
|
Comments:
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub getNetwkInfo
|
|
{
|
|
my ($class, $ref_nodes) = @_;
|
|
my @nodelist = @$ref_nodes;
|
|
|
|
my %nethash;
|
|
my @attrnames;
|
|
|
|
# get the current list of network attrs (networks table columns)
|
|
my $datatype = $xCAT::Schema::defspec{'network'};
|
|
foreach my $a (@{$datatype->{'attrs'}}) {
|
|
my $attr = $a->{attr_name};
|
|
push(@attrnames, $attr);
|
|
}
|
|
|
|
# read the networks table
|
|
my @TableRowArray = xCAT::DBobjUtils->getDBtable('networks');
|
|
if (! @TableRowArray)
|
|
{
|
|
return undef;
|
|
}
|
|
|
|
# for each node - get the network info
|
|
foreach my $node (@nodelist)
|
|
{
|
|
|
|
# get, check, split the node IP
|
|
my $IP = xCAT::NetworkUtils->getipaddr($node);
|
|
chomp $IP;
|
|
unless (($IP =~ /\d+\.\d+\.\d+\.\d+/) || ($IP =~ /:/))
|
|
{
|
|
next;
|
|
}
|
|
my ($ia, $ib, $ic, $id) = split('\.', $IP);
|
|
|
|
# check the entries of the networks table
|
|
# - if the bitwise AND of the IP and the netmask gives you
|
|
# the "net" name then that is the entry you want.
|
|
foreach (@TableRowArray) {
|
|
my $NM = $_->{'mask'};
|
|
my $net=$_->{'net'};
|
|
chomp $NM;
|
|
chomp $net;
|
|
|
|
if(xCAT::NetworkUtils->ishostinsubnet($IP, $NM, $net))
|
|
{
|
|
# fill in the hash -
|
|
foreach my $attr (@attrnames) {
|
|
if ( defined($_->{$attr}) ) {
|
|
$nethash{$node}{$attr} = $_->{$attr};
|
|
}
|
|
}
|
|
if($nethash{$node}{'gateway'} eq '<xcatmaster>')
|
|
{
|
|
if(xCAT::NetworkUtils->ip_forwarding_enabled())
|
|
{
|
|
$nethash{$node}{'gateway'} = xCAT::NetworkUtils->my_ip_in_subnet($net, $NM);
|
|
}
|
|
else
|
|
{
|
|
$nethash{$node}{'gateway'} = '';
|
|
}
|
|
$nethash{$node}{'myselfgw'} = 1;
|
|
# For hwctrl commands, it is possible that this subroutine is called
|
|
# on MN instead of SN, if the hcp SN is not set
|
|
if (xCAT::Utils->isMN() && !$nethash{$node}{'gateway'})
|
|
{
|
|
# does not have ip address in this subnet,
|
|
# use the node attribute 'xcatmaster' or site.master
|
|
my @nodes = ("$node");
|
|
my $sn = xCAT::ServiceNodeUtils->get_ServiceNode(\@nodes,"xcat","Node");
|
|
my $snkey = (keys %{$sn})[0];
|
|
$nethash{$node}{'gateway'} = xCAT::NetworkUtils->getipaddr($snkey);
|
|
}
|
|
|
|
}
|
|
next;
|
|
}
|
|
|
|
}
|
|
|
|
} #end - for each node
|
|
|
|
return %nethash;
|
|
}
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head3 parse_access_tabentry
|
|
|
|
Parse the access_tabentry field in Schema.pm.
|
|
We needs to support multiple keys in the table
|
|
Arguments:
|
|
$objname: objectname=>objtype hash
|
|
$access_tabentry: the access_tabentry defined in Schema.pm
|
|
$tabentry_ref: return the parsed result through this hash ref
|
|
The structure of the hash is:
|
|
{
|
|
'lookup_tables' => <table_name>
|
|
'lookup_attrs' =>
|
|
{
|
|
'attr1' => 'val1'
|
|
'attr2' => 'val2'
|
|
...
|
|
}
|
|
}
|
|
Returns:
|
|
0 - success
|
|
1 - failed
|
|
Globals:
|
|
Error:
|
|
Example:
|
|
|
|
To parse the access_tabentry field
|
|
|
|
my $rc = xCAT::DBobjUtils->parse_access_tabentry($objname, $this_attr->{access_tabentry}, \%tabentry);
|
|
|
|
Comments:
|
|
|
|
=cut
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub parse_access_tabentry()
|
|
{
|
|
my ($class, $objname, $access_tabentry, $tabentry_ref) = @_;
|
|
|
|
# ex. 'nodelist.node', 'attr:node'
|
|
foreach my $ent (split('::', $access_tabentry))
|
|
{
|
|
# ex. 'nodelist.node', 'attr:node'
|
|
my ($lookup_key, $lookup_value) = split('\=', $ent);
|
|
|
|
# ex. 'nodelist', 'node'
|
|
my ($lookup_table, $lookup_attr) = split('\.', $lookup_key);
|
|
|
|
# ex. 'attr', 'node'
|
|
my ($lookup_type, $lookup_data) = split('\:', $lookup_value);
|
|
|
|
if (!defined($tabentry_ref->{'lookup_table'}))
|
|
{
|
|
$tabentry_ref->{'lookup_table'} = $lookup_table;
|
|
}
|
|
|
|
# Only support one lookup table in the access_tabentry
|
|
# Do we need to support multiple tables in one access_tabentry ????
|
|
# has not seen any requirement...
|
|
if ($lookup_table ne $tabentry_ref->{'lookup_table'})
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"The access_tabentry \"$access_tabentry\" is not valid, can not specify more than one tables to look up.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
return 1;
|
|
}
|
|
|
|
if ($lookup_type eq 'attr')
|
|
{
|
|
# TODO: may need to update in the future
|
|
# for now, the "val" in attr:val in
|
|
# Schema.pm can only be the object name
|
|
# In the future, even if we need to change here,
|
|
# be caution about the performance
|
|
# looking up table is time consuming
|
|
$tabentry_ref->{'lookup_attrs'}->{$lookup_attr} = $objname;
|
|
}
|
|
elsif ($lookup_type eq 'str')
|
|
{
|
|
$tabentry_ref->{'lookup_attrs'}->{$lookup_attr} = $lookup_data;
|
|
}
|
|
else
|
|
{
|
|
my $rsp;
|
|
$rsp->{data}->[0] =
|
|
"The access_tabentry \"$access_tabentry\" is not valid, the lookup type can only be 'attr' or 'str'.";
|
|
xCAT::MsgUtils->message("E", $rsp, $::callback);
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
#-------------------------------------------------------------------------------
|
|
|
|
=head3 getchildren
|
|
Arguments:
|
|
single hostname
|
|
optional port number
|
|
Returns:
|
|
array of fsp/bpa hostnames (IPs)
|
|
if specified port, it will just return nodes within the port.
|
|
Globals:
|
|
%PPCHASH - HASH of nodename -> array of ip addresses
|
|
where the nodetype is fsp or bpa
|
|
Error:
|
|
$::RUNCMD_RC = 1;
|
|
Writes error to syslog
|
|
Example:
|
|
$c1 = getchildren($nodetocheck);
|
|
$c1 = getchildren($nodetocheck,$port);
|
|
Comments:
|
|
none
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------------------
|
|
|
|
my %PPCHASH;
|
|
sub getchildren
|
|
{
|
|
my $parent = shift;
|
|
if (($parent) && ($parent =~ /xCAT::/))
|
|
{
|
|
$parent = shift;
|
|
}
|
|
$::RUNCMD_RC = 0;
|
|
my $port = shift;
|
|
my @tabletype = qw(ppc zvm);
|
|
my @children = ();
|
|
my @children_port = ();
|
|
if (!%PPCHASH) {
|
|
my $ppctab = xCAT::Table->new( 'ppc' );
|
|
unless ($ppctab) { # cannot open the table return with error
|
|
xCAT::MsgUtils->message('S', "getchildren:Unable to open ppc table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
return undef;
|
|
}
|
|
my @ps = $ppctab->getAllNodeAttribs(['node','parent','nodetype','hcp']);
|
|
foreach my $entry ( @ps ) {
|
|
my $p = $entry->{parent};
|
|
my $c = $entry->{node};
|
|
my $t = $entry->{nodetype};
|
|
if ( $p and $c) {
|
|
if ($t) { # the nodetype exists in the ppc table, use it
|
|
if ( $t eq 'fsp' or $t eq 'bpa') {
|
|
# build hash of ppc.parent -> ppc.node
|
|
push @{$PPCHASH{$p}}, $c;
|
|
}
|
|
elsif ($t eq 'blade') {
|
|
push @{$PPCHASH{$c}}, $entry->{hcp};
|
|
}
|
|
} else { # go look in the nodetype table to find nodetype
|
|
my $type = getnodetype($c, "ppc");
|
|
if ( $type eq 'fsp' or $type eq 'bpa')
|
|
{
|
|
# build hash of ppc.parent -> ppc.node
|
|
push @{$PPCHASH{$p}}, $c;
|
|
}
|
|
elsif ($type eq "blade") {
|
|
push @{$PPCHASH{$c}}, $entry->{hcp};
|
|
}
|
|
}
|
|
} # not $p and $c
|
|
}
|
|
# Find parent in the hash and build return values
|
|
foreach (@{$PPCHASH{$parent}}) {
|
|
push @children, $_;
|
|
}
|
|
} else {
|
|
if (exists($PPCHASH{$parent})) {
|
|
foreach (@{$PPCHASH{$parent}}) {
|
|
push @children, $_;
|
|
}
|
|
}
|
|
}
|
|
# if port not input
|
|
if ( !defined($port ))
|
|
{
|
|
return \@children;
|
|
} else {
|
|
if (@children) {
|
|
my $vpdtab = xCAT::Table->new( 'vpd' );
|
|
unless ($vpdtab) { # cannot open the table return with error
|
|
xCAT::MsgUtils->message('S', "getchildren:Unable to open vpd table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
return undef;
|
|
}
|
|
my $sides = $vpdtab->getNodesAttribs(\@children, ['side']);
|
|
if(!$sides)
|
|
{
|
|
return undef;
|
|
}
|
|
foreach my $n (@children)
|
|
{
|
|
my $nside = $sides->{$n}->[0];
|
|
if ($nside->{side} =~ /$port/)
|
|
{
|
|
push @children_port, $n;
|
|
}
|
|
}
|
|
return \@children_port;
|
|
} else { # no children
|
|
return undef;
|
|
}
|
|
}
|
|
}
|
|
#-------------------------------------------------------------------------------
|
|
|
|
=head3 getnodetype
|
|
Query ppc table, if no type found query nodetype table
|
|
Arguments:
|
|
An array of nodenames or 1 nodename
|
|
Returns:
|
|
If the input is an array, it returns a hash,
|
|
for the nodes that can't get node type, it will be 'node' => undef;
|
|
If the input is not an array, it returns the value of type,
|
|
for the node that can't get node type, it will be undef;
|
|
Globals:
|
|
%NODETYPEHASH
|
|
Error:
|
|
$::RUNCMD_RC = 1;
|
|
Errors written to syslog
|
|
Example:
|
|
$type = xCAT::DBobjUtils->getnodetype($node, "ppc");
|
|
$type = xCAT::DBobjUtils->getnodetype($node);
|
|
$typerefer = xCAT::DBobjUtils->getnodetype(\@nodes, "PPC");
|
|
$typerefer = xCAT::DBobjUtils->getnodetype(\@nodes);
|
|
Comments:
|
|
none
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------------------
|
|
my %NODETYPEHASH;
|
|
sub getnodetype
|
|
{
|
|
my $nodes = shift;
|
|
if (($nodes) && ($nodes =~ /xCAT::/))
|
|
{
|
|
$nodes = shift;
|
|
}
|
|
my $table = shift;
|
|
my $rsp;
|
|
my @tabletype = qw(ppc zvm);
|
|
my %typehash;
|
|
my %tablehash;
|
|
$::RUNCMD_RC = 0;
|
|
|
|
my @failnodes;
|
|
my @failnodes1;
|
|
######################################################################
|
|
# if the table arg is set, go to the specified table first
|
|
# if can't get anything from the specified table, go to nodetype table
|
|
######################################################################
|
|
if ($table) {
|
|
my $nodetypetab = xCAT::Table->new( $table );
|
|
unless ($nodetypetab) {
|
|
xCAT::MsgUtils->message('S', "getnodetype:Unable to open $table table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
if ( $nodes =~ /^ARRAY/) {
|
|
foreach my $tn (@$nodes) {
|
|
$typehash{$tn} = undef;
|
|
}
|
|
} else {
|
|
$typehash{$nodes} = undef;
|
|
}
|
|
return \%typehash;
|
|
}
|
|
############################################
|
|
# if the input node arg is an array,
|
|
# query table and don't use the global hash
|
|
############################################
|
|
if ( $nodes =~ /^ARRAY/) {
|
|
my $nodetypes = $nodetypetab->getNodesAttribs($nodes, ['nodetype']);
|
|
foreach my $tn (@$nodes) {
|
|
my $gottype = $nodetypes->{$tn}->[0]->{'nodetype'};
|
|
if ( $gottype ) {
|
|
$NODETYPEHASH{$tn} = $gottype;
|
|
$typehash{$tn} = $gottype;
|
|
} else {
|
|
push @failnodes, $tn;
|
|
}
|
|
}
|
|
################################################
|
|
# for the failed nodes, go to nodetype table
|
|
################################################
|
|
if ( @failnodes ) {
|
|
my $typetable = xCAT::Table->new( 'nodetype' );
|
|
unless ($typetable) { # cannot open the table return with error
|
|
xCAT::MsgUtils->message('S', "getnodetype:Unable to open nodetype table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
foreach my $tn (@failnodes) {
|
|
$typehash{$tn} = undef;
|
|
}
|
|
} else {
|
|
my $nodetypes = $nodetypetab->getNodesAttribs(\@failnodes, ['nodetype']);
|
|
foreach my $tn ( @failnodes ) {
|
|
if ( $nodetypes->{$tn}->[0] ) {
|
|
$NODETYPEHASH{$tn} = $nodetypes->{$tn}->[0]->{'nodetype'};
|
|
$typehash{$tn} = $nodetypes->{$tn}->[0]->{'nodetype'};
|
|
} else {
|
|
push @failnodes1, $tn;
|
|
$typehash{$tn} = undef;
|
|
}
|
|
##################################################
|
|
# give error msg for the nodes can't get nodetype
|
|
##################################################
|
|
}
|
|
if ( @failnodes1 ) {
|
|
my $nodelist = join(",", @failnodes1);
|
|
xCAT::MsgUtils->message('S', "getnodetype:Can't find these nodes' type: $nodelist.\n");
|
|
}
|
|
}
|
|
}
|
|
#####################
|
|
# return the result
|
|
#####################
|
|
return \%typehash;
|
|
|
|
} else {
|
|
############################################
|
|
# if the input node arg is not an array,
|
|
# query table and use the global hash first
|
|
############################################
|
|
if ( $NODETYPEHASH{$nodes} ) {
|
|
return $NODETYPEHASH{$nodes};
|
|
} else {
|
|
my $typep = $nodetypetab->getNodeAttribs($nodes, ['nodetype']);
|
|
if ( $typep->{nodetype} ) {
|
|
$NODETYPEHASH{$nodes} = $typep->{nodetype};
|
|
return $typep->{nodetype};
|
|
} else { #if not find in the specified table, go to nodetype table
|
|
my $typetable = xCAT::Table->new( 'nodetype' );
|
|
unless ($typetable) { # cannot open the table return with error
|
|
xCAT::MsgUtils->message('S', "getnodetype:Unable to open nodetype table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
return undef;
|
|
}
|
|
my $typep = $typetable->getNodeAttribs($nodes, ['nodetype']);
|
|
if ( $typep->{nodetype} ) {
|
|
$NODETYPEHASH{$nodes} = $typep->{nodetype};
|
|
return $typep->{nodetype};
|
|
} else {
|
|
return undef;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
######################################################################
|
|
# if the table arg is not set, go to the nodetype table first
|
|
# if can't get anything from the specified table, go to nodetype table
|
|
######################################################################
|
|
my $nodetypetab = xCAT::Table->new( 'nodetype' );
|
|
unless ($nodetypetab) {
|
|
xCAT::MsgUtils->message('S', "getnodetype:Unable to open $table table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
if ( $nodes =~ /^ARRAY/) {
|
|
foreach my $tn (@$nodes) {
|
|
$typehash{$tn} = undef;
|
|
}
|
|
} else {
|
|
$typehash{$nodes} = undef;
|
|
}
|
|
return \%typehash;
|
|
}
|
|
############################################
|
|
# if the input node arg is an array,
|
|
# query table and don't use the global hash
|
|
############################################
|
|
if ( $nodes =~ /^ARRAY/) {
|
|
my $nodetypes = $nodetypetab->getNodesAttribs($nodes, ['nodetype']);
|
|
foreach my $tn (@$nodes) {
|
|
my $gottype = $nodetypes->{$tn}->[0]->{'nodetype'};
|
|
if ( $gottype) {
|
|
if ($gottype =~ /,/) { #if find ppc,osi
|
|
my @tbty = split /,/, $gottype;
|
|
foreach my $ttable (@tbty){
|
|
if (grep(/$ttable/, @tabletype)){
|
|
$tablehash{ $tn } = $ttable;
|
|
last;
|
|
}
|
|
}
|
|
} elsif (grep(/$gottype/, @tabletype)){ #if find ppc or zvm
|
|
$tablehash{ $tn } = $gottype;
|
|
} else {
|
|
$NODETYPEHASH{ $tn } = $gottype;
|
|
$typehash{ $tn } = $gottype;
|
|
}
|
|
} else {
|
|
$typehash{ $tn } = undef;
|
|
}
|
|
}
|
|
################################################
|
|
# for the failed nodes, go to related tables
|
|
################################################
|
|
if ( %tablehash ) {
|
|
foreach my $ttable (@tabletype) {
|
|
my @nodegroup;
|
|
foreach my $fnode (keys %tablehash) {
|
|
if ($tablehash{$fnode} eq $ttable) {
|
|
push @nodegroup, $fnode;
|
|
}
|
|
}
|
|
next unless (@nodegroup);
|
|
my $typetable = xCAT::Table->new( $ttable);
|
|
unless ($typetable) {
|
|
my $failnodes = join(",", @nodegroup);
|
|
xCAT::MsgUtils->message('S', "getnodetype:Unable to open $ttable table, can't find $failnodes type.\n");
|
|
$::RUNCMD_RC = 1;
|
|
foreach (@nodegroup) {
|
|
$typehash{$_} = undef;
|
|
}
|
|
} else {
|
|
my $typep = $typetable->getNodesAttribs(\@nodegroup, ['nodetype']);
|
|
foreach my $fn (@nodegroup) {
|
|
if ( $typep->{$fn}->[0]->{'nodetype'} ) {
|
|
$typehash{$fn} = $typep->{$fn}->[0]->{'nodetype'};
|
|
$NODETYPEHASH{$fn} = $typep->{$fn}->[0]->{'nodetype'};
|
|
} else {
|
|
$typehash{$fn} = undef;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return \%typehash;
|
|
} else { # if not an array
|
|
if ( $NODETYPEHASH{$nodes} ) {
|
|
return $NODETYPEHASH{$nodes};
|
|
} else {
|
|
my $typep = $nodetypetab->getNodeAttribs($nodes, ["nodetype"]);
|
|
if ( $typep->{nodetype} and !(grep(/$typep->{nodetype}/, @tabletype))) {
|
|
$NODETYPEHASH{$nodes} = $typep->{nodetype};
|
|
return $typep->{nodetype};
|
|
} elsif ( grep(/$typep->{nodetype}/, @tabletype) ) {
|
|
my $typetable = xCAT::Table->new( $typep->{nodetype} );
|
|
unless ($typetable) {
|
|
xCAT::MsgUtils->message('S', "getnodetype:Unable to open nodetype table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
return undef;
|
|
}
|
|
my $typep = $typetable->getNodeAttribs($nodes, ["nodetype"]);
|
|
if ( $typep->{nodetype} ) {
|
|
$NODETYPEHASH{$nodes} = $typep->{nodetype};
|
|
return $typep->{nodetype};
|
|
} else {
|
|
return undef;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#-------------------------------------------------------------------------------
|
|
|
|
=head3 getcecchildren
|
|
returns cec of the specified frame,
|
|
Arguments:
|
|
frame name
|
|
Returns:
|
|
Array of cec hostnames
|
|
Globals:
|
|
%PARENT_CHILDREN_CEC
|
|
Error:
|
|
none
|
|
Example:
|
|
@frame_members = getcecchildren($frame);
|
|
Comments:
|
|
none
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------------------
|
|
my %PARENT_CHILDREN_CEC;
|
|
sub getcecchildren
|
|
{
|
|
my $parent = shift;
|
|
if (($parent) && ($parent =~ /xCAT::/))
|
|
{
|
|
$parent = shift;
|
|
}
|
|
my @children = ();
|
|
if (!%PARENT_CHILDREN_CEC) {
|
|
my $ppctab = xCAT::Table->new( 'ppc' );
|
|
unless ($ppctab) { # cannot open the table return with error
|
|
xCAT::MsgUtils->message('S', "getcecchildren:Unable to open ppc table.\n");
|
|
$::RUNCMD_RC = 1;
|
|
return undef;
|
|
}
|
|
if ($ppctab)
|
|
{
|
|
my @ps = $ppctab->getAllNodeAttribs(['node','parent','nodetype']);
|
|
foreach my $entry ( @ps ) {
|
|
my $p = $entry->{parent};
|
|
my $c = $entry->{node};
|
|
my $t = $entry->{nodetype};
|
|
if ( $p and $c) {
|
|
if ($t) { # the nodetype exists in the ppc table, use it
|
|
if ( $t eq 'cec') {
|
|
# build hash of ppc.parent -> ppc.node
|
|
push @{$PARENT_CHILDREN_CEC{$p}}, $c;
|
|
}
|
|
} else { # go look in the nodetype table to find nodetype
|
|
my $type = getnodetype($c);
|
|
if ( $type eq 'cec') {
|
|
push @{$PARENT_CHILDREN_CEC{$p}}, $c;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
# find a match for the parent and build the return array
|
|
foreach (@{$PARENT_CHILDREN_CEC{$parent}}) {
|
|
push @children, $_;
|
|
}
|
|
return \@children;
|
|
}
|
|
} else { # already built the HASH
|
|
if (exists($PARENT_CHILDREN_CEC{$parent})) {
|
|
foreach (@{$PARENT_CHILDREN_CEC{$parent}}) {
|
|
push @children, $_;
|
|
}
|
|
return \@children;
|
|
}
|
|
}
|
|
return undef;
|
|
}
|
|
#-------------------------------------------------------------------------------
|
|
|
|
=head3 judge_node
|
|
judge the node is a real FSP/BPA,
|
|
use to distinguish if the data is defined in xCAT 2.5 or later
|
|
Arguments:
|
|
node name
|
|
Returns:
|
|
0 is a fake FSP/BPA,defined in xCAT 2.5
|
|
1 is a real FSP/BPA,defined in xCAT 2.6 or later
|
|
Error:
|
|
none
|
|
Example:
|
|
$result = judge_node($nodetocheck);
|
|
Comments:
|
|
none
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------------------
|
|
sub judge_node
|
|
{
|
|
my $node = shift;
|
|
if (($node) && ($node =~ /xCAT::/))
|
|
{
|
|
$node = shift;
|
|
}
|
|
my $type = shift;
|
|
my $flag = 0;
|
|
my $parenttype;
|
|
my $nodeparent;
|
|
my $ppctab = xCAT::Table->new( 'ppc' );
|
|
if ( $ppctab ) {
|
|
$nodeparent = $ppctab->getNodeAttribs($node, ["parent"]);
|
|
if ($nodeparent and $nodeparent->{parent}) {
|
|
$parenttype = getnodetype($nodeparent->{parent});
|
|
}
|
|
}
|
|
|
|
if ($type =~ /^fsp$/) {
|
|
if ($parenttype =~ /^cec$/)
|
|
{
|
|
$flag = 1;
|
|
} else
|
|
{
|
|
$flag = 0;
|
|
}
|
|
}
|
|
|
|
if ($type =~ /^bpa$/) {
|
|
if ($parenttype =~ /^frame$/)
|
|
{
|
|
$flag = 1;
|
|
} else
|
|
{
|
|
$flag = 0;
|
|
}
|
|
}
|
|
|
|
return $flag;
|
|
}
|
|
|
|
|
|
#-------------------------------------------------------------------------------
|
|
|
|
=head3 expandnicsattr
|
|
Expand the nics related attributes into the readable format,
|
|
for example, the nicsips=eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1
|
|
expanded format:
|
|
nicsips.eth0=1.1.1.1|2.1.1.1
|
|
nicsips.eth1=3.1.1.1|4.1.1.1
|
|
|
|
Arguments:
|
|
nicsattr value, like niccsips=eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1
|
|
nicnames: only return the value for specific nics, like "eth0,eth1"
|
|
Returns:
|
|
expanded format, like:
|
|
nicsips.eth0=1.1.1.1|2.1.1.1
|
|
nicsips.eth1=3.1.1.1|4.1.1.1
|
|
Error:
|
|
none
|
|
|
|
Example:
|
|
my $nicsstr = xCAT::DBobjUtils->expandnicsattr($attrval);
|
|
|
|
Comments:
|
|
none
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------------------
|
|
sub expandnicsattr()
|
|
{
|
|
my $nicstr = shift;
|
|
if (($nicstr) && ($nicstr =~ /xCAT::/))
|
|
{
|
|
$nicstr = shift;
|
|
}
|
|
my $nicnames = shift;
|
|
|
|
my $ret;
|
|
|
|
$nicstr =~ /^(.*?)=(.*?)$/;
|
|
|
|
#Attribute: nicips, nichostnamesuffix, etc.
|
|
my $nicattr = $1;
|
|
|
|
# Value: eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1
|
|
my $nicval=$2;
|
|
|
|
# $nicarr[0]: eth0!1.1.1.1|2.1.1.1
|
|
# $nicarr[1]: eth1!3.1.1.1|4.1.1.1
|
|
my @nicarr = split(/,/, $nicval);
|
|
|
|
foreach my $nicentry (@nicarr)
|
|
{
|
|
#nicentry: eth0!1.1.1.1|2.1.1.1
|
|
# $nicv[0]: eth0
|
|
# $nicv[1]: 1.1.1.1|2.1.1.1
|
|
my @nicv = split(/!/, $nicentry);
|
|
|
|
# only return nic* attr for these specific nics
|
|
if ($nicnames)
|
|
{
|
|
my @nics = split(/,/, $nicnames);
|
|
if ($nicv[0])
|
|
{
|
|
# Do not need to return the nic attr for this nic
|
|
if (!grep(/^$nicv[0]$/, @nics))
|
|
{
|
|
next;
|
|
}
|
|
}
|
|
}
|
|
|
|
# ignore the line that does not have nicname or value
|
|
if ($nicv[0] && $nicv[1])
|
|
{
|
|
$ret .= " $nicattr.$nicv[0]=$nicv[1]\n";
|
|
}
|
|
}
|
|
|
|
chomp($ret);
|
|
return $ret;
|
|
|
|
}
|
|
|
|
|
|
#-------------------------------------------------------------------------------
|
|
|
|
=head3 collapsenicsattr
|
|
Collapse the nics related attributes into the database format,
|
|
for example,
|
|
nicsips.eth0=1.1.1.1|2.1.1.1
|
|
nicsips.eth1=3.1.1.1|4.1.1.1
|
|
|
|
the collapsed format:
|
|
nicsips=eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1
|
|
|
|
The collapse will be done against the hash %::FILEATTRS or %::CLIATTRS,
|
|
remove the nicips.thx attributes from %::FILEATTRS or %::CLIATTRS,
|
|
add the collapsed info nicips into %::FILEATTRS or %::CLIATTRS.
|
|
|
|
Arguments:
|
|
$::FILEATTRS{$objname} or $::CLIATTRS{$objname}
|
|
$objname
|
|
|
|
Returns:
|
|
None, update %::FILEATTRS or %::CLIATTRS directly
|
|
|
|
Error:
|
|
none
|
|
|
|
Example:
|
|
xCAT::DBobjUtils->collapsenicsattr($nodeattrhash);
|
|
|
|
Comments:
|
|
none
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------------------
|
|
sub collapsenicsattr()
|
|
{
|
|
my $nodeattrhash = shift;
|
|
if (($nodeattrhash) && ($nodeattrhash =~ /xCAT::/))
|
|
{
|
|
$nodeattrhash = shift;
|
|
}
|
|
my $objname = shift;
|
|
|
|
my %nicattrs = ();
|
|
foreach my $nodeattr (keys %{$nodeattrhash})
|
|
{
|
|
# e.g nicips.eth0
|
|
# do not need to handle nic attributes without the postfix .ethx,
|
|
# it will be overwritten by the attributes with the postfix .ethx,
|
|
if ($nodeattr =~ /^(nic\w+)\.(\w+)$/)
|
|
{
|
|
if ($1 && $2)
|
|
{
|
|
# $nicattrs{nicips}{eth0} = "1.1.1.1|1.2.1.1"
|
|
$nicattrs{$1}{$2} = $nodeattrhash->{$nodeattr};
|
|
|
|
# remove nicips.eth0 from the %::FILEATTRS
|
|
delete $nodeattrhash->{$nodeattr};
|
|
}
|
|
}
|
|
}
|
|
# $nicattrs{'nicips'}{'eth0'} = "1.1.1.1|1.2.1.1"
|
|
# $nicattrs{'nicips'}{'eth1'} = "2.1.1.1|2.2.1.1"
|
|
foreach my $nicattr (keys %nicattrs)
|
|
{
|
|
my @tmparray = ();
|
|
foreach my $nicname (keys %{$nicattrs{$nicattr}})
|
|
{
|
|
# eth0!1.1.1.1|1.2.1.1
|
|
push @tmparray, "$nicname!$nicattrs{$nicattr}{$nicname}";
|
|
}
|
|
# eth0!1.1.1.1|1.2.1.1,eth1!2.1.1.1|2.2.1.1
|
|
$nodeattrhash->{$nicattr} = join(',', @tmparray);
|
|
}
|
|
}
|
|
|
|
1;
|