2
0
mirror of https://github.com/xcat2/xcat-core.git synced 2026-11-20 09:22:17 +00:00
Files
xcat-core/xCAT-server/lib/xcat/plugins/hosts.pm
T
Daniel Hilst 605705f285 fix(makehosts): an IPv6 node that changes address keeps both host entries
addnode and delnode find an existing host entry through the host-entry index,
and that index indexed node names only for an IPv4 first field and keyed the
address on its literal spelling. So makehosts left two entries for one node:
changing node01 from 2001:db8::10 to 2001:db8::20 added the second address and
kept the first, and an expanded IPv6 entry stayed when the compressed spelling
of the same address was added or deleted. The node resolved to a stale address.

_host_entry_matches handled both cases and no code called it. It is removed,
because a second place that compares an address is how this file reached this
state.

xCAT::NetworkUtils gains canonical_ip_address, which answers the one spelling
every spelling of an address shares. It is built on _pack_ip_address, so it
prefers core Socket and falls back to the optional Socket6. The index keys on
that answer, and it indexes node names for any first field whose shape is an
address.

On a host with no parser for IPv6 the canonical form is undefined and the
index keys on the literal. An address change written the same way still leaves
one entry, through the node name. An equivalent spelling becomes a second
entry, which is the limit of what such a host can decide.

makehosts_ipv6.t now runs addnode and delnode and reads the host entries they
produced. Eight of its 21 assertions fail against the previous index,
including the address change and both spelling-equivalence cases.

makehosts_index.t stubbed xCAT::NetworkUtils as an empty package. It loads the
real module, because the index now reads the canonical address from it.

Signed-off-by: Daniel Hilst <392820+dhilst@users.noreply.github.com>
2026-10-22 17:18:19 -03:00

1102 lines
32 KiB
Perl

# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
package xCAT_plugin::hosts;
use strict;
use warnings;
use xCAT::Table;
use xCAT::TableUtils;
use xCAT::Utils;
use xCAT::NetworkUtils;
require xCAT::MsgUtils;
use Data::Dumper;
use File::Copy;
use Getopt::Long;
use Fcntl ':flock';
my @hosts; #Hold /etc/hosts data to be written back
my %host_indexes_by_ip;
my %host_indexes_by_node;
my $LONGNAME;
my $OTHERNAMESFIRST;
my $ADDNAMES;
my $MACTOLINKLOCAL;
############# TODO - add return code checking !!!!!
sub handled_commands
{
return { makehosts => "hosts", };
}
sub _host_line_index_values
{
my $line = shift;
return unless defined($line);
my ($ip) = $line =~ /^(\S+)\s/;
return unless defined($ip);
# Every spelling of one address has to reach one key, or makehosts leaves
# a second entry when a node changes address. A host with no parser for
# the family gets the literal back, which is a match on the exact
# spelling and nothing wider.
my $canonical = xCAT::NetworkUtils->canonical_ip_address($ip);
my $key = defined($canonical) ? $canonical : $ip;
# The node index needs to know the first field is an address, which is a
# question about its shape. A dotted quad covers a legacy entry such as
# 010.1.1.1 that no parser accepts, and a colon covers an IPv6 literal on
# a host with no parser for one. A hostname in /etc/hosts has neither.
my @nodes;
if (defined($canonical) || $ip =~ /^\d+\.\d+\.\d+\.\d+$/ || $ip =~ /:/)
{
my ($primary_name) = $line =~ /^\S+\s+(\S+)/;
if (defined($primary_name))
{
# Preserve matching a short node against an FQDN-first entry.
my $offset = 0;
while ((my $dot = index($primary_name, '.', $offset)) >= 0)
{
push @nodes, substr($primary_name, 0, $dot);
$offset = $dot + 1;
}
push @nodes, $primary_name;
}
}
return ($key, \@nodes);
}
sub _index_host_line
{
my $idx = shift;
my ($ip, $nodes) = _host_line_index_values($hosts[$idx]);
return unless defined($ip);
$host_indexes_by_ip{$ip}{$idx} = 1;
foreach my $node (@{$nodes})
{
$host_indexes_by_node{$node}{$idx} = 1;
}
}
sub _unindex_host_line
{
my $idx = shift;
my ($ip, $nodes) = _host_line_index_values($hosts[$idx]);
return unless defined($ip);
if (exists($host_indexes_by_ip{$ip}))
{
delete $host_indexes_by_ip{$ip}{$idx};
delete $host_indexes_by_ip{$ip} unless keys %{ $host_indexes_by_ip{$ip} };
}
foreach my $node (@{$nodes})
{
if (exists($host_indexes_by_node{$node}))
{
delete $host_indexes_by_node{$node}{$idx};
delete $host_indexes_by_node{$node} unless keys %{ $host_indexes_by_node{$node} };
}
}
}
sub _rebuild_host_indexes
{
%host_indexes_by_ip = ();
%host_indexes_by_node = ();
foreach my $idx (0 .. $#hosts)
{
_index_host_line($idx);
}
}
sub _set_host_lines
{
my $lines = shift;
@hosts = @{$lines};
_rebuild_host_indexes();
return \@hosts;
}
sub _set_host_line
{
my ($idx, $line) = @_;
_unindex_host_line($idx);
$hosts[$idx] = $line;
_index_host_line($idx);
}
sub _push_host_line
{
my $line = shift;
push @hosts, $line;
_index_host_line($#hosts);
}
sub _matching_host_indexes
{
my ($node, $ip) = @_;
my %matches;
my $canonical = xCAT::NetworkUtils->canonical_ip_address($ip);
my $key = defined($canonical) ? $canonical : $ip;
if (defined($key) && exists($host_indexes_by_ip{$key}))
{
$matches{$_} = 1 foreach keys %{ $host_indexes_by_ip{$key} };
}
if (exists($host_indexes_by_node{$node}))
{
$matches{$_} = 1 foreach keys %{ $host_indexes_by_node{$node} };
}
my @indexes = sort { $a <=> $b } keys %matches;
return @indexes;
}
sub delnode
{
my $node = shift;
my $ip = shift;
unless ($node and $ip)
{
return;
} #bail if requested to do something that could zap /etc/hosts badly
my $othernames = shift;
my $domain = shift;
foreach my $idx (_matching_host_indexes($node, $ip))
{
_set_host_line($idx, "");
}
}
sub addnode
{
my $callback = shift;
my $node = shift;
my $ip = shift;
unless ($node and $ip)
{
return;
} #bail if requested to do something that could zap /etc/hosts badly
my $othernames = shift;
my $domain = shift;
my $nics = shift;
# if this ip was already added then just update the entry
my @matches = _matching_host_indexes($node, $ip);
if (@matches)
{
my $idx = shift @matches;
my $line;
if ($nics)
{
# we're processing the nics table and we found an
# existing entry for this ip so just add this
# node name as an alias for the existing entry
my $existing_line = $hosts[$idx];
chomp($existing_line);
my ($hip, $hnode, $hdom, $hother) = split(/ /, $existing_line);
$line = build_line($callback, $ip, $hnode, $domain, $othernames);
}
else
{
# otherwise just try to completely update the existing entry
$line = build_line($callback, $ip, $node, $domain, $othernames);
}
_set_host_line($idx, $line);
foreach my $duplicate_idx (@matches)
{
_set_host_line($duplicate_idx, "");
}
return;
}
my $line = build_line($callback, $ip, $node, $domain, $othernames);
if ($line) {
_push_host_line($line);
}
}
sub build_line
{
my $callback = shift;
my $ip = shift;
my $node = shift;
my $domain = shift;
my $othernames = shift;
my @o_names = ();
my @n_names = ();
if (defined $othernames)
{
# Trim spaces from the beginning and end from $othernames
$othernames =~ s/^\s+|\s+$//g;
# the "hostnames" attribute can be a list delimited by
# either a comma or a space
@o_names = split(/,| /, $othernames);
}
my $longname;
foreach (@o_names)
{
if (($_ eq $node) || ($domain && ($_ eq "$node.$domain")))
{
$longname = "$node.$domain";
$_ = "";
}
elsif ($_ =~ /\./)
{
if (!$longname)
{
$longname = $_;
$_ = "";
}
}
elsif ($ADDNAMES)
{
unshift(@n_names, "$_.$domain");
}
}
unshift(@o_names, @n_names);
my $shortname = $node;
if ($node =~ m/\.$domain$/i)
{
$longname = $node;
($shortname = $node) =~ s/\.$domain$//;
}
elsif ($domain && !$longname)
{
$shortname = $node;
$longname = "$node.$domain";
}
# if shortname contains a dot then we have a bad syntax for name
if ($shortname =~ /\./) {
my $rsp;
push @{ $rsp->{data} }, "Invalid short node name \'$shortname\'. The short node name may not contain a dot. The short node name is considered to be anything preceeding the network domain name in the fully qualified node name \'$longname\'.\n";
xCAT::MsgUtils->message("E", $rsp, $callback);
return undef;
}
$othernames = join(' ', @o_names);
if ($LONGNAME) { return "$ip $longname $shortname $othernames\n"; }
elsif ($OTHERNAMESFIRST) { return "$ip $othernames $longname $shortname\n"; }
else { return "$ip $shortname $longname $othernames\n"; }
}
sub addotherinterfaces
{
my $callback = shift;
my $node = shift;
my $otherinterfaces = shift;
my $domain = shift;
my @itf_pairs = split(/,/, $otherinterfaces);
foreach (@itf_pairs)
{
my ($itf, $ip);
if ($_ =~ /!/) {
($itf, $ip) = split(/!/, $_);
} else {
($itf, $ip) = split(/:/, $_);
}
if ($ip && xCAT::NetworkUtils->isValidIp($ip))
{
if ($itf =~ /^-/)
{
$itf = $node . $itf;
}
#lookup the domain for the ip address
#if failed, use the domain passed in
my ($mydomain,$mynet)=getIPdomain($ip);
if($mydomain){
$domain=$mydomain;
}
addnode $callback, $itf, $ip, '', $domain;
}
}
}
sub delotherinterfaces
{
my $node = shift;
my $otherinterfaces = shift;
my $domain = shift;
my @itf_pairs = split(/,/, $otherinterfaces);
foreach (@itf_pairs)
{
my ($itf, $ip);
if ($_ =~ /!/) {
($itf, $ip) = split(/!/, $_);
} else {
($itf, $ip) = split(/:/, $_);
}
if ($ip && xCAT::NetworkUtils->isValidIp($ip))
{
if ($itf =~ /^-/)
{
$itf = $node . $itf;
}
delnode $itf, $ip, '', $domain;
}
}
}
##!!!!!!!!!!!!!!!!!!!
# NOTE FOR CHANGING #
# This subroutine is called in ddns.pm, please take care the calling in ddns.pm
# for your changes, especially the change upon the subroutine interface
##!!!!!!!!!!!!!!!!!!!
sub add_hosts_content {
my %args = @_;
my $nodelist = $args{nodelist};
my $callback = $args{callback};
my $DELNODE = $args{delnode};
my $domain = $args{domain};
my $hoststab = xCAT::Table->new('hosts', -create => 0);
my $hostscache;
if ($hoststab) {
$hostscache = $hoststab->getNodesAttribs($nodelist,
[qw(ip node hostnames otherinterfaces)]);
}
foreach (@{$nodelist}) {
my $ref = $hostscache->{$_}->[0];
my $nodename = $_;
my $ip = $ref->{ip};
if (not $ip) {
$ip = xCAT::NetworkUtils->getipaddr($nodename); #attempt lookup
}
my $netn;
($domain, $netn) = &getIPdomain($ip, $callback);
if (!$domain) {
if ($::sitedomain) {
$domain = $::sitedomain;
} elsif ($::XCATSITEVALS{domain}) {
$domain = $::XCATSITEVALS{domain};
} else {
my $rsp;
push @{ $rsp->{data} }, "No domain can be determined for node \'$nodename\'. The domain of the xCAT node must be provided in an xCAT network definition or the xCAT site definition.\n";
xCAT::MsgUtils->message("W", $rsp, $callback);
next;
}
}
if ($DELNODE)
{
delnode $nodename, $ip, $ref->{hostnames}, $domain;
if (defined($ref->{otherinterfaces}))
{
delotherinterfaces $nodename, $ref->{otherinterfaces}, $domain;
}
}
else
{
if (xCAT::NetworkUtils->isValidIp($ip))
{
addnode $callback, $nodename, $ip, $ref->{hostnames}, $domain;
}
else
{
my $rsp;
if (!$ip)
{
push @{ $rsp->{data} }, "Ignoring node \'$nodename\', it can not be resolved.";
}
else
{
push @{ $rsp->{data} }, "Ignoring node \'$nodename\', its ip address \'$ip\' is not valid.";
}
xCAT::MsgUtils->message("W", $rsp, $callback);
}
if (defined($ref->{otherinterfaces}))
{
addotherinterfaces $callback, $nodename, $ref->{otherinterfaces}, $domain;
}
}
} #end foreach
if ($args{hostsref}) {
@{ $args{hostsref} } = @hosts;
}
}
#-------------------------------------------------------------------------------
=head3 add_all_hosts_content
Adds a host entry for every row of the hosts table.
Arguments:
hostents - reference to the list of hosts table rows
callback - the command callback
domain - the domain to use when a row resolves to none
Returns:
the node name of every row, in order
Comments:
makehosts with no noderange takes this path, so an address the entry
test rejects reaches no host entry at all.
=cut
#-------------------------------------------------------------------------------
sub add_all_hosts_content
{
my %args = @_;
my $hostents = $args{hostents};
my $callback = $args{callback};
my $domain = $args{domain};
my @allnodes;
foreach my $hostent (@{$hostents})
{
push @allnodes, $hostent->{node};
my $netn;
($domain, $netn) = &getIPdomain($hostent->{ip});
if (!$domain) {
$domain = $::sitedomain;
}
if (!$domain) {
$domain = $::XCATSITEVALS{domain};
}
if (xCAT::NetworkUtils->isValidIp($hostent->{ip}))
{
addnode $callback, $hostent->{node}, $hostent->{ip},
$hostent->{hostnames}, $domain;
}
else
{
my $rsp;
push @{ $rsp->{data} },
"Invalid IP Addr \'$hostent->{ip}\' for node \'$hostent->{node}\'.";
xCAT::MsgUtils->message("E", $rsp, $callback);
}
if (defined($hostent->{otherinterfaces}))
{
addotherinterfaces $callback, $hostent->{node},
$hostent->{otherinterfaces}, $domain;
}
}
return @allnodes;
}
sub process_request
{
Getopt::Long::Configure("bundling");
$Getopt::Long::ignorecase = 0;
Getopt::Long::Configure("no_pass_through");
my $req = shift;
my $callback = shift;
my $dr = shift;
my %extraargs = @_;
my $HELP;
my $VERSION;
my $REMOVE;
my $DELNODE;
my $usagemsg =
"Usage: makehosts <noderange> [-d] [-n] [-l] [-a] [-o] [-m]\n makehosts -h\n makehosts -v";
# parse the options
if ($req && $req->{arg}) { @ARGV = @{ $req->{arg} }; }
else { @ARGV = (); }
# print "argv=@ARGV\n";
if (
!GetOptions(
'h|help' => \$HELP,
'n' => \$REMOVE,
'd' => \$DELNODE,
'o|othernamesfirst' => \$OTHERNAMESFIRST,
'a|adddomaintohostnames' => \$ADDNAMES,
'm|mactolinklocal' => \$MACTOLINKLOCAL,
'l|longnamefirst' => \$LONGNAME,
'v|version' => \$VERSION,
)
)
{
if ($callback)
{
my $rsp = {};
$rsp->{data}->[0] = $usagemsg;
xCAT::MsgUtils->message("I", $rsp, $callback);
}
else
{
xCAT::MsgUtils->message("I", $usagemsg . "\n");
}
return;
}
# display the usage if -h
if ($HELP)
{
if ($callback)
{
my $rsp = {};
$rsp->{data}->[0] = $usagemsg;
xCAT::MsgUtils->message("I", $rsp, $callback);
}
else
{
xCAT::MsgUtils->message("I", $usagemsg . "\n");
}
return;
}
if ($VERSION)
{
my $version = xCAT::Utils->Version();
if ($callback)
{
my $rsp = {};
$rsp->{data}->[0] = $version;
xCAT::MsgUtils->message("I", $rsp, $callback);
}
else
{
xCAT::MsgUtils->message("I", $version . "\n");
}
return;
}
# get site FQDNfirst(Fully Qualified Domian Name)
my @FQDNfirst = xCAT::TableUtils->get_site_attribute("FQDNfirst");
if ((defined($FQDNfirst[0])) && ($FQDNfirst[0] =~ /^(1|yes|enable)$/i)) { $LONGNAME = "1"; }
# get site domain for backward compatibility
my @domain = xCAT::TableUtils->get_site_attribute("domain");
if ($domain[0]) {
$::sitedomain = $domain[0];
}
my $hoststab = xCAT::Table->new('hosts');
my $domain;
my $lockh;
# lockfile to prevent concurrent executions
open($lockh, ">", "/tmp/xcat/hostsfile.lock");
flock($lockh, LOCK_EX);
# save a backup copy
my $bakname = "/etc/hosts.xcatbak";
copy("/etc/hosts", $bakname);
my @host_lines;
if ($REMOVE)
{
# add the localhost entry if trying to create the /etc/hosts from scratch
if ($^O =~ /^aix/i)
{
push @host_lines, "127.0.0.1 loopback localhost\n";
}
else
{
push @host_lines, "127.0.0.1 localhost\n";
}
}
else
{
# the contents of the /etc/hosts file is saved in the @hosts array
# the @hosts elements are updated and used to re-create the
# /etc/hosts file at the end by the writeout subroutine.
my $rconf;
open($rconf, "/etc/hosts"); # Read file into memory
if ($rconf)
{
while (<$rconf>)
{
push @host_lines, $_;
}
close($rconf);
}
}
_set_host_lines(\@host_lines);
if ($req->{node})
{
if ($MACTOLINKLOCAL)
{
my $mactab = xCAT::Table->new("mac");
my $machash = $mactab->getNodesAttribs($req->{node}, ['mac']);
foreach my $node (keys %{$machash})
{
my $mac = $machash->{$node}->[0]->{mac};
if (!$mac)
{
next;
}
my $linklocal = xCAT::NetworkUtils->linklocaladdr($mac);
my $netn;
($domain, $netn) = &getIPdomain($linklocal, $callback);
if (!$domain) {
if ($::sitedomain) {
$domain = $::sitedomain;
} elsif ($::XCATSITEVALS{domain}) {
$domain = $::XCATSITEVALS{domain};
} else {
my $rsp;
push @{ $rsp->{data} }, "No domain can be determined for node \'$node\'. The domain of the xCAT node must be provided in an xCAT network definition or the xCAT site definition.\n";
xCAT::MsgUtils->message("W", $rsp, $callback);
next;
}
}
if ($DELNODE)
{
delnode $node, $linklocal, $node, $domain;
}
else
{
addnode $callback, $node, $linklocal, $node, $domain;
}
}
}
else
{
add_hosts_content(nodelist => $req->{node}, callback => $callback, delnode => $DELNODE, domain => $domain);
} # end else
# do the other node nics - if any
&donics(nodes => $req->{node}, callback => $callback, delnode => $DELNODE);
}
else
{
if ($DELNODE)
{
return;
}
my @hostents =
$hoststab->getAllNodeAttribs(
[ 'ip', 'node', 'hostnames', 'otherinterfaces' ]);
my @allnodes = add_all_hosts_content(
hostents => \@hostents,
callback => $callback,
domain => $domain
);
# also do nics table
&donics(nodes => \@allnodes, callback => $callback, delnode => $DELNODE);
}
writeout();
if ($lockh)
{
flock($lockh, LOCK_UN);
}
}
sub writeout
{
my $targ;
open($targ, '>', "/etc/hosts");
foreach (@hosts)
{
print $targ $_;
}
close($targ);
}
#-------------------------------------------------------------------------------
=head3 donics
Add the additional network interfaces for a list of nodes as
indicated in the nics table
Arguments:
node name
Returns:
0 - ok
1 - error
Globals:
Example:
my $rc = &donics(nodes=>\@allnodes, callback=>$callback, delnode=>$DELNODE);
Comments:
none
=cut
#-------------------------------------------------------------------------------
##!!!!!!!!!!!!!!!!!!!
# NOTE FOR CHANGING #
# This subroutine is called in ddns.pm, please take care the calling in ddns.pm
# for your changes, especially the change upon the subroutine interface
##!!!!!!!!!!!!!!!!!!!
sub donics
{
my %args = @_;
my $nodes = $args{nodes};
my $callback = $args{callback};
my $delnode = $args{delnode};
my @nodelist = @{$nodes};
my $nicstab = xCAT::Table->new('nics');
my $nettab = xCAT::Table->new('networks');
foreach my $node (@nodelist)
{
my $nich;
my %nicindex;
# get the nic info
my $et =
$nicstab->getNodeAttribs(
$node,
[
'nicips', 'nichostnamesuffixes',
'nichostnameprefixes',
'nicnetworks', 'nicaliases'
]
);
# only require IP for nic
if (!($et->{nicips})) {
next;
}
# gather nics info
# delimiter could be ":" or "!"
# new $et->{nicips} looks like
# "eth0!11.10.1.1,eth1!60.0.0.5|60.0.0.250..."
my @nicandiplist = split(',', $et->{'nicips'});
foreach (@nicandiplist)
{
my ($nicname, $nicip);
# if it contains a "!" then split on "!"
if ($_ =~ /!/) {
($nicname, $nicip) = split('!', $_);
} else {
($nicname, $nicip) = split(':', $_);
}
$nicindex{$nicname} = 0;
if (!$nicip) {
next;
}
#Only support format for nicips is :<nic1>!<ip1>|<ip2>|... or <nic1>!<one regular expression>
if ($nicip =~ /^\|\S*\|$/) {
$nicip = xCAT::Table::transRegexAttrs($node, $nicip);
}
if ($nicip =~ /\|/) {
my @ips = split(/\|/, $nicip);
foreach my $ip (@ips) {
$nich->{$nicname}->{nicip}->[ $nicindex{$nicname} ] = $ip;
$nicindex{$nicname}++;
}
} else {
$nich->{$nicname}->{nicip}->[ $nicindex{$nicname} ] = $nicip;
$nicindex{$nicname}++;
}
}
my @nicandsufx = split(',', $et->{'nichostnamesuffixes'});
my @nicandprfx = split(',', $et->{'nichostnameprefixes'});
foreach (@nicandsufx)
{
my ($nicname, $nicsufx);
if ($_ =~ /!/) {
($nicname, $nicsufx) = split('!', $_);
} else {
($nicname, $nicsufx) = split(':', $_);
}
if ($nicsufx =~ /\|/) {
my @sufs = split(/\|/, $nicsufx);
my $index = 0;
foreach my $suf (@sufs) {
$nich->{$nicname}->{nicsufx}->[$index] = $suf;
$index++;
}
} else {
$nich->{$nicname}->{nicsufx}->[0] = $nicsufx;
}
}
foreach (@nicandprfx)
{
my ($nicname, $nicprfx);
if ($_ =~ /!/) {
($nicname, $nicprfx) = split('!', $_);
} else {
($nicname, $nicprfx) = split(':', $_);
}
if (defined($nicprfx) && $nicprfx =~ /\|/) {
my @prfs = split(/\|/, $nicprfx);
my $index = 0;
foreach my $prf (@prfs) {
$nich->{$nicname}->{nicprfx}->[$index] = $prf;
$index++;
}
} else {
$nich->{$nicname}->{nicprfx}->[0] = $nicprfx;
}
}
# see if we need to fill in a default suffix
# nich has all the valid nics - ie. that have IPs provided!
foreach my $nic (keys %{$nich}) {
unless (defined($nicindex{$nic})) {
$nicindex{$nic} = 0;
}
for (my $i = 0 ; $i < $nicindex{$nic} ; $i++) {
if (!$nich->{$nic}->{nicsufx}->[$i] && !$nich->{$nic}->{nicprfx}->[$i]) {
if ($nic =~ /\./) {
my $rsp;
push @{ $rsp->{data} }, "$node: since \'$nic\' contains dot, nics.nichostnamesuffixes.$nic should be configured without dot for \'$nic\' interface.";
xCAT::MsgUtils->message("E", $rsp, $callback);
next;
}
# then we have no suffix at all for this
# so set a default
$nich->{$nic}->{nicsufx}->[$i] = "-$nic";
} elsif ($nich->{$nic}->{nicsufx}->[$i] && $nich->{$nic}->{nicsufx}->[$i] =~ /\./) {
my $rsp;
push @{ $rsp->{data} }, "$node: the value \'$nich->{$nic}->{nicsufx}->[$i]\' of nics.nichostnamesuffixes.$nic should not contain dot.";
xCAT::MsgUtils->message("E", $rsp, $callback);
delete $nich->{$nic}->{nicsufx}->[$i];
next;
} elsif ($nich->{$nic}->{nicprfx}->[$i] && $nich->{$nic}->{nicprfx}->[$i] =~ /\./) {
my $rsp;
push @{ $rsp->{data} }, "$node: the value \'$nich->{$nic}->{nicprfx}->[$i]\' of nics.nichostnameprefixes.$nic should not contain dot.";
xCAT::MsgUtils->message("E", $rsp, $callback);
delete $nich->{$nic}->{nicprfx}->[$i];
next;
}
}
}
my @nicandnetwrk = split(',', $et->{'nicnetworks'});
foreach (@nicandnetwrk)
{
my ($nicname, $netwrk);
if ($_ =~ /!/) {
($nicname, $netwrk) = split('!', $_);
} else {
($nicname, $netwrk) = split(':', $_);
}
if (!$netwrk) {
next;
}
if ($netwrk =~ /\|/) {
my @nets = split(/\|/, $netwrk);
my $index = 0;
foreach my $net (@nets) {
$nich->{$nicname}->{netwrk}->[$index] = $net;
$index++;
}
} else {
$nich->{$nicname}->{netwrk}->[0] = $netwrk;
}
}
my @nicandnicalias;
if (defined($et->{'nicaliases'})) {
@nicandnicalias = split(',', $et->{'nicaliases'});
}
foreach (@nicandnicalias)
{
my ($nicname, $aliases);
if ($_ =~ /!/) {
($nicname, $aliases) = split('!', $_);
} else {
($nicname, $aliases) = split(':', $_);
}
if (!$aliases) {
next;
}
# for example: nicaliases.ib0=|maestro-(\d+)$|m($1)-ib0|
if ($aliases =~ /^\|\S*\|$/) {
$aliases = xCAT::Table::transRegexAttrs($node, $aliases);
}
if ($aliases =~ /\|/) {
my @names = split(/\|/, $aliases);
my $index = 0;
foreach my $alias (@names) {
$nich->{$nicname}->{nicaliases}->[$index] = $alias;
$index++;
}
} else {
$nich->{$nicname}->{nicaliases}->[0] = $aliases;
}
}
# end gather nics info
# add or delete nic entries in the hosts file
foreach my $nic (keys %{$nich}) {
# make sure we have the short hostname
my $shorthost;
($shorthost = $node) =~ s/\..*$//;
for (my $i = 0 ; $i < $nicindex{$nic} ; $i++) {
my $nicip = "";
my $nicsuffix = "";
my $nicprefix = "";
my $nicnetworks = "";
my $nicaliases = "";
$nicip = $nich->{$nic}->{nicip}->[$i] if (defined($nich->{$nic}->{nicip}->[$i]));
$nicsuffix = $nich->{$nic}->{nicsufx}->[$i] if (defined($nich->{$nic}->{nicsufx}->[$i]));
$nicprefix = $nich->{$nic}->{nicprfx}->[$i] if (defined($nich->{$nic}->{nicprfx}->[$i]));
$nicnetworks = $nich->{$nic}->{netwrk}->[$i] if (defined($nich->{$nic}->{netwrk}->[$i]));
$nicaliases = $nich->{$nic}->{nicaliases}->[$i] if (defined($nich->{$nic}->{nicaliases}->[$i]));
if (!$nicip) {
next;
}
# construct hostname for nic
my $nichostname = "$nicprefix$shorthost$nicsuffix";
# get domain from network def provided by nic attr
my $nt = $nettab->getAttribs({ netname => "$nicnetworks" }, 'domain');
# look up the domain as a check or if it's not provided
my ($ndomain, $netn) = &getIPdomain($nicip, $callback);
if ($nt->{domain} && $ndomain) {
# if they don't match we may have a problem.
if ($nicnetworks ne $netn) {
my $rsp;
push @{ $rsp->{data} }, "The xCAT network name listed for
\'$nichostname\' is \'$nicnetworks\' however the nic IP address \'$nicip\' seems to be in the \'$netn\' network.\nIf there is an error then makes corrections to the database definitions and re-run this command.\n";
xCAT::MsgUtils->message("W", $rsp, $callback);
}
}
# choose a domain
my $nicdomain;
if ($ndomain) {
# use the one based on the ip address
$nicdomain = $ndomain;
} elsif ($nt->{domain}) {
# then try the one provided in the nics entry
$nicdomain = $nt->{domain};
} elsif ($::sitedomain) {
# try the site domain for backward compatibility
$nicdomain = $::sitedomain;
} elsif ($::XCATSITEVALS{domain}) {
$nicdomain = $::XCATSITEVALS{domain};
} else {
my $rsp;
push @{ $rsp->{data} }, "No domain can be determined for the NIC IP value of \'$nicip\'. The network domains must be provided in an xCAT network definition or the xCAT site definition.\n";
xCAT::MsgUtils->message("W", $rsp, $callback);
next;
}
if ($delnode)
{
delnode $nichostname, $nicip, '', $nicdomain;
}
else
{
addnode $callback, $nichostname, $nicip, $nicaliases, $nicdomain, 1;
}
} # end for each index
} # end for each nic
} # end for each node
if ($args{hostsref}) {
@{ $args{hostsref} } = @hosts;
}
$nettab->close;
$nicstab->close;
return 0;
}
#-------------------------------------------------------------------------------
=head3 getIPdomain
Find the xCAT network definition match the IP and then return the
domain value from that network def.
Arguments:
node IP
callback
Returns:
domain and netname - ok
undef - error
Globals:
Example:
my $rc = &getIPdomain($nodeIP, $callback);
Comments:
none
=cut
#-------------------------------------------------------------------------------
sub getIPdomain
{
my $nodeIP = shift;
my $callback = shift;
# get the network defs
my $nettab = xCAT::Table->new('networks');
my @nets = $nettab->getAllAttribs('netname', 'net', 'mask', 'domain');
# foreach network def
foreach my $enet (@nets)
{
my $NM = $enet->{'mask'};
my $net = $enet->{'net'};
if (xCAT::NetworkUtils->ishostinsubnet($nodeIP, $NM, $net))
{
return ($enet->{'domain'}, $enet->{'netname'});
last;
}
}
# could not find the network domain for this IP address
return undef;
}
1;