2724 lines
98 KiB
Perl
Executable File
2724 lines
98 KiB
Perl
Executable File
#!/usr/bin/perl
|
|
#
|
|
# This is called when striker, a node or a DR host needs to configure the local network and user accounts.
|
|
#
|
|
# Exit codes;
|
|
# 0 = Normal exit.
|
|
# 1 = The program is not running as root.
|
|
# 2 = Failed to connect to database(s).
|
|
# 3 = Job was already picked up by another running instance.
|
|
# 4 = The host name did not update properly.
|
|
# 5 = Failed to write the temp file with the new password needed to call anvil-change-password.
|
|
# 6 = The job-uuid was not found.
|
|
# 7 = The host is an active cluster member.
|
|
# 8 = Duplicate NICs assigned to the same MAC address
|
|
#
|
|
# TODO:
|
|
# - Add MTU support
|
|
# - Check to see if this is a cluster node and/or running VMs, and if so, refuse to run.
|
|
#
|
|
|
|
use strict;
|
|
use warnings;
|
|
use Anvil::Tools;
|
|
use Data::Dumper;
|
|
use Text::Diff;
|
|
|
|
my $THIS_FILE = ($0 =~ /^.*\/(.*)$/)[0];
|
|
my $running_directory = ($0 =~ /^(.*?)\/$THIS_FILE$/)[0];
|
|
if (($running_directory =~ /^\./) && ($ENV{PWD}))
|
|
{
|
|
$running_directory =~ s/^\./$ENV{PWD}/;
|
|
}
|
|
|
|
# Turn off buffering so that the pinwheel will display while waiting for the SSH call(s) to complete.
|
|
$| = 1;
|
|
|
|
my $anvil = Anvil::Tools->new();
|
|
|
|
# Read switches
|
|
$anvil->Get->switches({list => [
|
|
"job-uuid",
|
|
"debug",
|
|
], man => $THIS_FILE});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => $anvil->data->{switches}});
|
|
|
|
if (($anvil->data->{switches}{debug}) && (not -e $anvil->data->{path}{configs}{'anvil.debug'}))
|
|
{
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, key => "log_0843", variables => {
|
|
file => $anvil->data->{path}{configs}{'anvil.debug'},
|
|
host => $anvil->Get->short_host_name(),
|
|
}});
|
|
my $problem = $anvil->Storage->write_file({
|
|
file => $anvil->data->{path}{configs}{'anvil.debug'},
|
|
body => "",
|
|
overwrite => 1,
|
|
user => "root",
|
|
group => "root",
|
|
mode => "0666",
|
|
});
|
|
}
|
|
|
|
# Make sure we're running as 'root'
|
|
# $< == real UID, $> == effective UID
|
|
if (($< != 0) && ($> != 0))
|
|
{
|
|
# Not root
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, 'print' => 1, key => "error_0005"});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
# Make sure that we set the network->wait_on_network() timeout to 60 seconds.
|
|
$anvil->Storage->update_config({
|
|
append => 1,
|
|
variable => "network::wait_on_network::timeout",
|
|
value => 60,
|
|
});
|
|
|
|
# Because we're working with the network config, we can't reliable use cached connections.
|
|
$anvil->data->{sys}{net}{always_reconnect} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, secure => 1, list => {
|
|
"sys::net::always_reconnect" => $anvil->data->{sys}{net}{always_reconnect},
|
|
}});
|
|
|
|
# Connect
|
|
$anvil->Database->connect({check_for_resync => 1});
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "message_0031"});
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, 'print' => 1, key => "log_0132"});
|
|
if (not $anvil->data->{sys}{database}{connections})
|
|
{
|
|
# No databases, exit.
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, 'print' => 1, key => "error_0003"});
|
|
$anvil->nice_exit({exit_code => 2});
|
|
}
|
|
|
|
pickup_job_details($anvil);
|
|
overwrite_variables_with_switches($anvil);
|
|
|
|
# Set maintenance mode
|
|
#$anvil->System->maintenance_mode({set => 1});
|
|
|
|
# Reconfigure the network.
|
|
reconfigure_network($anvil);
|
|
|
|
# Record that we've configured this machine.
|
|
$anvil->Database->insert_or_update_variables({
|
|
variable_name => "system::configured",
|
|
variable_value => 1,
|
|
variable_default => "",
|
|
variable_description => "striker_0048",
|
|
variable_section => "system",
|
|
variable_source_uuid => $anvil->data->{sys}{host_uuid},
|
|
variable_source_table => "hosts",
|
|
});
|
|
|
|
update_passwords($anvil);
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
});
|
|
|
|
# Make sure that we set the network->wait_on_network() timeout back to 180.
|
|
$anvil->Storage->update_config({
|
|
append => 1,
|
|
variable => "network::wait_on_network::timeout",
|
|
value => 180,
|
|
});
|
|
|
|
# Clear maintenance mode.
|
|
$anvil->System->maintenance_mode({set => 0});
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, 'print' => 1, key => "log_0467"});
|
|
|
|
$anvil->nice_exit({exit_code => 0});
|
|
|
|
|
|
#############################################################################################################
|
|
# Functions #
|
|
#############################################################################################################
|
|
|
|
# This does a reboot.
|
|
sub do_reboot
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
# Tell the user why we're rebooting
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 5}),
|
|
message => "message_0388",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
});
|
|
my $time_left = 60;
|
|
while ($time_left)
|
|
{
|
|
# Give them the countdown.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "log_0626",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { seconds => $time_left },
|
|
});
|
|
sleep 10;
|
|
$time_left -= 10;
|
|
}
|
|
|
|
# Last, log that we're going down now.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0389",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
});
|
|
my $shell_call = $anvil->data->{path}{exe}{systemctl}." reboot";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call, source => $THIS_FILE, line => __LINE__});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { output => $output, return_code => $return_code }});
|
|
|
|
return(0);
|
|
}
|
|
|
|
# This updates the passwords on the root user, admin user, database and striker-ui-api user.
|
|
sub update_passwords
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
# Have we been asked to set a password?
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, secure => 1, list => {
|
|
"config::striker_password" => $anvil->data->{config}{striker_password},
|
|
}});
|
|
if ($anvil->data->{config}{striker_password})
|
|
{
|
|
# Set the passwords
|
|
my $password = $anvil->data->{config}{striker_password};
|
|
my $temp_file = "/tmp/anvil-".$anvil->Get->uuid;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, secure => 1, list => { password => $password }});
|
|
|
|
# Write the password into a temporary file.
|
|
my $error = $anvil->Storage->write_file({
|
|
body => $password,
|
|
file => $temp_file,
|
|
group => "root",
|
|
mode => "0600",
|
|
overwrite => 1,
|
|
secure => 1,
|
|
user => "root",
|
|
});
|
|
|
|
# Call anvil-change-password
|
|
if ($error)
|
|
{
|
|
# Couldn't write the temp file.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "message_0030",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { file => $temp_file },
|
|
});
|
|
$anvil->nice_exit({exit_code => 5});
|
|
}
|
|
else
|
|
{
|
|
my $wait_until = time + 120;
|
|
my $waiting = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
waiting => $waiting,
|
|
wait_until => $wait_until,
|
|
}});
|
|
while ($waiting)
|
|
{
|
|
my $shell_call = $anvil->data->{path}{exe}{'anvil-change-password'}." -y --password-file ".$temp_file.$anvil->Log->switches;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
|
|
my ($output, $return_code) = $anvil->System->call({
|
|
debug => 2,
|
|
timeout => 30,
|
|
shell_call => $shell_call });
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
if ($return_code)
|
|
{
|
|
# Something went wrong
|
|
if (time > $wait_until)
|
|
{
|
|
# Give up.
|
|
$waiting = 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { waiting => $waiting }});
|
|
}
|
|
else
|
|
{
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, 'print' => 1, key => "error_0011", variables => { return_code => $return_code }});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# Success
|
|
$waiting = 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { waiting => $waiting }});
|
|
}
|
|
}
|
|
|
|
# Unlink the temp file.
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "log_0263", variables => { file => $temp_file }});
|
|
unlink $temp_file;
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "log_0283"});
|
|
}
|
|
}
|
|
|
|
$anvil->Job->update_progress({
|
|
progress => 95,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
});
|
|
|
|
return(0);
|
|
}
|
|
|
|
# This does the work of reconfiguring the network
|
|
sub reconfigure_network
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
my $local_host = $anvil->Get->short_host_name();
|
|
my $prefix = $anvil->data->{config}{prefix};
|
|
my $sequence = $anvil->data->{config}{sequence};
|
|
my $domain = $anvil->data->{config}{domain};
|
|
my $new_host_name = $anvil->data->{config}{host_name};
|
|
my $organization = $anvil->data->{config}{organization};
|
|
my $bcn_count = $anvil->data->{config}{bcn_count};
|
|
my $ifn_count = $anvil->data->{config}{ifn_count};
|
|
my $sn_count = $anvil->data->{config}{sn_count};
|
|
my $mn_count = $anvil->data->{config}{mn_count};
|
|
my $type = $anvil->Get->host_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
prefix => $prefix,
|
|
sequence => $sequence,
|
|
domain => $domain,
|
|
organization => $organization,
|
|
bcn_count => $bcn_count,
|
|
sn_count => $sn_count,
|
|
mn_count => $mn_count,
|
|
ifn_count => $ifn_count,
|
|
new_host_name => $new_host_name,
|
|
type => $type,
|
|
}});
|
|
|
|
# If we're configuring a dashboard and no host name was given, generate it.
|
|
if (($type eq "striker") && (not $new_host_name))
|
|
{
|
|
$new_host_name = $prefix."-striker".sprintf("%02d", $sequence).".".$domain;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_host_name => $new_host_name }});
|
|
}
|
|
|
|
if ($new_host_name)
|
|
{
|
|
my $type_name = "";
|
|
if ($type eq "striker")
|
|
{
|
|
$type_name = $anvil->Words->string({key => "brand_0003"});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { type_name => $type_name }});
|
|
}
|
|
elsif ($type eq "node")
|
|
{
|
|
$type_name = $anvil->Words->string({key => "brand_0007"});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { type_name => $type_name }});
|
|
}
|
|
elsif ($type eq "dr")
|
|
{
|
|
$type_name = $anvil->Words->string({key => "brand_0008"});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { type_name => $type_name }});
|
|
}
|
|
my $pretty_host_name = $new_host_name;
|
|
if (($organization) && ($sequence))
|
|
{
|
|
$pretty_host_name = $organization." - ".$type_name." ".sprintf("%02d", $sequence);
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { pretty_host_name => $pretty_host_name }});
|
|
}
|
|
|
|
# Set the host_name
|
|
my ($host_name, $descriptive_host_name) = $anvil->System->host_name({set => $new_host_name, pretty => $pretty_host_name});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => {
|
|
host_name => $host_name,
|
|
descriptive_host_name => $descriptive_host_name,
|
|
}});
|
|
if ($host_name eq $new_host_name)
|
|
{
|
|
# Success
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 5}),
|
|
message => "message_0016",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { host_name => $new_host_name },
|
|
});
|
|
}
|
|
else
|
|
{
|
|
# Failed
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "message_0017",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_status => "failed",
|
|
variables => {
|
|
host_name => $new_host_name,
|
|
bad_host_name => $host_name,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 4});
|
|
}
|
|
}
|
|
|
|
# Now configure the network.
|
|
my $dns = $anvil->data->{config}{dns} ? [split/,/, $anvil->data->{config}{dns}] : [];
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { dns => $dns }});
|
|
for (my $i = 0; $i < @{$dns}; $i++)
|
|
{
|
|
$dns->[$i] = $anvil->Words->clean_spaces({ string => $dns->[$i] });
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "dns->[$i]" => $dns->[$i] }});
|
|
}
|
|
|
|
my $gateway = $anvil->data->{config}{gateway};
|
|
my $gateway_interface = $anvil->data->{config}{gateway_interface};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => {
|
|
gateway => $gateway,
|
|
gateway_interface => $gateway_interface,
|
|
}});
|
|
|
|
# If there is no default gateway device, and one of the interfaces are set to DHCP, use it.
|
|
if (not $gateway_interface)
|
|
{
|
|
# IFN first, BCN second, SN last
|
|
foreach my $network_type ("ifn", "bcn", "sn", "mn")
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
|
|
my $count = 0;
|
|
if ($network_type eq "bcn") { $count = $bcn_count; }
|
|
elsif ($network_type eq "sn") { $count = $sn_count; }
|
|
elsif ($network_type eq "ifn") { $count = $ifn_count; }
|
|
elsif ($network_type eq "mn") { $count = $mn_count; }
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { count => $count }});
|
|
|
|
next if not $count;
|
|
foreach my $network_count (1..$count)
|
|
{
|
|
my $ip_key = $network_type.$network_count."_ip";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { ip_key => $ip_key }});
|
|
|
|
if ((exists $anvil->data->{config}{$ip_key}) && ($anvil->data->{config}{$ip_key} eq "dhcp"))
|
|
{
|
|
$gateway_interface = $network_type.$network_count;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { gateway_interface => $gateway_interface }});
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Before we continue, see if there's two interfaces pointing at the same NIC. If so, the node would
|
|
# endlessly reboot.
|
|
my $macs = {};
|
|
my $query = "
|
|
SELECT
|
|
variable_uuid,
|
|
variable_name,
|
|
variable_value
|
|
FROM
|
|
variables
|
|
WHERE
|
|
variable_name LIKE '\%_mac_to_set::value'
|
|
AND
|
|
variable_source_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)."
|
|
ORDER BY
|
|
variable_name ASC;";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }});
|
|
my $results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__});
|
|
my $count = @{$results};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
results => $results,
|
|
count => $count,
|
|
}});
|
|
foreach my $row (@{$results})
|
|
{
|
|
my $variable_uuid = $row->[0];
|
|
my $variable_name = $row->[1];
|
|
my $variable_value = $row->[2];
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:variable_uuid' => $variable_uuid,
|
|
's2:variable_name' => $variable_name,
|
|
's3:variable_value' => $variable_value,
|
|
}});
|
|
|
|
# An undefined interface will have the MAC address value set to '1', ignore those.
|
|
next if $variable_value eq "1";
|
|
|
|
if ($variable_name =~ /form::config_step2::(.*?)_mac_to_set::value/)
|
|
{
|
|
my $device = lc($1);
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { device => $device}});
|
|
|
|
if (not exists $macs->{$variable_value})
|
|
{
|
|
$macs->{$variable_value} = $device;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
"macs->${variable_value}" => $macs->{$variable_value},
|
|
}});
|
|
}
|
|
else
|
|
{
|
|
# Fail out!
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0376",
|
|
job_status => "failed",
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
mac_address => $variable_value,
|
|
iface1 => $macs->{$variable_value},
|
|
iface2 => $device,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 8});
|
|
}
|
|
}
|
|
}
|
|
|
|
# We'll set this to '1' if we reconfigure the network
|
|
$anvil->data->{sys}{reboot} = 0;
|
|
|
|
# Read the existing network data
|
|
$anvil->Network->collect_data({debug => 2, start => 1});
|
|
|
|
# This will be set to '1' if we make a change.
|
|
my $changes = 0;
|
|
my $new_interfaces = [];
|
|
|
|
my $network_type = $anvil->System->check_network_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
|
|
# Configure the network using Network Manager
|
|
reconfigure_interfaces($anvil);
|
|
|
|
### NOTE: If we're not a striker, the update the job to say we're disconnecting to
|
|
### reconfigure the network.
|
|
my $host_type = $anvil->Get->host_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { host_type => $host_type }});
|
|
if ($host_type ne "striker")
|
|
{
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({set => 50}),
|
|
message => "message_0415",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
});
|
|
$anvil->Database->disconnect({debug => 2});
|
|
}
|
|
|
|
# These can brake the connection.
|
|
$anvil->data->{sys}{restart_nm} = 0;
|
|
reconfigure_bonds($anvil);
|
|
reconfigure_bridges($anvil);
|
|
reconfigure_ip_addresses($anvil);
|
|
|
|
# Sleep a few seconds, and then restart NetworkManager.service.
|
|
my $nm_running = $anvil->System->check_daemon({debug => 2, daemon => "NetworkManager.service"});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
nm_running => $nm_running,
|
|
'sys::restart_nm' => $anvil->data->{sys}{restart_nm},
|
|
}});
|
|
if (($anvil->data->{sys}{restart_nm}) or (not $nm_running))
|
|
{
|
|
$anvil->System->stop_daemon({debug => 2, daemon => "NetworkManager.service"});
|
|
$anvil->System->start_daemon({debug => 2, daemon => "NetworkManager.service"});
|
|
sleep 2;
|
|
}
|
|
|
|
# Reconnect!
|
|
if ($host_type ne "striker")
|
|
{
|
|
my $time_now = time;
|
|
my $restart_nm_time = $time_now + 30;
|
|
my $wait_until = $time_now + 60;
|
|
my $nm_restarted = 0;
|
|
my $waiting = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:time_now' => $time_now,
|
|
's2:restart_nm_time' => $restart_nm_time,
|
|
's3:wait_until' => $wait_until,
|
|
}});
|
|
while ($waiting)
|
|
{
|
|
$anvil->refresh();
|
|
$anvil->Database->connect();
|
|
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "sys::database::connections" => $anvil->data->{sys}{database}{connections} }});
|
|
if ($anvil->data->{sys}{database}{connections})
|
|
{
|
|
# We're back!
|
|
$waiting = 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { waiting => $waiting }});
|
|
}
|
|
else
|
|
{
|
|
# Sleep for a bit.
|
|
my $now_time = time;
|
|
my $time_left = $wait_until - $now_time;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
now_time => $now_time,
|
|
time_left => $time_left,
|
|
}});
|
|
if ($time_left > 0)
|
|
{
|
|
if (($now_time > $restart_nm_time) && (not $nm_restarted))
|
|
{
|
|
# Kick the network
|
|
$nm_restarted = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { nm_restarted => $nm_restarted }});
|
|
|
|
# Restart the daemon
|
|
$anvil->System->stop_daemon({debug => 2, daemon => "NetworkManager.service"});
|
|
$anvil->System->start_daemon({debug => 2, daemon => "NetworkManager.service"});
|
|
}
|
|
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "log_0829", variables => { time_left => $time_left }});
|
|
sleep 2;
|
|
}
|
|
else
|
|
{
|
|
# Give up and reboot.
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "warning_0169"});
|
|
|
|
# Don't use 'do_reboot()' as we've got no DB connection.
|
|
my $shell_call = $anvil->data->{path}{exe}{systemctl}." reboot";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 1, list => { shell_call => $shell_call }});
|
|
|
|
# We should be dead by now...
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call, source => $THIS_FILE, line => __LINE__});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { output => $output, return_code => $return_code }});
|
|
}
|
|
}
|
|
}
|
|
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({set => 75}),
|
|
message => "message_0416",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
});
|
|
}
|
|
|
|
# If any virtio bridges exist, remove it/them.
|
|
my $start = 0;
|
|
my $shell_call = $anvil->data->{path}{exe}{setsid}." --wait ".$anvil->data->{path}{exe}{virsh}." net-list";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
|
|
my ($bridges, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { bridges => $bridges, return_code => $return_code }});
|
|
if ($return_code)
|
|
{
|
|
### NOTE: We're doing a bunch of deletes, so to be safe we statically define the directory
|
|
### here.
|
|
# Libvirtd isn't running, check the directory directly.
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "log_0478"});
|
|
my $directory = "/etc/libvirt/qemu/networks/autostart";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { directory => $directory }});
|
|
|
|
if (-d $directory)
|
|
{
|
|
# Delete all files.
|
|
local(*DIRECTORY);
|
|
opendir(DIRECTORY, $directory);
|
|
while(my $file = readdir(DIRECTORY))
|
|
{
|
|
next if $file eq ".";
|
|
next if $file eq "..";
|
|
my $full_path = $directory."/".$file;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => {
|
|
file => $file,
|
|
full_path => $full_path,
|
|
}});
|
|
if (-l $full_path)
|
|
{
|
|
# It's a symlink, remove it.
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "log_0479", variables => { 'symlink' => $full_path }});
|
|
unlink $full_path;
|
|
if (-l $full_path)
|
|
{
|
|
# It didn't work...
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 0, priority => "err", key => "error_0132", variables => { 'symlink' => $full_path }});;
|
|
}
|
|
}
|
|
}
|
|
closedir(DIRECTORY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach my $line (split/\n/, $bridges)
|
|
{
|
|
$line = $anvil->Words->clean_spaces({string => $line});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { line => $line }});
|
|
if ($line =~ /^----------/)
|
|
{
|
|
$start = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { start => $start }});
|
|
next;
|
|
}
|
|
next if not $start;
|
|
my $bridge = ($line =~ /(.*?)\s/)[0];
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { bridge => $bridge }});
|
|
|
|
$anvil->data->{virsh}{bridge}{$bridge} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "virsh::bridge::$bridge" => $anvil->data->{virsh}{bridge}{$bridge} }});
|
|
}
|
|
|
|
foreach my $bridge (sort {$a cmp $b} keys %{$anvil->data->{virsh}{bridge}})
|
|
{
|
|
# Destroy (stop) it.
|
|
my ($destroy, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{setsid}." --wait ".$anvil->data->{path}{exe}{virsh}." net-destroy ".$bridge});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { destroy => $destroy, return_code => $return_code }});
|
|
|
|
# Disable it from auto-start.
|
|
(my $disable, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{setsid}." --wait ".$anvil->data->{path}{exe}{virsh}." net-autostart ".$bridge." --disable"});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { disable => $disable, return_code => $return_code }});
|
|
|
|
# Undefine (delete)
|
|
(my $undefine, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{setsid}." --wait ".$anvil->data->{path}{exe}{virsh}." net-undefine ".$bridge});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { undefine => $undefine, return_code => $return_code }});
|
|
}
|
|
}
|
|
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
});
|
|
|
|
return(0);
|
|
}
|
|
|
|
sub reconfigure_bridges
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "log_0853"});
|
|
my $local_host = $anvil->Get->short_host_name();
|
|
my $bcn_count = $anvil->data->{config}{bcn_count};
|
|
my $ifn_count = $anvil->data->{config}{ifn_count};
|
|
my $type = $anvil->Get->host_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
local_host => $local_host,
|
|
bcn_count => $bcn_count,
|
|
ifn_count => $ifn_count,
|
|
type => $type,
|
|
}});
|
|
|
|
if ($type eq "striker")
|
|
{
|
|
# No bridges on strikers.
|
|
return(0);
|
|
}
|
|
|
|
foreach my $network_type ("bcn", "ifn")
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
my $count = 0;
|
|
if ($network_type eq "bcn") { $count = $bcn_count; }
|
|
elsif ($network_type eq "ifn") { $count = $ifn_count; }
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { count => $count }});
|
|
|
|
# This is the old type of network config
|
|
foreach my $i (1..$count)
|
|
{
|
|
### TODO: This is almost always going to be on the bond, but we need to handle
|
|
### bridges on interfaces on DR hosts.
|
|
my $bridge_name = $network_type.$i."_bridge1";
|
|
my $on_device = $network_type.$i."_bond1";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
bridge_name => $bridge_name,
|
|
on_device => $on_device,
|
|
}});
|
|
|
|
# Checking if the bridge exists and that it is on the requested device
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0400",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
bridge_name => $bridge_name,
|
|
on_device => $on_device,
|
|
},
|
|
});
|
|
|
|
if (exists $anvil->data->{nmcli}{bridge}{$bridge_name})
|
|
{
|
|
# The bridge exists.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0401",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {},
|
|
});
|
|
}
|
|
else
|
|
{
|
|
# If there are ifcfg files for this bridge, move it.
|
|
my $network_type = $anvil->System->check_network_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
if ($network_type eq "ifcfg")
|
|
{
|
|
my $ifcfg_file = $anvil->data->{path}{directories}{ifcfg}."/ifcfg-".$bridge_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { ifcfg_file => $ifcfg_file }});
|
|
if (-f $ifcfg_file)
|
|
{
|
|
# It exists, move it.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0417",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
variables => { file => $ifcfg_file },
|
|
});
|
|
$anvil->Storage->backup({file => $ifcfg_file});
|
|
unlink $ifcfg_file;
|
|
}
|
|
}
|
|
|
|
# Create the bridge.
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection add type bridge con-name ".$bridge_name." ifname ".$bridge_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
|
|
if ($return_code)
|
|
{
|
|
# Failed to add the bridge
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0485",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => {
|
|
bridge_name => $bridge_name,
|
|
return_code => $return_code,
|
|
output => $output,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
my $bridge_uuid = ($output =~ /\((.*?)\) successfully added/)[0];
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { bridge_uuid => $bridge_uuid }});
|
|
|
|
if ($bridge_uuid)
|
|
{
|
|
# Disabling DHCP on the new bridge
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0408",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $bridge_name,
|
|
device_uuid => $bridge_uuid,
|
|
},
|
|
});
|
|
my ($output, $return_code) = $anvil->Network->modify_connection({uuid => $bridge_uuid, variable => "ipv4.method", value => "disabled"});
|
|
($output, $return_code) = $anvil->Network->modify_connection({uuid => $bridge_uuid, variable => "ipv6.method", value => "disabled"});
|
|
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection up ".$bridge_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
}
|
|
|
|
# Rescan.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0394",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
$anvil->Network->collect_data();
|
|
}
|
|
|
|
# Checking that the device is connected to this bridge
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0404",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { on_device => $on_device },
|
|
});
|
|
my $bridge_uuid = $anvil->data->{nmcli}{bridge}{$bridge_name}{uuid};
|
|
my $on_device_uuid = $anvil->data->{nmcli}{device}{$on_device}{uuid} // "";
|
|
my $on_device_parent = $anvil->data->{nmcli}{uuid}{$on_device_uuid}{'connection.master'} // "";
|
|
my $on_device_child_type = $anvil->data->{nmcli}{uuid}{$on_device_uuid}{'connection.slave-type'} // "";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
bridge_uuid => $bridge_uuid,
|
|
on_device_uuid => $on_device_uuid,
|
|
on_device_parent => $on_device_parent,
|
|
on_device_child_type => $on_device_child_type,
|
|
}});
|
|
|
|
if ($on_device_parent)
|
|
{
|
|
if ($on_device_parent eq $bridge_name)
|
|
{
|
|
# The device is connected to the bridge already.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0405",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
next;
|
|
}
|
|
else
|
|
{
|
|
# The device is on another bridge, moving it.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0406",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { on_device_parent => $on_device_parent },
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# The device is not on this bridge, connecting it
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0407",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { on_device_parent => $on_device_parent },
|
|
});
|
|
}
|
|
|
|
# Disabling DHCP on the device before connecting it.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0408",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $on_device,
|
|
device_uuid => $on_device_uuid,
|
|
},
|
|
});
|
|
my ($output, $return_code) = $anvil->Network->modify_connection({uuid => $on_device_uuid, variable => "ipv4.method", value => "disabled"});
|
|
($output, $return_code) = $anvil->Network->modify_connection({uuid => $on_device_uuid, variable => "ipv6.method", value => "disabled"});
|
|
|
|
# Connect it now.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0409",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection modify ".$on_device_uuid." master ".$bridge_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
|
|
if ($return_code)
|
|
{
|
|
# Failed to connect the device to the bridge.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0486",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => {
|
|
on_device => $on_device,
|
|
bridge_name => $bridge_name,
|
|
return_code => $return_code,
|
|
output => $output,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
# Reset the device.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0403",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $on_device,
|
|
device_uuid => $on_device_uuid,
|
|
},
|
|
});
|
|
($output, $return_code) = $anvil->Network->reset_connection({uuid => $on_device_uuid});
|
|
|
|
# Rescan.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0394",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
$anvil->Network->collect_data();
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
sub reconfigure_bonds
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
my $local_host = $anvil->Get->short_host_name();
|
|
my $prefix = $anvil->data->{config}{prefix};
|
|
my $sequence = $anvil->data->{config}{sequence};
|
|
my $domain = $anvil->data->{config}{domain};
|
|
my $bcn_count = $anvil->data->{config}{bcn_count};
|
|
my $ifn_count = $anvil->data->{config}{ifn_count};
|
|
my $sn_count = $anvil->data->{config}{sn_count};
|
|
my $mn_count = $anvil->data->{config}{mn_count};
|
|
my $type = $anvil->Get->host_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
local_host => $local_host,
|
|
prefix => $prefix,
|
|
sequence => $sequence,
|
|
domain => $domain,
|
|
type => $type,
|
|
}});
|
|
foreach my $network_type ("bcn", "sn", "mn", "ifn")
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
my $count = 0;
|
|
if ($network_type eq "bcn") { $count = $bcn_count; }
|
|
elsif ($network_type eq "sn") { $count = $sn_count; }
|
|
elsif ($network_type eq "ifn") { $count = $ifn_count; }
|
|
elsif ($network_type eq "mn") { $count = $mn_count; }
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { count => $count }});
|
|
|
|
# This is the old type of network config
|
|
foreach my $i (1..$count)
|
|
{
|
|
my $bond_name = $network_type.$i."_bond1";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { bond_name => $bond_name }});
|
|
|
|
# Skip if this isn't marked to become a bond.
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
"config::${bond_name}" => $anvil->data->{config}{$bond_name},
|
|
}});
|
|
if (not $anvil->data->{config}{$bond_name})
|
|
{
|
|
# No bond on this network.
|
|
next;
|
|
}
|
|
|
|
my $link_nm_uuids = [];
|
|
my $link1_name = $network_type.$i."_link1";
|
|
my $link1_mac_key = $network_type.$i."_link1_mac_to_set";
|
|
my $link1_mac = $anvil->data->{config}{$link1_mac_key};
|
|
my $link1_nm_uuid = $anvil->data->{nmcli}{mac_address}{$link1_mac}{uuid};
|
|
|
|
my $link2_name = $network_type.$i."_link2";
|
|
my $link2_mac_key = $network_type.$i."_link2_mac_to_set";
|
|
my $link2_mac = $anvil->data->{config}{$link2_mac_key};
|
|
my $link2_nm_uuid = $anvil->data->{nmcli}{mac_address}{$link2_mac}{uuid};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
link1_name => $link1_name,
|
|
link1_mac_key => $link1_mac_key,
|
|
link1_mac => $link1_mac,
|
|
link1_nm_uuid => $link1_nm_uuid,
|
|
link2_name => $link2_name,
|
|
link2_mac_key => $link2_mac_key,
|
|
link2_mac => $link2_mac,
|
|
link2_nm_uuid => $link2_nm_uuid,
|
|
}});
|
|
|
|
# Push the two nm_uuids into the array for later checking/adding to the bond.
|
|
push @{$link_nm_uuids}, $link1_nm_uuid;
|
|
push @{$link_nm_uuids}, $link2_nm_uuid;
|
|
|
|
# Check if the bond exists or not.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0390",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { bond_name => $bond_name },
|
|
});
|
|
if (exists $anvil->data->{nmcli}{bond}{$bond_name})
|
|
{
|
|
# It does.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0391",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { nm_uuid => $anvil->data->{nmcli}{bond}{$bond_name}{uuid} },
|
|
});
|
|
}
|
|
else
|
|
{
|
|
# It doesn't, create it.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0392",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
bond_name => $bond_name,
|
|
link1_name => $link1_name,
|
|
link1_mac => $link1_mac,
|
|
link1_nm_uuid => $link1_nm_uuid,
|
|
link2_name => $link2_name,
|
|
link2_mac => $link2_mac,
|
|
link2_nm_uuid => $link2_nm_uuid,
|
|
},
|
|
});
|
|
|
|
# If there are ifcfg files for this bond, move it.
|
|
my $network_type = $anvil->System->check_network_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
if ($network_type eq "ifcfg")
|
|
{
|
|
my $ifcfg_file = $anvil->data->{path}{directories}{ifcfg}."/ifcfg-".$bond_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { ifcfg_file => $ifcfg_file }});
|
|
if (-f $ifcfg_file)
|
|
{
|
|
# It exists, move it.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0417",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
variables => { file => $ifcfg_file },
|
|
});
|
|
$anvil->Storage->backup({file => $ifcfg_file});
|
|
unlink $ifcfg_file;
|
|
}
|
|
}
|
|
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection add type bond con-name ".$bond_name." ifname ".$bond_name." bond.options \"mode=active-backup,miimon=100,downdelay=0,updelay=120000,primary=".$link1_name."\"";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
if ($return_code)
|
|
{
|
|
# Adding the bond failed.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0483",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => {
|
|
bond_name => $bond_name,
|
|
return_code => $return_code,
|
|
output => $output,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
my $bond_uuid = ($output =~ /\((.*?)\) successfully added/)[0];
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { bond_uuid => $bond_uuid }});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
sleep 2;
|
|
|
|
if ($bond_uuid)
|
|
{
|
|
# Disabling DHCP on the new bond device
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0408",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $bond_name,
|
|
device_uuid => $bond_uuid,
|
|
},
|
|
});
|
|
my ($output, $return_code) = $anvil->Network->modify_connection({uuid => $bond_uuid, variable => "ipv4.method", value => "disabled"});
|
|
($output, $return_code) = $anvil->Network->modify_connection({uuid => $bond_uuid, variable => "ipv6.method", value => "disabled"});
|
|
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection up ".$bond_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
sleep 2;
|
|
}
|
|
|
|
# Done! Rescanning the network config
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0394",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
});
|
|
$anvil->Network->collect_data();
|
|
}
|
|
|
|
# Now add the interfaces, disabling their ipv4.method first.
|
|
my $uuid_count = @{$link_nm_uuids};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { uuid_count => $uuid_count }});
|
|
foreach my $nm_uuid (@{$link_nm_uuids})
|
|
{
|
|
my $link_name = $anvil->data->{nmcli}{uuid}{$nm_uuid}{name};
|
|
my $link_device = $anvil->data->{nmcli}{uuid}{$nm_uuid}{device};
|
|
my $mac_address = $anvil->data->{nmcli}{uuid}{$nm_uuid}{mac_address};
|
|
my $parent_bond_name = $anvil->data->{nmcli}{uuid}{$nm_uuid}{'connection.master'};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:nm_uuid' => $nm_uuid,
|
|
's2:link_name' => $link_name,
|
|
's3:link_device' => $link_device,
|
|
's4:mac_address' => $mac_address,
|
|
's5:parent_bond_name' => $parent_bond_name,
|
|
}});
|
|
|
|
if ($parent_bond_name eq "--")
|
|
{
|
|
$parent_bond_name = "";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { parent_bond_name => $parent_bond_name }});
|
|
}
|
|
|
|
if ($parent_bond_name)
|
|
{
|
|
if ($parent_bond_name eq $bond_name)
|
|
{
|
|
# Already a member of the bond.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0395",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
link_name => $link_device ? $link_device : $link_name,
|
|
nm_uuid => $nm_uuid,
|
|
},
|
|
});
|
|
next;
|
|
}
|
|
else
|
|
{
|
|
# The interface is a member of another bond, switching it to this bond.\n";
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0396",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
link_name => $link_device ? $link_device : $link_name,
|
|
nm_uuid => $nm_uuid,
|
|
old_bond => $parent_bond_name,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# The interface needs to be connected to the bond.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0397",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
link_name => $link_device ? $link_device : $link_name,
|
|
nm_uuid => $nm_uuid,
|
|
},
|
|
});
|
|
}
|
|
|
|
# Disabling DHCP on the interface
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0408",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $link_device ? $link_device : $link_name,
|
|
device_uuid => $nm_uuid,
|
|
},
|
|
});
|
|
my ($output, $return_code) = $anvil->Network->modify_connection({uuid => $nm_uuid, variable => "ipv4.method", value => "disabled"});
|
|
($output, $return_code) = $anvil->Network->modify_connection({uuid => $nm_uuid, variable => "ipv6.method", value => "disabled"});
|
|
|
|
# Connecting the interface to the bond
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0399",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
link_name => $link_device ? $link_device : $link_name,
|
|
bond_name => $bond_name,
|
|
},
|
|
});
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection modify ".$nm_uuid." connection.master ".$bond_name." connection.slave-type bond";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
sleep 2;
|
|
|
|
if ($return_code)
|
|
{
|
|
# Adding the link failed.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0484",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => {
|
|
link_name => $link_device ? $link_device : $link_name,
|
|
bond_name => $bond_name,
|
|
return_code => $return_code,
|
|
output => $output,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
# Reset the interface.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0403",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $link_device ? $link_device : $link_name,
|
|
device_uuid => $nm_uuid,
|
|
},
|
|
});
|
|
($output, $return_code) = $anvil->Network->reset_connection({uuid => $nm_uuid});
|
|
|
|
# Rescan.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0394",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
$anvil->Network->collect_data({debug => 2});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { nm_uuid => $nm_uuid }});
|
|
}
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { i => $i }});
|
|
}
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
}
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "log_0852"});
|
|
|
|
return(0);
|
|
}
|
|
|
|
sub wait_for_nm
|
|
{
|
|
my ($anvil, $bond_name) = @_;
|
|
|
|
my $found = 0;
|
|
my $waiting = 1;
|
|
my $wait_until = time + 30;
|
|
while ($waiting)
|
|
{
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection show | ".$anvil->data->{path}{exe}{'grep'}." -c ".$bond_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
if ($output eq "0")
|
|
{
|
|
if (time > $wait_until)
|
|
{
|
|
# Give up.
|
|
$waiting = 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { waiting => $waiting }});
|
|
}
|
|
# Not found yet.
|
|
sleep 2;
|
|
}
|
|
else
|
|
{
|
|
# Found it.
|
|
$found = 0;
|
|
$waiting = 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
found => $found,
|
|
waiting => $waiting,
|
|
}});
|
|
}
|
|
}
|
|
|
|
return($found);
|
|
}
|
|
|
|
sub reconfigure_ip_addresses
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
my $local_host = $anvil->Get->short_host_name();
|
|
my $bcn_count = $anvil->data->{config}{bcn_count};
|
|
my $ifn_count = $anvil->data->{config}{ifn_count};
|
|
my $sn_count = $anvil->data->{config}{sn_count};
|
|
my $mn_count = $anvil->data->{config}{mn_count};
|
|
my $dns = $anvil->data->{config}{dns};
|
|
my $gateway = $anvil->data->{config}{gateway};
|
|
my $gw_interface = $anvil->data->{config}{gateway_interface};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
local_host => $local_host,
|
|
bcn_count => $bcn_count,
|
|
ifn_count => $ifn_count,
|
|
sn_count => $sn_count,
|
|
mn_count => $mn_count,
|
|
dns => $dns,
|
|
gateway => $gateway,
|
|
gw_interface => $gw_interface,
|
|
}});
|
|
foreach my $network_type ("bcn", "sn", "mn", "ifn")
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
my $count = 0;
|
|
if ($network_type eq "bcn") { $count = $bcn_count; }
|
|
elsif ($network_type eq "sn") { $count = $sn_count; }
|
|
elsif ($network_type eq "ifn") { $count = $ifn_count; }
|
|
elsif ($network_type eq "mn") { $count = $mn_count; }
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { count => $count }});
|
|
|
|
# This is the old type of network config
|
|
foreach my $i (1..$count)
|
|
{
|
|
my $ip_key = $network_type.$i."_ip";
|
|
my $subnet_key = $network_type.$i."_subnet_mask";
|
|
my $link1_name = $network_type.$i."_link1";
|
|
my $link2_name = $network_type.$i."_link2";
|
|
my $bond_name = $network_type.$i."_bond1";
|
|
my $bridge_name = $network_type.$i."_bridge1";
|
|
my $is_gateway = $gw_interface eq $network_type.$i ? 1 : 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
ip_key => $ip_key,
|
|
subnet_key => $subnet_key,
|
|
link1_name => $link1_name,
|
|
link2_name => $link2_name,
|
|
bond_name => $bond_name,
|
|
bridge_name => $bridge_name,
|
|
is_gateway => $is_gateway,
|
|
}});
|
|
|
|
if ((not exists $anvil->data->{config}{$ip_key}) or (not $anvil->data->{config}{$ip_key}))
|
|
{
|
|
# No IP for this network
|
|
next;
|
|
}
|
|
|
|
my $ip_address = $anvil->data->{config}{$ip_key};
|
|
my $subnet_mask = $anvil->data->{config}{$subnet_key};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
ip_address => $ip_address,
|
|
subnet_mask => $subnet_mask,
|
|
}});
|
|
|
|
if (($subnet_mask !~ /^\d+$/) or ($subnet_mask < 1) or ($subnet_mask > 32))
|
|
{
|
|
# Convert to CIDR
|
|
my $cidr = $anvil->Convert->cidr({subnet_mask => $subnet_mask});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { cidr => $cidr }});
|
|
if (not $cidr)
|
|
{
|
|
# The subnet_mask is not valid.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0487",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { subnet_mask => $subnet_mask },
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
$subnet_mask = $cidr;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { subnet_mask => $subnet_mask }});
|
|
}
|
|
|
|
# What device are we assigning the IP address to?
|
|
my $on_device = "";
|
|
my $on_device_uuid = "";
|
|
if ((exists $anvil->data->{nmcli}{bridge}{$bridge_name}) && ($anvil->data->{nmcli}{bridge}{$bridge_name}{uuid}))
|
|
{
|
|
$on_device = $bridge_name;
|
|
$on_device_uuid = $anvil->data->{nmcli}{bridge}{$bridge_name}{uuid};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
on_device => $on_device,
|
|
on_device_uuid => $on_device_uuid,
|
|
}});
|
|
}
|
|
elsif ((exists $anvil->data->{nmcli}{bond}{$bond_name}) && ($anvil->data->{nmcli}{bond}{$bond_name}{uuid}))
|
|
{
|
|
$on_device = $bond_name;
|
|
$on_device_uuid = $anvil->data->{nmcli}{bond}{$bond_name}{uuid};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
on_device => $on_device,
|
|
on_device_uuid => $on_device_uuid,
|
|
}});
|
|
}
|
|
elsif ((exists $anvil->data->{nmcli}{interface}{$link1_name}) && ($anvil->data->{nmcli}{interface}{$link1_name}{uuid}))
|
|
{
|
|
$on_device = $link1_name;
|
|
$on_device_uuid = $anvil->data->{nmcli}{interface}{$link1_name}{uuid};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
on_device => $on_device,
|
|
on_device_uuid => $on_device_uuid,
|
|
}});
|
|
}
|
|
else
|
|
{
|
|
# Failed to find a device to assign this IP address to.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0488",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
network => $network_type.$i,
|
|
ip_address => $ip_address,
|
|
subnet_mask => $subnet_mask,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
# Check to see if the IP address is assigned yet.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0393",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
ip_address => $ip_address,
|
|
subnet_mask => $subnet_mask,
|
|
device => $on_device,
|
|
},
|
|
});
|
|
my $clear_ip_from = "";
|
|
if (exists $anvil->data->{nmcli}{ipv4}{$ip_address})
|
|
{
|
|
my $ip_uuid = $anvil->data->{nmcli}{ipv4}{$ip_address}{on_uuid};
|
|
my $current_device = $anvil->data->{nmcli}{uuid}{$ip_uuid}{device};
|
|
my $ip_sequence = $anvil->data->{nmcli}{ipv4}{$ip_address}{sequence};
|
|
my $current_subnet_mask = $anvil->data->{nmcli}{uuid}{$ip_uuid}{ipv4}{ip}{$ip_sequence}{subnet_mask};
|
|
my $current_gateway = $anvil->data->{nmcli}{uuid}{$ip_uuid}{ipv4}{gateway};
|
|
my $current_dns = $anvil->data->{nmcli}{uuid}{$ip_uuid}{ipv4}{dns};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:ip_uuid' => $ip_uuid,
|
|
's2:current_device' => $current_device,
|
|
's3:ip_sequence' => $ip_sequence,
|
|
's4:current_subnet_mask' => $current_subnet_mask,
|
|
's5:current_gateway' => $current_gateway,
|
|
's6:current_dns' => $current_dns,
|
|
}});
|
|
if (not $ip_uuid)
|
|
{
|
|
# The IP exists, but wasn't translate to a network manager UUID.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0489",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { ip_address => $ip_address },
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
# The IP exists, checking if it needs to be updated.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0398",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {},
|
|
});
|
|
if ($on_device ne $current_device)
|
|
{
|
|
# The IP address is on another device, we'll move it
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0402",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { device => $current_device },
|
|
});
|
|
$clear_ip_from = $current_device;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_ip_from => $clear_ip_from }});
|
|
}
|
|
elsif ($subnet_mask ne $current_subnet_mask)
|
|
{
|
|
# The current subnet mask is different, will update.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0410",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { current_subnet_mask => $current_subnet_mask },
|
|
});
|
|
}
|
|
elsif ($gateway ne $current_gateway)
|
|
{
|
|
# The current gateway is different, will update.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0411",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { current_gateway => $current_gateway },
|
|
});
|
|
}
|
|
elsif ($dns ne $current_dns)
|
|
{
|
|
# The current DNS is different, will update.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0412",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { current_dns => $current_dns },
|
|
});
|
|
}
|
|
else
|
|
{
|
|
# No update is needed.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0413",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
next;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# The IP address needs to be assigned.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0414",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
}
|
|
|
|
if ($clear_ip_from)
|
|
{
|
|
# Clear the IP off the old device
|
|
my $old_uuid = $anvil->data->{nmcli}{device}{$clear_ip_from}{uuid};
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0408",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $clear_ip_from,
|
|
device_uuid => $old_uuid,
|
|
},
|
|
});
|
|
my ($output, $return_code) = $anvil->Network->modify_connection({uuid => $old_uuid, variable => "ipv4.method", value => "disabled"});
|
|
($output, $return_code) = $anvil->Network->modify_connection({uuid => $old_uuid, variable => "ipv6.method", value => "disabled"});
|
|
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0403",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $clear_ip_from,
|
|
device_uuid => $old_uuid,
|
|
},
|
|
});
|
|
($output, $return_code) = $anvil->Network->reset_connection({uuid => $old_uuid});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
sleep 2;
|
|
}
|
|
|
|
# Now assign the IP.
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection modify ".$on_device_uuid." ipv4.method manual ipv4.addresses ".$ip_address."/".$subnet_mask;
|
|
if ($is_gateway)
|
|
{
|
|
if ($gateway)
|
|
{
|
|
$shell_call .= " ipv4.gateway ".$gateway;
|
|
}
|
|
if ($dns)
|
|
{
|
|
$shell_call .= " ipv4.dns ".$dns;
|
|
}
|
|
}
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
$anvil->data->{sys}{restart_nm} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'sys::restart_nm' => $anvil->data->{sys}{restart_nm} }});
|
|
sleep 2;
|
|
|
|
# Restart the interface
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0403",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
device => $on_device,
|
|
device_uuid => $on_device_uuid,
|
|
},
|
|
});
|
|
($output, $return_code) = $anvil->Network->reset_connection({uuid => $on_device_uuid});
|
|
|
|
# Rescan.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0394",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
$anvil->Network->collect_data({debug => 2});
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
sub reconfigure_interfaces
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
# Before we start, we need to make sure all interfaces are up. Otherwise, there's no way to match a
|
|
# network manager device to the ip addr name or the biosdevname.
|
|
foreach my $uuid (sort {$a cmp $b} keys %{$anvil->data->{nmcli}{uuid}})
|
|
{
|
|
### TODO: Any devices that are down, set:
|
|
### nmcli connection modify <uuid> ipv4.method manual ipv4.addresses 169.0.0.x/8' (x == Wired connection x)
|
|
my $connection_id = $anvil->data->{nmcli}{uuid}{$uuid}{'connection.id'} // "";
|
|
my $general_ip_iface = $anvil->data->{nmcli}{uuid}{$uuid}{'GENERAL.IP-IFACE'} // "";
|
|
$general_ip_iface = "" if $general_ip_iface eq "--";
|
|
my $device_type = $anvil->data->{nmcli}{uuid}{$uuid}{'connection.type'} // "";
|
|
my $match_interface_name = $anvil->data->{nmcli}{uuid}{$uuid}{'match.interface-name'} // "";
|
|
my $connection_autoconnect = $anvil->data->{nmcli}{uuid}{$uuid}{'connection.autoconnect'} // "";
|
|
my $active = $anvil->data->{nmcli}{uuid}{$uuid}{active};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:uuid' => $uuid,
|
|
's2:connection_id' => $connection_id,
|
|
's3:general_ip_iface' => $general_ip_iface,
|
|
's4:device_type' => $device_type,
|
|
's5:match_interface_name' => $match_interface_name,
|
|
's6:connection_autoconnect' => $connection_autoconnect,
|
|
's7:active' => $active,
|
|
}});
|
|
|
|
### NOTE: I don't think this is needed, but here's the code in case we change our mind.
|
|
if (0)
|
|
{
|
|
# Try activating it.
|
|
if ((not $general_ip_iface) && (not $active))
|
|
{
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "log_0842", variables => {
|
|
id => $connection_id,
|
|
uuid => $uuid,
|
|
}});
|
|
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection up ".$uuid;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
sleep 2;
|
|
|
|
# Rescan.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0394",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
$anvil->Network->collect_data({debug => 2});
|
|
}
|
|
}
|
|
}
|
|
|
|
my $local_host = $anvil->Get->short_host_name();
|
|
my $prefix = $anvil->data->{config}{prefix};
|
|
my $sequence = $anvil->data->{config}{sequence};
|
|
my $domain = $anvil->data->{config}{domain};
|
|
my $bcn_count = $anvil->data->{config}{bcn_count};
|
|
my $ifn_count = $anvil->data->{config}{ifn_count};
|
|
my $sn_count = $anvil->data->{config}{sn_count};
|
|
my $mn_count = $anvil->data->{config}{mn_count};
|
|
my $type = $anvil->Get->host_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
local_host => $local_host,
|
|
prefix => $prefix,
|
|
sequence => $sequence,
|
|
domain => $domain,
|
|
type => $type,
|
|
}});
|
|
foreach my $network_type ("bcn", "sn", "mn", "ifn")
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
my $count = 0;
|
|
if ($network_type eq "bcn") { $count = $bcn_count; }
|
|
elsif ($network_type eq "sn") { $count = $sn_count; }
|
|
elsif ($network_type eq "ifn") { $count = $ifn_count; }
|
|
elsif ($network_type eq "mn") { $count = $mn_count; }
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { count => $count }});
|
|
|
|
# This is the old type of network config
|
|
foreach my $i (1..$count)
|
|
{
|
|
my $link1_mac_key = $network_type.$i."_link1_mac_to_set";
|
|
my $link2_mac_key = $network_type.$i."_link2_mac_to_set";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
i => $i,
|
|
link1_mac_key => $link1_mac_key,
|
|
link2_mac_key => $link2_mac_key,
|
|
}});
|
|
|
|
# This will get set to '1' if there's a link2
|
|
my $bond_name = $network_type.$i."_bond1";
|
|
$anvil->data->{config}{$bond_name} = 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
"config::${bond_name}" => $anvil->data->{config}{$bond_name},
|
|
}});
|
|
|
|
# If the user had the option to create a network but didn't, there will be no link1
|
|
# mac to set.
|
|
next if not exists $anvil->data->{config}{$link1_mac_key};
|
|
next if not $anvil->data->{config}{$link1_mac_key};
|
|
|
|
my $wanted_link1_name = $network_type.$i."_link1";
|
|
my $wanted_link1_mac = $anvil->data->{config}{$link1_mac_key};
|
|
my $wanted_link2_name = $network_type.$i."_link2";
|
|
my $wanted_link2_mac = exists $anvil->data->{config}{$link2_mac_key} ? $anvil->data->{config}{$link2_mac_key} : "";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
wanted_link1_name => $wanted_link1_name,
|
|
wanted_link1_mac => $wanted_link1_mac,
|
|
wanted_link2_name => $wanted_link2_name,
|
|
wanted_link2_mac => $wanted_link2_mac,
|
|
}});
|
|
|
|
# Loop through our interfaces to see if we can find this interface.
|
|
my $link1_nm_uuid = $anvil->data->{nmcli}{mac_address}{$wanted_link1_mac}{uuid};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { link1_nm_uuid => $link1_nm_uuid }});
|
|
|
|
# Are the link(s) already configured?
|
|
my $configure_link1 = 0;
|
|
my $configure_link2 = 0;
|
|
|
|
# Get the Network Manager UUIDs.
|
|
if ($link1_nm_uuid)
|
|
{
|
|
my $found = 0;
|
|
my $match_interface_name = $anvil->data->{nmcli}{uuid}{$link1_nm_uuid}{'match.interface-name'} // "";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { match_interface_name => $match_interface_name }});
|
|
foreach my $interface (split/,/, $match_interface_name)
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { interface => $interface }});
|
|
|
|
# In case the GENERAL.IP-IFACE or GENERAL.NAME name didn't update,
|
|
# map this interface name to 'nmcli::interface::<name>::uuid'.
|
|
if (not exists $anvil->data->{nmcli}{interface}{$interface})
|
|
{
|
|
$anvil->data->{nmcli}{interface}{$interface}{uuid} = $link1_nm_uuid;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
"nmcli::interface::${interface}::uuid" => $anvil->data->{nmcli}{interface}{$interface}{uuid},
|
|
}});
|
|
}
|
|
if ($interface eq $wanted_link1_name)
|
|
{
|
|
$found = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { found => $found }});
|
|
}
|
|
}
|
|
if (not $found)
|
|
{
|
|
$configure_link1 = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { configure_link1 => $configure_link1 }});
|
|
}
|
|
|
|
# Make sure that the autoconnect is enabled.
|
|
if ($anvil->data->{nmcli}{uuid}{$link1_nm_uuid}{'connection.autoconnect'} ne "yes")
|
|
{
|
|
my ($output, $return_code) = $anvil->Network->modify_connection({uuid => $link1_nm_uuid, variable => "connection.autoconnect", value => "yes"});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# We're dead.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0480",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => {
|
|
mac_address => $wanted_link1_mac,
|
|
interface_name => $wanted_link1_name,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { configure_link1 => $configure_link1 }});
|
|
if ($configure_link1)
|
|
{
|
|
rename_interface($anvil, $wanted_link1_name, $link1_nm_uuid);
|
|
}
|
|
|
|
my $link2_nm_uuid = "";
|
|
if ($wanted_link2_mac)
|
|
{
|
|
$link2_nm_uuid = $anvil->data->{nmcli}{mac_address}{$wanted_link2_mac}{uuid};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { link2_nm_uuid => $link2_nm_uuid }});
|
|
if ($link2_nm_uuid)
|
|
{
|
|
my $found = 0;
|
|
my $match_interface_name = $anvil->data->{nmcli}{uuid}{$link2_nm_uuid}{'match.interface-name'} ? $anvil->data->{nmcli}{uuid}{$link2_nm_uuid}{'match.interface-name'} : "";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { match_interface_name => $match_interface_name }});
|
|
foreach my $interface (split/,/, $match_interface_name)
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { interface => $interface }});
|
|
if ($interface eq $wanted_link2_name)
|
|
{
|
|
$found = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { found => $found }});
|
|
last;
|
|
}
|
|
}
|
|
if (not $found)
|
|
{
|
|
$configure_link2 = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { configure_link1 => $configure_link1 }});
|
|
}
|
|
|
|
# Make sure that the autoconnect is enabled.
|
|
if ($anvil->data->{nmcli}{uuid}{$link2_nm_uuid}{'connection.autoconnect'} ne "yes")
|
|
{
|
|
my ($output, $return_code) = $anvil->Network->modify_connection({uuid => $link2_nm_uuid, variable => "connection.autoconnect", value => "yes"});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0480",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_status => "failed",
|
|
variables => {
|
|
mac_address => $wanted_link2_mac,
|
|
interface_name => $wanted_link2_name,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { configure_link2 => $configure_link2 }});
|
|
if ($configure_link2)
|
|
{
|
|
rename_interface($anvil, $wanted_link2_name, $link2_nm_uuid);
|
|
}
|
|
|
|
# There's a second interface, so create a bond.
|
|
$anvil->data->{config}{$bond_name} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
"config::${bond_name}" => $anvil->data->{config}{$bond_name},
|
|
}});
|
|
}
|
|
}
|
|
}
|
|
|
|
# There is no way (that we've found) to get the network interface ames to be updated without a reboot.
|
|
if ($anvil->data->{sys}{reboot_needed})
|
|
{
|
|
do_reboot($anvil);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
sub rename_interface
|
|
{
|
|
my ($anvil, $wanted_link_name, $nm_uuid) = @_;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
wanted_link_name => $wanted_link_name,
|
|
nm_uuid => $nm_uuid,
|
|
}});
|
|
|
|
my $old_device = $anvil->data->{nmcli}{uuid}{$nm_uuid}{device};
|
|
my $name = $anvil->data->{nmcli}{uuid}{$nm_uuid}{'connection.id'};
|
|
my $mac_address = $anvil->data->{nmcli}{uuid}{$nm_uuid}{mac_address};
|
|
my $type = $anvil->data->{nmcli}{uuid}{$nm_uuid}{type};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:wanted_link_name' => $wanted_link_name,
|
|
's2:nm_uuid' => $nm_uuid,
|
|
's3:old_device' => $old_device,
|
|
's4:name' => $name,
|
|
's5:mac_address' => $mac_address,
|
|
's6:type' => $type,
|
|
}});
|
|
|
|
# Tell the user what we're about to rename
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0383",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
variables => {
|
|
mac_address => $mac_address,
|
|
old_device => $old_device,
|
|
old_name => $name,
|
|
new_name => $wanted_link_name,
|
|
nm_uuid => $nm_uuid,
|
|
},
|
|
});
|
|
|
|
# If there are ifcfg files for this device, move them.
|
|
my $network_type = $anvil->System->check_network_type();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { network_type => $network_type }});
|
|
if ($network_type eq "ifcfg")
|
|
{
|
|
my $old_ifcfg_file = $anvil->data->{path}{directories}{ifcfg}."/ifcfg-".$old_device;
|
|
my $new_ifcfg_file = $anvil->data->{path}{directories}{ifcfg}."/ifcfg-".$wanted_link_name;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
old_ifcfg_file => $old_ifcfg_file,
|
|
new_ifcfg_file => $new_ifcfg_file,
|
|
}});
|
|
foreach my $file ($old_ifcfg_file, $new_ifcfg_file)
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { file => $file }});
|
|
if (-f $file)
|
|
{
|
|
# It exists, move it.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0417",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
variables => { file => $file },
|
|
});
|
|
$anvil->Storage->backup({file => $file});
|
|
unlink $file;
|
|
}
|
|
}
|
|
}
|
|
|
|
# Read persistent-net and see if it needs to be updated.
|
|
my $new_persistent_net = "";
|
|
my $old_persistent_net = "";
|
|
if (-e $anvil->data->{path}{configs}{'persistent-net'})
|
|
{
|
|
$old_persistent_net = $anvil->Storage->read_file({file => $anvil->data->{path}{configs}{'persistent-net'}});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { old_persistent_net => $old_persistent_net }});
|
|
}
|
|
foreach my $line (split/\n/, $old_persistent_net)
|
|
{
|
|
# If this MAC or device name exists already, delete the line.
|
|
if (($line =~ /"$mac_address"/) or ($line =~ /"$wanted_link_name"/))
|
|
{
|
|
next;
|
|
}
|
|
$new_persistent_net .= $line."\n";
|
|
}
|
|
$new_persistent_net .= "SUBSYSTEM==\"net\",ACTION==\"add\",ATTR{address}==\"".$mac_address."\",ATTR{type}==\"".$type."\",NAME=\"".$wanted_link_name."\"\n";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_persistent_net => $new_persistent_net }});
|
|
|
|
my $difference = diff \$old_persistent_net, \$new_persistent_net, { STYLE => 'Unified' };
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { difference => $difference }});
|
|
|
|
# Write the new file.
|
|
if ($difference)
|
|
{
|
|
# Updating the udev file
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0384",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
variables => { file => $anvil->data->{path}{configs}{'persistent-net'} },
|
|
});
|
|
my $problem = $anvil->Storage->write_file({
|
|
file => $anvil->data->{path}{configs}{'persistent-net'},
|
|
body => $new_persistent_net,
|
|
overwrite => 1,
|
|
user => "admin",
|
|
group => "admin",
|
|
mode => "0644",
|
|
|
|
});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { problem => $problem }});
|
|
if ($problem)
|
|
{
|
|
# Failed to write the udev file
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0043",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => { file => $anvil->data->{path}{configs}{'persistent-net'} },
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
}
|
|
|
|
# Update the connection.interface-name
|
|
my $connection_interface_name = $anvil->data->{nmcli}{uuid}{$nm_uuid}{'connection.interface-name'} ? $anvil->data->{nmcli}{uuid}{$nm_uuid}{'connection.interface-name'} : "";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { connection_interface_name => $connection_interface_name }});
|
|
if ($connection_interface_name)
|
|
{
|
|
# Removing the old 'connection.interface-name'
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0385",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
variables => { name => $connection_interface_name },
|
|
});
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection modify ".$nm_uuid." connection.interface-name \"\"";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
sleep 2;
|
|
|
|
$shell_call = $anvil->data->{path}{exe}{nmcli}." --get-values connection.interface-name connection show ".$nm_uuid;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
if ($output)
|
|
{
|
|
# Failed to delete the 'connection.interface-name', This should have been blank
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0481",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => { output => $output },
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
}
|
|
|
|
# We'll log what it was, and change it anyway
|
|
my $match_interface_name = $anvil->data->{nmcli}{uuid}{$nm_uuid}{'match.interface-name'} ? $anvil->data->{nmcli}{uuid}{$nm_uuid}{'match.interface-name'} : "";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { match_interface_name => $match_interface_name }});
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0386",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
new_name => $wanted_link_name,
|
|
old_device => $old_device,
|
|
},
|
|
});
|
|
|
|
if ($old_device eq $wanted_link_name)
|
|
{
|
|
# Both the netbios name and the old device name are the same, match would break!
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0490",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
variables => {
|
|
wanted_link_name => $wanted_link_name,
|
|
old_device => $old_device,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
my $shell_call = $anvil->data->{path}{exe}{nmcli}." connection modify ".$nm_uuid." match.interface-name \"".$wanted_link_name." ".$old_device."\"";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
sleep 2;
|
|
|
|
# Read it back
|
|
$shell_call = $anvil->data->{path}{exe}{nmcli}." --get-values match.interface-name connection show ".$nm_uuid;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
if (($output ne $wanted_link_name.",".$old_device) && ($output ne $old_device.",".$wanted_link_name))
|
|
{
|
|
# This should have been blank
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0482",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => {
|
|
new_name => $wanted_link_name,
|
|
old_device => $old_device,
|
|
output => $output,
|
|
},
|
|
});
|
|
$anvil->nice_exit({exit_code => 1});
|
|
}
|
|
|
|
# Set the connection.id to the old name.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0387",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
variables => { old_device => $old_device },
|
|
});
|
|
$shell_call = $anvil->data->{path}{exe}{nmcli}." connection modify ".$nm_uuid." connection.id \"".$old_device."\"";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
# NM seems to have a race issue, so we sleep a second after nmcli calls.
|
|
sleep 2;
|
|
|
|
# Read it back
|
|
$shell_call = $anvil->data->{path}{exe}{nmcli}." --get-values connection.id connection show ".$nm_uuid;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { shell_call => $shell_call }});
|
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
output => $output,
|
|
return_code => $return_code,
|
|
}});
|
|
|
|
# Re-read the updated data
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0394",
|
|
log_level => 1,
|
|
'print' => 1,
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
variables => { },
|
|
});
|
|
$anvil->Network->collect_data({debug => 2});
|
|
|
|
# Set the reboot flag.
|
|
$anvil->data->{sys}{reboot_needed} = 1;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "sys::reboot_needed" => $anvil->data->{sys}{reboot_needed} }});
|
|
|
|
return(0);
|
|
}
|
|
|
|
# This will pick up the job, or exit.
|
|
sub pickup_job_details
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
# If this returns '1', the job-uuid was bad. If it returns '2', another process is running.
|
|
my $return = $anvil->Job->get_job_details({
|
|
check => 1,
|
|
job_uuid => $anvil->data->{switches}{'job-uuid'},
|
|
});
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { 'return' => $return }});
|
|
if ($return == 1)
|
|
{
|
|
# It's not a valid UUID.
|
|
$anvil->nice_exit({exit_code => 6});
|
|
}
|
|
if ($return == 2)
|
|
{
|
|
# This job is being handled by another process that is still alive.
|
|
$anvil->nice_exit({exit_code => 3});
|
|
}
|
|
|
|
# Still alive? Good.
|
|
my $job_picked_up_by = $anvil->data->{jobs}{job_picked_up_by};
|
|
my $job_progress = $anvil->data->{jobs}{job_progress};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
job_picked_up_by => $job_picked_up_by,
|
|
job_progress => $job_progress,
|
|
}});
|
|
|
|
# See if the job was picked up by another running instance.
|
|
if ($job_picked_up_by)
|
|
{
|
|
# The previous job is gone if we're still alive, we'll take this over.
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, 'print' => 1, key => "log_0147", variables => {
|
|
pid => $job_picked_up_by,
|
|
percent => $job_progress,
|
|
}});
|
|
}
|
|
|
|
### These are the new variables
|
|
$anvil->data->{config}{striker_password} = "";
|
|
$anvil->data->{config}{prefix} = "";
|
|
$anvil->data->{config}{sequence} = "";
|
|
$anvil->data->{config}{domain} = "";
|
|
$anvil->data->{config}{host_name} = "";
|
|
$anvil->data->{config}{organization} = "";
|
|
$anvil->data->{config}{bcn_count} = 1;
|
|
$anvil->data->{config}{ifn_count} = 1;
|
|
$anvil->data->{config}{sn_count} = 0;
|
|
$anvil->data->{config}{mn_count} = 0;
|
|
$anvil->data->{config}{dns} = "";
|
|
$anvil->data->{config}{gateway} = "";
|
|
$anvil->data->{config}{gateway_interface} = "";
|
|
|
|
### TODO: Remove this later
|
|
# This will store the variables from the database
|
|
$anvil->data->{variables} = {};
|
|
|
|
### TODO: Remove this, it shouldn't be needed once we confirm everything is in the job_data.
|
|
# If we're still alive, pick up the details.
|
|
my $query = "
|
|
SELECT
|
|
variable_name,
|
|
variable_value
|
|
FROM
|
|
variables
|
|
WHERE
|
|
variable_name
|
|
LIKE
|
|
'form::config_step%'
|
|
AND
|
|
variable_source_table = 'hosts'
|
|
AND
|
|
variable_source_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)."
|
|
;";
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }});
|
|
|
|
my $results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__});
|
|
my $count = @{$results};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
results => $results,
|
|
count => $count,
|
|
}});
|
|
foreach my $row (@{$results})
|
|
{
|
|
my $this_variable = $row->[0];
|
|
my $this_value = $row->[1];
|
|
my $secure = $this_variable =~ /passw/ ? 1 : 0;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:this_variable' => $this_variable,
|
|
's2:this_value' => $anvil->Log->is_secure($this_value),
|
|
}});
|
|
|
|
$anvil->_make_hash_reference($anvil->data->{variables}, $this_variable, $this_value);
|
|
}
|
|
|
|
### TODO: This is the only way we should do it, but the variable names need to change to be more sensible.
|
|
# Overwrite variables with job data.
|
|
foreach my $line (split/\n/, $anvil->data->{jobs}{job_data})
|
|
{
|
|
if ($line =~ /^(form::config_step[^\s]+)=(.*?)$/)
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
'job_data::variable_name' => $1,
|
|
'job_data::variable_value' => $anvil->Log->is_secure($2),
|
|
}});
|
|
$anvil->_make_hash_reference($anvil->data->{variables}, $1, $2);
|
|
}
|
|
elsif ($line =~ /^(.*?)=(.*)$/)
|
|
{
|
|
my $variable = $1;
|
|
my $value = $2;
|
|
my $secure = $variable =~ /passw/ ? 1 : 0;
|
|
$anvil->data->{config}{$variable} = $value;
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
's1:variable' => $variable,
|
|
's2:value' => $anvil->Log->is_secure($value),
|
|
"s3:config::${variable}" => $anvil->Log->is_secure($anvil->data->{config}{$variable}),
|
|
}});
|
|
}
|
|
}
|
|
|
|
### TODO: Remove this when no longer needed.
|
|
# Convert old variables to new ones.
|
|
foreach my $config_step (sort {$a cmp $b} keys %{$anvil->data->{variables}{form}})
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { config_step => $config_step }});
|
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{variables}{form}{$config_step}})
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { variable => $variable }});
|
|
|
|
if (exists $anvil->data->{variables}{form}{$config_step}{$variable}{value})
|
|
{
|
|
$anvil->data->{config}{$variable} = $anvil->data->{variables}{form}{$config_step}{$variable}{value};
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
"config::${variable}" => $anvil->data->{config}{$variable},
|
|
}});
|
|
}
|
|
}
|
|
}
|
|
|
|
# Clear previous data
|
|
$anvil->Job->update_progress({
|
|
progress => 0,
|
|
message => "clear",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
});
|
|
|
|
# Record that we've picked up this job.
|
|
$anvil->Job->update_progress({
|
|
progress => $anvil->Job->bump_progress({steps => 1}),
|
|
message => "message_0015",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
});
|
|
|
|
# If we're in a cluster, abort.
|
|
if (-e $anvil->data->{path}{exe}{pcs})
|
|
{
|
|
# To make logs more sensible, we'll call 'problem' as 'out_of_cluster'.
|
|
$anvil->data->{cib}{parsed}{'local'}{ready} = "" if not defined $anvil->data->{cib}{parsed}{'local'}{ready};
|
|
my ($out_of_cluster) = $anvil->Cluster->parse_cib();
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
out_of_cluster => $out_of_cluster,
|
|
"cib::parsed::local::ready" => defined $anvil->data->{cib}{parsed}{'local'}{ready} ? $anvil->data->{cib}{parsed}{'local'}{ready} : "",
|
|
}});
|
|
if ((not $out_of_cluster) && ($anvil->data->{cib}{parsed}{'local'}{ready}))
|
|
{
|
|
# We're in a cluster, abort.
|
|
$anvil->Job->update_progress({
|
|
progress => 100,
|
|
message => "error_0250",
|
|
job_uuid => $anvil->data->{job}{uuid},
|
|
job_status => "failed",
|
|
'print' => 1,
|
|
log_level => 1,
|
|
file => $THIS_FILE,
|
|
line => __LINE__,
|
|
});
|
|
$anvil->nice_exit({exit_code => 7});
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
sub overwrite_variables_with_switches
|
|
{
|
|
my ($anvil) = @_;
|
|
|
|
if (not defined $anvil->data->{variables})
|
|
{
|
|
$anvil->data->{variables} = {};
|
|
}
|
|
|
|
foreach my $switch_name (keys %{$anvil->data->{switches}})
|
|
{
|
|
my $switch_value = $anvil->data->{switches}{$switch_name};
|
|
|
|
if ($switch_name =~ /^form::config_step[^\s]+$/)
|
|
{
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
|
|
'switches::variable_name' => $switch_name,
|
|
'switches::variable_value' => $anvil->Log->is_secure($switch_value),
|
|
}});
|
|
$anvil->_make_hash_reference($anvil->data->{variables}, $switch_name, $switch_value);
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|