%PDF-
%PDF-
Mini Shell
Mini Shell
package Host;
use Moose;
use File::Basename qw( dirname basename );
use File::Spec::Functions;
use Data::Dumper;
use Output;
use JSON;
use Pool;
use bxInventory qw( get_from_yaml save_to_yaml );
has 'host', is => 'ro', isa => 'Str';
has 'ip', is => 'ro', isa => 'Str', lazy => 1, builder => 'get_ipaddress';
has 'debug', is => 'ro', lazy => 1, default => 0;
has 'logfile', is => 'ro', default => '/opt/webdir/logs/host_manage.debug';
# test if host with hostname in the pool
# 1 -> pool_not_created
# 2 -> host_not_in_pool
# 3 -> host_in_pool_not_in_group
# 0 -> host_in_pool
sub host_in_pool {
my ( $self, $group, $hostname ) = @_;
if ( not defined $hostname ) {
$hostname = $self->host;
}
$hostname =~ s/^["']//;
$hostname =~ s/["']$//;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $debug = $self->debug;
my $logOutput = Output->new( error => 0, logfile => $self->logfile );
my %returnMessage = (
1 => 'pool_not_created',
2 => 'host_not_in_pool',
3 => 'host_in_pool_not_in_group',
0 => 'host_in_group',
);
my $rt = 0;
my $pool = Pool->new();
my $getConfigData = $pool->get_ansible_data;
if ( $getConfigData->is_error > 0 ) {
$rt = 1;
if ($debug) { $logOutput->log_data("$message_p: pool is not created"); }
}
else {
if ($debug) {
$logOutput->log_data(
"$message_p: pool exists, try found host $hostname");
}
# get all data for hosts in the pool
my $configData = $getConfigData->get_data;
my $configHostData = $configData->[1]->{$hostname};
# no host :(
if ( !$configHostData ) {
$rt = 2;
if ($debug) {
$logOutput->log_data(
"$message_p: host $hostname not found in pool");
}
# host found
}
else {
# if group set => we need check group
if ( $group && $group !~ /^hosts$/ ) {
my $host_groups =
grep( /^$group$/, keys %{ $configHostData->{'roles'} } );
# roles not found = group not found
if ( $host_groups == 0 ) {
if ($debug) {
$logOutput->log_data(
"$message_p: host $hostname not found in $group");
}
$rt = 3;
}
}
}
}
if ($debug) {
$logOutput->log_data(
"$message_p: search finished, " . $returnMessage{$rt} );
}
return Output->new( error => $rt, message => $returnMessage{$rt} );
}
sub onfly_host_test {
my $self = shift;
my $shortname = shift;
my $netaddr = shift;
my $ipaddr = $netaddr;
if ( $netaddr !~ /^[\d\.]+$/ ) {
my $bx_net = bxNetwork->new( netaddr => $netaddr, host => $shortname );
$ipaddr = $bx_net->a_lookup($netaddr);
}
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $debug = $self->debug;
my $logOutput = Output->new( error => 0, logfile => $self->logfile );
if ($debug) { $logOutput->log_data("$message_p: start testing"); }
my $pool = Pool->new();
my $conf_data = $pool->get_ansible_data();
my $ans_data = $pool->set_ansible_conf();
if ( $conf_data->is_error ) { return $conf_data }
my @servers = sort keys %{ $conf_data->get_data->[1] };
if ($debug) {
$logOutput->log_data( "$message_p: found " . join( ',', @servers ) );
}
my $cmd_exec = $ans_data->{'ansible'};
my $cmd_module = 'bx_vat';
my $cmd_library = $ans_data->{'library'};
foreach my $server (@servers) {
if ($debug) {
$logOutput->log_data("$message_p: process server $server");
}
my $cmd_run =
qq($cmd_exec $server -m "$cmd_module" -M "$cmd_library" 2>/dev/null);
open( my $rh, "$cmd_run |" ) or next;
my $json_output = "";
while (<$rh>) {
if (/^$server\s*\|\s*(\S+)\s*\>\>\s*\{\s*/) {
my $result = $1;
if ( $result =~ /^success$/i ) {
$json_output = $json_output . "\{";
next;
}
}
if ( $json_output !~ /^$/ ) {
$json_output = $json_output . $_;
}
}
close $rh;
#print "|$json_output|\n";
if ( $json_output !~ /^$/ ) {
my $ansible_facts = from_json($json_output);
my $server_info = $ansible_facts->{'ansible_facts'};
for my $addr_info ( grep /^addr/, keys %$server_info ) {
my $addr_ip = $server_info->{$addr_info};
if ( $addr_ip =~ /^$ipaddr$/ ) {
my $int = $addr_info;
$int =~ s/^addr_//;
return Output->new(
error => 1,
message =>
"$message_t: $server already in the pool (ip=$addr_ip interface=$int)",
);
}
}
}
}
return Output->new(
error => 0,
message => "$message_t: $ipaddr not found"
);
}
# get info from ansible config
sub get_ipaddress {
my $self = shift;
my $hostname = $self->host;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $debug = $self->debug;
my $logOutput = Output->new( error => 0, logfile => $self->logfile );
my $test_host = $self->host_in_pool;
my $ipaddres = '';
if ($debug) {
$logOutput->log_data("$message_p: try found netaddress for $hostname");
}
# pool is not created = imossible, but :)
if ( $test_host->is_error == 1 ) {
if ($debug) {
$logOutput->log_data(
"$message_p: test host in the pool return error");
}
return $hostname;
# host not in the pool: get address from DNS server
}
elsif ( $test_host->is_error == 2 or $test_host->is_error == 3 ) {
my $bx_n = bxNetwork->new( host => $hostname );
my $bx_net_info = $bx_n->network_info;
if ( $bx_net_info->is_error ) {
if ($debug) {
$logOutput->log_data(
"$message_p: search netaddress by hostname return error");
}
return $hostname;
}
$ipaddres = $bx_net_info->get_data->[1]->{'netaddr'};
if ($debug) {
$logOutput->log_data(
"$message_p: host=$hostname netaddr=$ipaddres");
}
# get address from pool configuration
}
else {
my $bx_pool = Pool->new();
my $bx_data = $bx_pool->get_ansible_data;
my $bx_conf = $bx_data->get_data;
$ipaddres = $bx_conf->[1]->{$hostname}->{'ip'};
if ($debug) {
$logOutput->log_data(
"$message_p: host=$hostname netaddr=$ipaddres");
}
}
#print $ipaddres,"\n";
return $ipaddres;
}
sub get_bx_dbs {
my $self = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $hostname = Pool::esc_chars( $self->host );
my $pool = Pool->new();
my $ansData = $pool->set_ansible_conf();
my $cmd_play = $ansData->{'ansible'};
my $cmd_module = 'bx_db';
my $cmd_library = $ansData->{'library'};
my $cmd_run = qq($cmd_play $hostname -m "$cmd_module" -M "$cmd_library");
open( my $rh, "$cmd_run |" )
or return Output->new(
error => 1,
message => "$message_p: Cannot run $cmd_module on $hostname",
);
my $json_output = "";
while (<$rh>) {
if (/^$hostname\s*\|\s*(\S+)\s*\>\>\s*\{\s*/) {
my $result = $1;
if ( $result =~ /^success$/i ) {
$json_output = $json_output . "\{";
next;
}
else {
return Output->new(
error => 1,
message => "$message_p: \`$cmd_run\` return $result",
);
}
}
if ( $json_output !~ /^$/ ) {
$json_output = $json_output . $_;
}
}
close $rh;
my $ansible_facts = from_json($json_output);
my $server_info = $ansible_facts->{'ansible_facts'};
return Output->new(
error => 0,
data => [ 'dbs_list', { $hostname => $server_info } ],
);
}
sub get_bx_info {
my $self = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $hostname = Pool::esc_chars( $self->host );
my $pool = Pool->new();
my $ansData = $pool->set_ansible_conf();
my $cmd_play = $ansData->{'ansible'};
my $cmd_module = 'bx_vat';
my $cmd_library = $ansData->{'library'};
my $cmd_run =
qq($cmd_play $hostname -m "$cmd_module" -M "$cmd_library" 2>&1);
#print "$cmd_run\n";
open( my $rh, "$cmd_run |" )
or return Output->new(
error => 1,
message => "$message_p: Cannot run $cmd_module on $hostname",
);
my $json_output = "";
my $erro_output = "";
while (<$rh>) {
if ( /^$hostname\s*\|\s*(\S+)\s*\>\>\s*\{\s*/
or /^$hostname\s*\|\s*(\S+)\s*=\>(.*)$/ )
{
my $result = $1;
my $opt = ($2) ? $2 : "";
$opt =~ s/^\s+//;
$opt =~ s/\s+$//;
if ( $result =~ /^success$/i ) {
$json_output = $json_output . "\{";
next;
# vm03 | FAILED => SSH Error: ssh:
}
else {
return Output->new(
error => 1,
message => "$message_p: $opt",
);
}
}
elsif (/^No hosts matched$/) {
return Output->new(
error => 1,
message => "$message_p: Not found $hostname in the pool",
);
}
if ( $json_output !~ /^$/ ) {
$json_output = $json_output . $_;
}
}
close $rh;
my $ansible_facts = from_json($json_output);
my $server_info = $ansible_facts->{'ansible_facts'};
return Output->new(
error => 0,
data => [ 'bx_variables', { $hostname => $server_info } ],
);
}
# update data in the host vars file
sub update_host_vars {
my $self = shift;
my $options = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
# test if host exists
my $host = $self->host;
#print "1. test hot in pool\n";
my $host_status = $self->host_in_pool();
#print Dumper($host_status);
if ( $host_status->is_error ) {
return $host_status;
}
if ( not defined $options ) {
return Output->new(
error => 1,
message => "$message_p: Need defined hash with options list"
);
}
# get pool information
my $bx_pool = Pool->new();
my $an_data = $bx_pool->ansible_conf;
my $host_vars_path = catfile( $an_data->{'host_vars'}, $host );
my $host_vars_temp = $host_vars_path . ".temp";
my $host_vars_live = ( -f $host_vars_path ) ? 1 : 0;
my $inventory_data;
if ($host_vars_live){
my $get_inventory = get_from_yaml($host_vars_path);
if ( $get_inventory->is_error ) {
return $get_inventory;
}
$inventory_data = $get_inventory->data->[1];
}
##print "2. create updated and deleted options hash\n";
# return structure
my $updates = 0;
my $deletes = 0;
foreach my $k ( keys %$options ) {
next if ($k =~ /^(group|state|hostname)$/);
#print "$k => $options->{$k}\n";
# key=value
if (defined $options->{$k}){
if (defined $inventory_data->{$k}){
if ($inventory_data->{$k} ne $options->{$k}){
$inventory_data->{$k} = $options->{$k};
$updates++;
}
}
else {
$inventory_data->{$k} = $options->{$k};
$updates++;
}
}
# key
else {
if (defined $inventory_data->{$k}){
delete $inventory_data->{$k};
$deletes++;
}
}
}
# update values or create new
my $save_inventory = save_to_yaml($inventory_data, $host_vars_temp);
if ( $save_inventory->is_error ) {
return $save_inventory;
}
# rewrite origin file
unlink $host_vars_path if ($host_vars_live);
rename $host_vars_temp, $host_vars_path;
chmod 0640, $host_vars_path;
return Output->new(
error => 0,
message => "$message_p: "
. "File=$host_vars_path is modified; updates=$updates deletes=$deletes",
data => ["$message_p",
{updates => $updates, deletes => $deletes, file => $host_vars_path}]
);
}
# add host to group, if group not defined add host to pool
sub add_to_group {
my ( $self, $group, $is_update ) = @_;
if ( not defined $is_update ) {
$is_update = 0;
}
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $debug = $self->debug;
my $logOutput = Output->new( error => 0, logfile => $self->logfile );
my $hostname = $self->host;
my $ipaddres = $self->ip;
my $mess = ( defined $group ) ? "$group" : "hosts";
if ($debug) {
$logOutput->log_data("$message_p: start add host $hostname to $mess");
}
# create hostname if request by IP
if ( $mess =~ /^hosts$/ && $hostname =~ /^$ipaddres$/ ) {
# get localhost hostname and ip address
my $bx_n = bxNetwork->new( netaddr => $hostname );
my $bx_net_info = $bx_n->network_info;
if ( $bx_net_info->is_error ) { return $bx_net_info; }
$hostname = $bx_net_info->get_data->[1]->{'host'};
$ipaddres = $bx_net_info->get_data->[1]->{'netaddr'};
if ($debug) {
$logOutput->log_data(
"$message_p: update hostname=$hostname netaddr=$ipaddres");
}
}
my $status = $self->host_in_pool( $group, $hostname );
## 0 => host exists in defined group
if ( !$status->is_error ) {
if ($debug) {
$logOutput->log_data("$message_p: host $hostname in $mess");
}
return Output->new(
error => 0,
message => "$message_p: $hostname already in $mess",
);
}
## 1 => pool is not created
if ( $status->is_error == 1 ) {
if ($debug) { $logOutput->log_data("$message_p: pool is not created"); }
return $status;
}
my $pool = Pool->new();
my $ansData = $pool->set_ansible_conf();
my $bxData = $pool->set_bitrix_conf();
my $cfgData = $pool->get_ansible_data();
my $mStatus = $pool->monitorStatus()->get_data()->[1]->{monitoring_status};
#print Dumper($cfgData);
my $section_prefix = $bxData->{'aHostsPrefix'};
# create updated_groups
my %updated_groups;
if ( defined $group ) {
$updated_groups{$group} = 0;
}
# 2 => host not in main group hosts ( update $group and hosts)
if ( $status->is_error == 2 ) {
$updated_groups{ $bxData->{'aHostsDefault'} } = 0;
if ($debug) {
$logOutput->log_data(
"$message_p: need add $hostname to hosts group");
}
}
# add host to group(s):
my $ans_hosts_path = $ansData->{'hosts'};
my $ans_hosts_temp = $ans_hosts_path . ".tmp";
open( my $hh, $ans_hosts_path )
or return Output->new(
error => 2,
message => "$message_p: Cannot open $ans_hosts_path: $!"
);
open( my $th, ">$ans_hosts_temp" )
or return Output->new(
error => 2,
message => "$message_p: Cannot open $ans_hosts_temp: $!"
);
# create temporary file with new data
while (<$hh>) {
s/^\s+//;
s/\s+$//;
print $th $_, "\n";
if (/^\[$section_prefix\-([^\]]+)\]$/) {
my $found = $1;
if ( grep /^$found$/, keys %updated_groups ) {
print $th "$hostname ansible_ssh_host=$ipaddres\n";
$updated_groups{$found} = 1;
if ($debug) {
$logOutput->log_data("$message_p: add host to $found");
}
}
}
}
close $hh;
close $th;
# test if all updates done
foreach my $k ( keys %updated_groups ) {
if ( $updated_groups{$k} == 0 ) {
if ($debug) {
$logOutput->log_data("$message_p: not updated $k. exit");
}
return Output->new(
error => 1,
message => "$message_p: Cannot update group $k",
);
}
}
# create backup for current config and replace it by temporary file
if ( $is_update == 0 ) {
unlink $ans_hosts_path;
rename $ans_hosts_temp, $ans_hosts_path;
# run common playbook
# set network, time
my $cmd_play = $ansData->{'playbook'};
my $cmd_conf = catfile( $ansData->{'base'}, "common.yml" );
my $cmd_type = "common";
if ( defined $mStatus && $mStatus eq "enable" ) {
$cmd_conf = catfile( $ansData->{'base'}, "monitor.yml" );
$cmd_type = "monitor";
}
# run as daemon in background
my $dh = bxDaemon->new( task_cmd => qq($cmd_play $cmd_conf) );
if ($debug) {
$logOutput->log_data(
"$message_p: start common task for new $hostname");
}
my $created_process = $dh->startProcess($cmd_type)->get_data()->[1];
my ($task_id) = grep {!/^task_name$/} keys %$created_process;
my $task_pid = $created_process->{$task_id}->{pid};
my $task_status = $created_process->{$task_id}->{status};
return Output->new(
error => 0,
message => "$message_p: succefully added $hostname to group(s)",
data => [ 'hosts_file', $ans_hosts_path, [$task_id, $task_pid, $task_status] ]
);
}
else {
if ($debug) {
$logOutput->log_data(
"$message_p: succefully added $hostname to group(s)");
}
return Output->new(
error => 0,
message => "$message_p: succefully added $hostname to group(s)",
data => [ 'hosts_file', $ans_hosts_temp ]
);
}
}
# delete host from group, if group not defined - delete from all pool groups
# 1 => 'pool_not_created',
# 2 => 'host_not_in_pool',
# 3 => 'host_in_pool_not_in_group',
# 0 => 'host_in_group',
sub del_from_group {
my $self = shift;
my $group = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $debug = $self->debug;
my $logOutput = Output->new( error => 0, logfile => $self->logfile );
my $hostname = $self->host;
# test if host in the pool
my $status = $self->host_in_pool($group);
my $mess = ( defined $group ) ? "$group" : "hosts";
if ( $status->is_error ) {
return Output->new(
error => 0,
message => "$message_p: $hostname not found in group $mess"
);
}
# get pool configuration
my $bx_pool = Pool->new();
my $ans_conf = $bx_pool->set_ansible_conf();
my $bx_conf = $bx_pool->set_bitrix_conf();
my $pool_conf = $bx_pool->get_ansible_data();
if ( $pool_conf->is_error ) { return $pool_conf; }
# test if host hold roles
my $host_conf = $pool_conf->get_data->[1]->{$hostname};
my @host_roles = sort keys %{ $host_conf->{'roles'} };
my $host_roles = @host_roles;
if ( $mess =~ /^hosts$/ && $host_roles > 0 ) {
return Output->new(
error => 1,
message =>
"$message_t: Cannot delete host $hostname, it hold next roles: "
. join( ', ', @host_roles )
);
}
# group names options
my $section_prefix = $bx_conf->{'aHostsPrefix'};
my $section_default = $bx_conf->{'aHostsDefault'};
# ansible playbook settings
my $cmd_play = $ans_conf->{'playbook'};
my $cmd_conf = catfile( $ans_conf->{'base'}, "common.yml" );
# remove ssh options from server is main group
if ( $mess =~ /^hosts$/ ) {
my $cmd_opt = "common_server=$hostname common_manage=remove";
my $cmd_run = qq($cmd_play $cmd_conf -e "$cmd_opt" 1>/dev/null 2>&1);
system($cmd_run) == 0
or return Output->new(
error => 1,
message =>
"$message_p: Cannot remove ssh options from host $hostname",
);
}
# delete host from group
my $ans_hosts_path = $ans_conf->{'hosts'};
my $ans_hosts_temp = $ans_hosts_path . ".tmp";
open( my $hh, $ans_hosts_path )
or return Output->new(
error => 1,
message => "$message_p: Cannot open $ans_hosts_path: $!"
);
open( my $th, ">$ans_hosts_temp" )
or return Output->new(
error => 1,
message => "$message_p: Cannot open $ans_hosts_temp: $!"
);
# create temporary file with new data
# if group defined = > delete only from this group
# else delete from all group in the pool
my $pool_config_changed = 0;
my $section_name = "";
my $is_deleted_section = 0;
while (<$hh>) {
chomp;
s/^\s+//;
s/\s+$//;
my $str = $_;
# section pool is found
if ( $str =~ /^\[$section_prefix-([^\]]+)\]/ ) {
$section_name = $1;
$is_deleted_section = 1; # default delete
# change opinion about the removal
if ( $group
&& $group !~ /^$section_default$/
&& $section_name !~ /^$group$/ )
{
$is_deleted_section = 0;
}
}
# option found
if ( /^$hostname\s+(.+)$/ && $is_deleted_section == 1 ) {
$pool_config_changed++;
next;
}
print $th $_, "\n";
}
close $hh;
close $th;
if ( $pool_config_changed == 0 ) {
return Output->new(
error => 3,
message => "$message_p: Cannot delete host from the group $mess"
);
}
# backup and rename
rename $ans_hosts_path, $ans_hosts_path . ".bak";
rename $ans_hosts_temp, $ans_hosts_path;
# update security option on hosts that left in the pool
my $dh = bxDaemon->new( task_cmd => qq($cmd_play $cmd_conf) );
my $created_process = $dh->startProcess('common');
return Output->new(
error => 0,
message => "$message_p: successful deleted host $hostname from pool"
);
}
sub removeHostFromPool {
my $self = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $debug = $self->debug;
my $logOutput = Output->new( error => 0, logfile => $self->logfile );
my $hostname = $self->host;
# test if host in the pool
my $status = $self->host_in_pool();
if ( $status->is_error ) {
return Output->new(
error => 0,
message => "$message_p: $hostname not found in the pool."
);
}
# get pool configuration
my $bx_pool = Pool->new();
my $ans_conf = $bx_pool->set_ansible_conf();
my $pool_conf = $bx_pool->get_ansible_data();
if ( $pool_conf->is_error ) { return $pool_conf; }
# test if host hold roles
my $host_conf = $pool_conf->get_data->[1]->{$hostname};
my @host_roles = sort keys %{ $host_conf->{'roles'} };
my $host_roles = @host_roles;
if ( $host_roles > 0 ) {
return Output->new(
error => 1,
message =>
"$message_t: Cannot delete host $hostname, it hold next roles: "
. join( ', ', @host_roles )
);
}
# ansible playbook settings
my $cmd_play = $ans_conf->{'playbook'};
my $cmd_conf = catfile( $ans_conf->{'base'}, "common.yml" );
# clean up ssh configuration, ansible variables and etc,
my $opts = {
common_server => $hostname,
common_manage => 'remove',
};
my $dh = bxDaemon->new(
debug => $self->debug,
task_cmd => qq($cmd_play $cmd_conf)
);
my $created_process = $dh->startAnsibleProcess( "remove_$hostname", $opts );
return $created_process;
}
# create host in the pool
sub createHost {
my $self = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
my $debug = $self->debug;
my $logOutput = Output->new( error => 0, logfile => $self->logfile );
my $err_regexp = '(localhost|127\.0\.0\.\d+|localhost.localdomain)';
my $hostname = $self->host;
my $ipaddres = $self->ip;
if (not defined $hostname){
return Output->new(
error => 1,
message => "Cannot use empty hostname"
)
}
if ($debug) {
$logOutput->log_data(
"$message_p: start created host hostname=$hostname netaddr=$ipaddres"
);
}
# if user try add host=127.0.0.1 => ERROR
if ( $hostname =~ /^$err_regexp$/ || $ipaddres =~ /^$err_regexp$/ ) {
if ($debug) {
$logOutput->log_data(
"$message_p: cannot add to pool hostname=$hostname netaddr=$ipaddres"
);
}
return Output->new(
error => 1,
message => "$message_p: cannot use $hostname for add",
);
}
# generate host options
my $po = Pool->new();
my $host_id = $po->generate_host_id;
my $host_pass = $po->generate_host_password($hostname);
my $options = {
group => 'hosts',
host_id => $host_id,
host_pass => $host_pass,
bx_hostname => $hostname,
bx_netaddr => $ipaddres,
bx_connect => 'ipv4',
bx_netname => $hostname,
};
#print Dumper($options);
# if user input the same netaddress and hostname
# case1: hostname=example.org and ipaddress=example.org
# case2: hostname=1.2.3.4 ipaddres=1.2.3.4
if ( $hostname =~ /^$ipaddres$/ ) {
# case1: example.org
if ( $hostname !~ /^[\d\.]+$/ ) {
# get ipaddress
my $bx_n = bxNetwork->new( netaddr => $ipaddres );
$options->{'bx_netaddr'} = $bx_n->a_lookup($hostname);
if ( $options->{'bx_netaddr'} =~ /^$/ ) {
return Output->new(
error => 1,
message => "$message_p: $hostname is not a valid DNS name",
);
}
$options->{'bx_connect'} = 'fqdn';
# case2: 1.2.3.4 - we must defined correct hostname and ident for host
}
else {
my $bx_n = bxNetwork->new( netaddr => $ipaddres );
my $bx_net_info = $bx_n->network_info;
if ( $bx_net_info->is_error ) { return $bx_net_info; }
my $bx_net_data = $bx_net_info->get_data->[1];
my $type = $bx_net_data->{'type'};
if ( $type =~ /^fqdn$/ ) {
$options->{'bx_hostname'} = $bx_net_data->{'netaddr'};
$options->{'bx_netname'} = $bx_net_data->{'netaddr'};
}
else {
$options->{'bx_hostname'} = $bx_net_data->{'host'};
$options->{'bx_netname'} = $bx_net_data->{'host'};
}
if ($debug) {
$logOutput->log_data(
"$message_p: change hostname=$hostname to "
. $options->{'bx_netname'} );
}
}
# hostname=example ip=example.org
# or
# hostname example ip=1.2.3.4
}
else {
#$options->{'bx_hostname'} =~ s/^([^\.]+)\..+/$1/;
# test fqdn name: example.org
if ( $ipaddres !~ /^[\d\.]+$/ ) {
my $bx_n = bxNetwork->new( netaddr => $ipaddres );
$options->{'bx_netaddr'} = $bx_n->a_lookup($ipaddres);
if ( $options->{'bx_netaddr'} =~ /^$/ ) {
return Output->new(
error => 1,
message => "$message_p: $ipaddres is not a valid DNS name",
);
}
$options->{'bx_connect'} = 'fqdn';
$options->{'bx_netname'} = $ipaddres;
}
}
my $new_host = Host->new(
host => $options->{'bx_hostname'},
ip => $options->{'bx_netaddr'}
);
# test instance by its working option (not saved in the config files)
#my $test_all_host_ints = $new_host->onfly_host_test($hostname, $ipaddres);
#if ($test_all_host_ints->is_error){ return $test_all_host_ints };
# add host to group if one defined
my $group_mod = "no";
my $update_group = $new_host->add_to_group( $options->{'group'} );
if ($debug) { $logOutput->log_data("$message_p: add host to group hosts"); }
my $update_group_data = $update_group->get_data();
my $task_id = "";
my $task_pid = 0;
my $task_status = "";
if (defined $update_group_data->[2]){
$task_id = $update_group_data->[2]->[0];
$task_pid = $update_group_data->[2]->[1];
$task_status = $update_group_data->[2]->[2];
}
if ( $update_group->is_error ) {
return $update_group;
}
$group_mod = "yes";
#print Dumper($new_host);
my $host_mod = "no";
my $update_host = $new_host->update_host_vars($options);
#print Dumper($update_host);
if ( $update_host->is_error ) {
return $update_host;
}
if ($debug) { $logOutput->log_data("$message_p: update host vars"); }
$host_mod = "yes";
return Output->new(
error => 0,
message =>
"$message_p: modification was successful,"
. " host_vars=$host_mod, hosts=$group_mod"
. " task_id=$task_id task_pid=$task_pid task_status=$task_status",
data => [ $message_p, { hosts => $group_mod, host_vars => $host_mod } ]
);
}
# update host info by defined options
sub updateHost {
my $self = shift;
my $options = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
# test if host exists
my $host = $self->host;
# add host to group if one defined
my $group_mod = "no";
if ( defined $options->{'group'} ) {
my $update_group = $self->add_to_group( $options->{'group'} );
if ( $update_group->is_error ) {
return $update_group;
}
$group_mod = "yes";
}
# update additional variables if it defined
#print Dumper($options);
my $plus_option = grep( !/^(state|group|hostname)$/, keys %$options );
my $host_mod = "no";
if ( $plus_option > 0 ) {
my $update_host = $self->update_host_vars($options);
if ( $update_host->is_error ) {
return $update_host;
}
$host_mod = "yes";
}
return Output->new(
error => 0,
message =>
"$message_p: modification was successful, host_vars=$host_mod, hosts=$group_mod",
data => [ $message_p, { hosts => $group_mod, host_vars => $host_mod } ]
);
}
# delete host from group
sub deleteHost {
my $self = shift;
my $options = shift;
my $message_p = ( caller(0) )[3];
my $message_t = __PACKAGE__;
# test if host exists
my $group_mod = "no";
if ( defined $options->{'group'} ) {
my $update_group = $self->del_from_group( $options->{'group'} );
if ( $update_group->is_error ) {
return $update_group;
}
$group_mod = "yes";
}
# update additional variables if it defined
my $plus_option = grep( !/^(state|group|hostname)$/, keys %$options );
my $host_mod = "no";
if ( $plus_option > 0 ) {
my $update_host = $self->update_host_vars($options);
if ( $update_host->is_error ) {
return $update_host;
}
$host_mod = "yes";
}
return Output->new(
error => 0,
message =>
"$message_p: modification was successful, host_vars=$host_mod, hosts=$group_mod",
data => [ $message_p, { hosts => $group_mod, host_vars => $host_mod } ]
);
}
1;
Zerion Mini Shell 1.0