# main class for manage in the ansible pool
#
package bxNetworkNode;
use strict;
use warnings;
use Moose;
use File::Basename qw( dirname basename );
use File::Spec::Functions;
use Data::Dumper;
use Sys::Hostname;
use IO::Interface::Simple;
use bxNetwork;
use Pool;
use Output;
# network scheme fro localhost
has 'localhost_network' => (
is => 'ro',
lazy => 1,
builder => 'get_localhost_network',
);
has 'manager_interface' => (
is => 'ro',
isa => 'Str',
default => 'any',
);
has 'manager_ipaddress' => (
is => 'ro',
isa => 'Str',
default => 'any',
);
has 'manager_hostname' => (
is => 'ro',
isa => 'Str',
lazy => 1,
builder => 'get_localhost_hostname',
);
has 'debug' => (
is => 'ro',
isa => 'Int',
default => 0,
);
has 'logfile' => (
is => 'ro',
isa => 'Str',
default => '/opt/webdir/logs/manager_network.debug',
);
# list all running interfaces on localhost
sub get_localhost_network {
my $self = shift;
my $message_p = (caller(0))[3];
my %localhost_network = ();
my $exclude_address = qq(127\.0\.0\.1);
# get interfaces list
my @interfaces = IO::Interface::Simple->interfaces;
my $interfaces_count = 0;
foreach my $int (sort @interfaces){
if ($int->is_running && $int !~ /^lo/){
if($int->address !~ /^($exclude_address)$/){
$localhost_network{$int} = $int->address;
$interfaces_count++;
}
}
}
return [$interfaces_count, \%localhost_network],
}
# return hostname for localhost
# default hostname, but it can create it if used something incorrect (ex, localhost)
sub get_localhost_hostname {
my $self = shift;
my $hostname = hostname;
my $generated_hostname = qw(localhost|localhost.localdomain|127.0.0.1);
if ($hostname =~ /^($generated_hostname)$/){
return "server1";
}else{
return $hostname;
}
}
# replace localhost by generated hostname value
sub test_localhost_hostname{
my $name = shift;
my $generated_hostname = qw(localhost|localhost.localdomain|127.0.0.1);
if ($name =~ /^($generated_hostname)$/){
return "server1";
}else{
return $name;
}
}
# test A record for hostname
# convert hostname to ip addressi ( if complete we have right hash with:
# short_name => { int => fqdn_name }
# it is primary settings for pool manager
sub hostname_to_ip {
my $self = shift;
my $hostname = $self->manager_hostname;
# we new its generated name, doesn't check
my $ip = '';
if ($hostname !~ /^server1$/){
my $net = bxNetwork->new(host=>$hostname);
$ip = $net->a_lookup($hostname);
}
return $ip;
}
# test PTR record for defined interface
# convert ip address to hostname, use this hostname
# short_name => { int => fqdn_name }
sub ip_to_hostname {
my $self = shift;
my $interface = $self->manager_interface;
my $network = $self->localhost_network;
if($network->[0] == 0){
return [undef, undef];
}
# use first one
while ($interface =~ /^any$/){
foreach my $int (sort keys %{$network->[1]}){
$interface = $int;
}
}
my $ip_address = $network->[1]->{$interface};
my $net = bxNetwork->new(netaddr=>$ip_address);
my $return = [$interface, undef];
$return->[1] = $net->ptr_lookup($ip_address);
return $return;
}
# return
# network_name => { int => ip_address|fqdn }
sub create_network_options {
my $self = shift;
my $message_p = (caller(0))[3];
my $debug = $self->debug;
my $logOutput = Output->new(error => 0, logfile => $self->logfile);
my $interface = $self->manager_interface; # interface that used for pool, == any in default
my $hostname = $self->manager_hostname; # hostname, create hostname if not passed
if ($debug){
$logOutput->log_data(
"$message_p: input options interface=$interface hostname=$hostname"
);
}
$hostname = test_localhost_hostname($hostname);
my $local_net = $self->localhost_network; # return { int => ip_address }
if ($local_net->[0] == 0){
if ($debug){
$logOutput->log_data(
"$message_p: not found running interfaces on host $hostname"
);
}
return Output->new(
error => 1,
message => "$message_p: not found running interfaces on host $hostname",
);
}
# test if input interface is correct
my $is_correct_interface = 0; # interface that user defined exist on the server
if ($interface !~ /^any$/){
$is_correct_interface = grep /^$interface$/, (keys %{$local_net->[1]} );
if ($debug){
$logOutput->log_data(
"$message_p: not found running interface=$interface on host $hostname"
);
}
if ($is_correct_interface == 0){
return Output->new(
error => 1,
message => "$message_p: not found running interface=$interface on host $hostname",
);
}
}
# 1. try to convert hostname to ip_address
my $ip_address = $self->hostname_to_ip;
if($ip_address !~ /^$/){
if ($debug){
$logOutput->log_data(
"$message_p: found A record for hostname=$hostname; test ipaddress=$ip_address"
);
}
# test all intrefaces or one
my $is_local_interface = 0; # local interface contain ip address for hostname
my $is_the_input_intreface = 0; # interface that contain ip address it user defined for pool
my $ip_address_int = "";
# test if server contain ip address for hostname
foreach my $int (keys %{$local_net->[1]}){
if ($local_net->[1]->{$int} =~ /^$ip_address$/){
# input interfaces is owner for ip address
if($interface !~ /^any$/ && $int =~ /^$interface$/){
$is_local_interface = 1;
$is_the_input_intreface = 1;
$ip_address_int = $int;
# input interface is not owner for ip address
}elsif($interface !~ /^any$/ && $int !~ /^$interface$/){
$is_local_interface = 1;
$ip_address_int = $int;
# input interface is owner for ip address and user doesn't define prefered eth for pool
}elsif($interface =~ /^any$/){
$is_local_interface = 1;
$is_the_input_intreface = 1;
$ip_address_int = $int;
}
}
}
if ($debug){
$logOutput->log_data(
"$message_p: is_local_interface=$is_local_interface is_the_input_intreface=$is_the_input_intreface ip_address_int=$ip_address_int"
);
}
my $ident = $hostname;
#$ident =~ s/^([^\.]+)\..+$/$1/;
# use the same interface that hold DNS name
if ($is_local_interface == 1 && $is_the_input_intreface == 1){
if ($debug){
$logOutput->log_data(
"$message_p: return A: \{$ident => \{$ip_address_int => $hostname\}\}"
);
}
return Output->new(
error => 0,
data => ['pool_manager', {
ident => $ident,
interface => $ip_address_int,
netaddr => $local_net->[1]->{$ip_address_int},
fqdn => $hostname,
type => 'A'
}
],
);
# use user defined intreface, but it doesn't have ip address with dns name
}elsif($is_local_interface ==1 && $is_the_input_intreface == 0){
if ($debug){
$logOutput->log_data(
"$message_p: return SIMPLE: \{$ident => \{$interface => ".$local_net->[1]->{$interface}."\}\}"
);
}
return Output->new(
error => 0,
data => ['pool_manager', {
ident => $ident,
interface => $interface,
netaddr => $local_net->[1]->{$interface},
fqdn => $hostname,
type => 'SIMPLE'
}],
);
}else{
if ($debug){
$logOutput->log_data(
"$message_p: ip=$ip_address not belong to localhost"
);
}
return Output->new(
error => 1,
message => "$message_p: ip=$ip_address not belong to localhost; hostname=$hostname name can not be used, can cause errors in the configuration",
);
}
}
# cant't translate hostname to ip address
# try use ip address
my $dns_name = $self->ip_to_hostname;
# PTR record is found, use it name for pool configuration
if ($dns_name->[1] !~ /^$/){
my $ident = $dns_name->[1];
#$ident =~ s/^([^\.]+)\..+$/$1/;
if ($debug){
$logOutput->log_data(
"$message_p: found PTR record for interface dns_name=".$dns_name->[1]
);
$logOutput->log_data(
"$message_p: return A \{$ident => \{".$dns_name->[0]." => ".$dns_name->[1]."\}\}"
);
}
return Output->new(
error => 0,
data => ['pool_manager',{
ident => $ident,
interface => $dns_name->[0],
netaddr => $local_net->[1]->{$dns_name->[0]},
fqdn => $dns_name->[1],
type =>'PTR'
}
],
);
# PTR record not found use ip address of interface and input hostname(generated somtimes)
}else{
my $ident = $hostname;
#$ident =~ s/^([^\.]+)\..+$/$1/;
if ($debug){
$logOutput->log_data(
"$message_p: return SIMPLE \{$ident => \{".$dns_name->[0]." => ".$local_net->[1]->{$dns_name->[0]}."\}\}"
);
}
return Output->new(
error => 0,
data => ['pool_manager', {
ident => $ident,
interface => $dns_name->[0],
netaddr => $local_net->[1]->{$dns_name->[0]},
fqdn => $ident,
type =>'SIMPLE'
}],
);
}
}
# convert ip address to interface
sub ip_to_interface {
my $self = shift;
my $ip_address = shift;
my $message_p = (caller(0))[3];
my $debug = $self->debug;
my $logOutput = Output->new(error => 0, logfile => $self->logfile);
if (!$ip_address){
return Output->new(
error => 1,
message => "$message_p: ip_address is mandatory",
);
}
my $interface = $self->manager_interface; # interface that used for pool, == any in default
if($debug){
$logOutput->log_data(
"$message_p: try found interface for ip=$ip_address"
);
}
my $local_net = $self->localhost_network; # return { int => ip_address }
if ($local_net->[0] == 0){
if ($debug){
$logOutput->log_data(
"$message_p: not found running interfaces on host"
);
}
return Output->new(
error => 1,
message => "$message_p: not found running interfaces on host",
);
}
foreach my $int (keys %{$local_net->[1]}){
if ($local_net->[1]->{$int} =~ /^$ip_address$/){
if ($debug){
$logOutput->log_data(
"$message_p: found interface=$int for ip_address=$ip_address"
);
}
return Output->new(
error => 0,
data => ['pool_interface_revert',{netaddr=>$ip_address, interface => $int}],
);
}
}
return Output->new(
error => 1,
message => "$message_p: Not found ip address on localhost"
);
};
# list interfaces on localhost
sub list_interfaces {
my $self = shift;
my $message_p = (caller(0))[3];
my $local_net = $self->localhost_network; # return { int => ip_address }
if ($local_net->[0] == 0){
return Output->new(
error => 1,
message => "$message_p: not found running interfaces on host",
);
}
return Output->new(
error => 0,
data => ['pool_interfaces',$local_net->[1]]
);
}
sub interface_to_ip {
my $self = shift;
my $interface = shift;
my $message_p = (caller(0))[3];
my $local_net = $self->localhost_network; # return { int => ip_address }
#print Dumper($local_net);
if (not defined $local_net->[1]->{$interface}){
return Output->new(
error => 1,
message => "$message_p: not found running interface=$interface on host",
);
}
return Output->new(
error => 0,
data => ['pool_interfaces',{ interface => $interface, netaddr => $local_net->[1]->{$interface}}]
);
}
1;
Mini Shell