You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2358 lines
105 KiB
2358 lines
105 KiB
#!/usr/bin/perl |
|
# |
|
# This program will manage servers; Changing RAM, CPU cores, Growing virtual disks, adding virtual disks, |
|
# inserting and ejecting ISO images into virtual optical media. |
|
# |
|
# Exit codes; |
|
# 0 = Normal exit. |
|
# 1 = No database connection. |
|
# |
|
# TODO: |
|
# |
|
|
|
use strict; |
|
use warnings; |
|
use Anvil::Tools; |
|
require POSIX; |
|
use Term::Cap; |
|
use Data::Dumper; |
|
|
|
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(); |
|
|
|
$anvil->data->{switches}{anvil} = ""; # This is the Anvil! Name or UUID being worked on. |
|
$anvil->data->{switches}{boot} = ""; # This is a comma-separated list of ordered boot devices |
|
$anvil->data->{switches}{cores} = ""; # This sets the server to use this number of CPU cores. |
|
$anvil->data->{switches}{drive} = ""; # drive being modified (insert/eject ISO, growing drive) |
|
$anvil->data->{switches}{eject} = ""; # This will eject whatever ISO (if any) in the '--drive'. |
|
$anvil->data->{switches}{'expand-to'} = ""; # When the drive is a disk (backed by a DRBD resource), this is the new desired size to grow to. |
|
$anvil->data->{switches}{insert} = ""; # This is the ISO to insert into the --drive |
|
$anvil->data->{switches}{'job-uuid'} = ""; |
|
$anvil->data->{switches}{ram} = ""; # This is the amount of RAM to set the server to use. |
|
$anvil->data->{switches}{server} = ""; # server name or uuid |
|
$anvil->data->{switches}{y} = ""; # Don't prompt for confirmation. Only useful when there isn't a job UUID. |
|
$anvil->Get->switches; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 1, secure => 0, key => "log_0115", variables => { program => $THIS_FILE }}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
'switches::boot' => $anvil->data->{switches}{boot}, |
|
'switches::cores' => $anvil->data->{switches}{cores}, |
|
'switches::drive' => $anvil->data->{switches}{drive}, |
|
'switches::eject' => $anvil->data->{switches}{eject}, |
|
'switches::expand-to' => $anvil->data->{switches}{'expand-to'}, |
|
'switches::insert' => $anvil->data->{switches}{insert}, |
|
'switches::job-uuid' => $anvil->data->{switches}{'job-uuid'}, |
|
'switches::ram' => $anvil->data->{switches}{ram}, |
|
'switches::server' => $anvil->data->{switches}{server}, |
|
'switches::y' => $anvil->data->{switches}{y}, |
|
}}); |
|
|
|
# Connect to the database(s). If we have no connections, we'll proceed anyway as one of the 'run_once' tasks |
|
# is to setup the database server. |
|
$anvil->Database->connect(); |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 3, secure => 0, key => "log_0132"}); |
|
if (not $anvil->data->{sys}{database}{connections}) |
|
{ |
|
# No databases, update the job, sleep for a bit and then exit. The daemon will pick it up and try |
|
# again after we exit. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 0, priority => "err", key => "error_0305"}); |
|
sleep 10; |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
|
|
# If we don't have a job UUID, try to find one. |
|
if (not $anvil->data->{switches}{'job-uuid'}) |
|
{ |
|
# Load the job data. |
|
$anvil->data->{switches}{'job-uuid'} = $anvil->Job->get_job_uuid({program => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "switches::job-uuid" => $anvil->data->{switches}{'job-uuid'} }}); |
|
} |
|
|
|
# If we still don't have a job-uuit, go into interactive mode. |
|
if ($anvil->data->{switches}{'job-uuid'}) |
|
{ |
|
# Load the job data. |
|
$anvil->Job->clear(); |
|
$anvil->Job->get_job_details(); |
|
$anvil->Job->update_progress({ |
|
progress => 1, |
|
job_picked_up_by => $$, |
|
job_picked_up_at => time, |
|
message => "message_0251", |
|
}); |
|
|
|
# Job data will be in $anvil->data->{jobs}{job_data} |
|
run_jobs($anvil); |
|
} |
|
else |
|
{ |
|
# Interactive! |
|
$anvil->data->{new_config}{cpu}{sockets} = ""; |
|
$anvil->data->{new_config}{cpu}{cores} = ""; |
|
$anvil->data->{new_config}{ram}{'bytes'} = ""; |
|
$anvil->data->{old_config}{ram}{'bytes'} = ""; |
|
interactive_question($anvil); |
|
} |
|
|
|
$anvil->nice_exit({exit_code => 0}); |
|
|
|
|
|
############################################################################################################# |
|
# Functions # |
|
############################################################################################################# |
|
|
|
sub run_jobs |
|
{ |
|
my ($anvil) = @_; |
|
|
|
|
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_question |
|
{ |
|
my ($anvil) = @_; |
|
|
|
$anvil->Database->get_hosts(); |
|
$anvil->Database->get_anvils(); |
|
$anvil->Database->get_servers(); |
|
|
|
$anvil->data->{target_server}{server_uuid} = "" if not defined $anvil->data->{target_server}{server_uuid}; |
|
$anvil->data->{target_server}{server_name} = "" if not defined $anvil->data->{target_server}{server_name}; |
|
$anvil->data->{target_server}{server_state} = "" if not defined $anvil->data->{target_server}{server_state}; |
|
$anvil->data->{target_server}{anvil_uuid} = "" if not defined $anvil->data->{target_server}{anvil_uuid}; |
|
$anvil->data->{target_server}{anvil_name} = "" if not defined $anvil->data->{target_server}{anvil_name}; |
|
$anvil->data->{target_server}{anvil_description} = "" if not defined $anvil->data->{target_server}{anvil_description}; |
|
$anvil->data->{target_server}{anvil_node1_host_uuid} = "" if not defined $anvil->data->{target_server}{anvil_node1_host_uuid}; |
|
$anvil->data->{target_server}{anvil_node1_host_name} = "" if not defined $anvil->data->{target_server}{anvil_node1_host_name}; |
|
$anvil->data->{target_server}{anvil_node2_host_uuid} = "" if not defined $anvil->data->{target_server}{anvil_node2_host_uuid}; |
|
$anvil->data->{target_server}{anvil_node2_host_name} = "" if not defined $anvil->data->{target_server}{anvil_node2_host_name}; |
|
$anvil->data->{target_server}{anvil_dr1_host_uuid} = "" if not defined $anvil->data->{target_server}{anvil_dr1_host_uuid}; |
|
$anvil->data->{target_server}{anvil_dr1_host_name} = "" if not defined $anvil->data->{target_server}{anvil_dr1_host_name}; |
|
|
|
### Anvil |
|
# If 'switches::anvil' is set, see if it's a UUID and then set either 'anvil-uuid' or 'anvil-name'. |
|
if ($anvil->data->{switches}{anvil}) |
|
{ |
|
if ($anvil->Validate->uuid({uuid => $anvil->data->{switches}{anvil}})) |
|
{ |
|
$anvil->data->{target_server}{anvil_uuid} = $anvil->data->{switches}{anvil}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid}, |
|
}}); |
|
} |
|
else |
|
{ |
|
$anvil->data->{target_server}{anvil_name} = $anvil->data->{switches}{anvil}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_name" => $anvil->data->{target_server}{anvil_name}, |
|
}}); |
|
} |
|
} |
|
|
|
# Do we know or can we find the Anvil! UUID? |
|
if ((not $anvil->data->{target_server}{anvil_name}) && ($anvil->data->{switches}{'anvil-name'})) |
|
{ |
|
$anvil->data->{target_server}{anvil_name} = $anvil->data->{switches}{'anvil-name'}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_name" => $anvil->data->{target_server}{anvil_name}, |
|
}}); |
|
} |
|
if ((not $anvil->data->{target_server}{anvil_uuid}) && ($anvil->data->{switches}{'anvil-uuid'})) |
|
{ |
|
$anvil->data->{target_server}{anvil_uuid} = $anvil->data->{switches}{'anvil-uuid'}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid}, |
|
}}); |
|
} |
|
|
|
if ((not $anvil->data->{target_server}{anvil_uuid}) && (not $anvil->data->{target_server}{anvil_name})) |
|
{ |
|
# Nothing given. Is this host a node, perhaps? |
|
my $anvil_uuid = $anvil->Cluster->get_anvil_uuid(); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { anvil_uuid => $anvil_uuid }}); |
|
|
|
if ($anvil_uuid) |
|
{ |
|
$anvil->data->{target_server}{anvil_uuid} = $anvil_uuid; |
|
$anvil->data->{target_server}{anvil_name} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_name}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_name" => $anvil->data->{target_server}{anvil_name}, |
|
"target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid}, |
|
}}); |
|
} |
|
else |
|
{ |
|
# If there is only one Anvil!, choose it |
|
my $known_anvils = keys %{$anvil->data->{anvils}{anvil_name}}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { known_anvils => $known_anvils }}); |
|
if (not $known_anvils) |
|
{ |
|
my $variables = { server_uuid => $anvil->data->{target_server}{server_uuid} }; |
|
$anvil->Jobs->update_progress({ |
|
progress => 100, |
|
message => "error_0321", |
|
job_status => "failed", |
|
log_level => 1, |
|
priority => "err", |
|
}); |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
elsif ($known_anvils == 1) |
|
{ |
|
foreach my $anvil_name (keys %{$anvil->data->{anvils}{anvil_name}}) |
|
{ |
|
$anvil->data->{target_server}{anvil_name} = $anvil_name; |
|
$anvil->data->{target_server}{anvil_uuid} = $anvil->data->{anvils}{anvil_name}{$anvil_name}{anvil_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_name" => $anvil->data->{target_server}{anvil_name}, |
|
"target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid}, |
|
}}); |
|
} |
|
} |
|
} |
|
} |
|
elsif (not $anvil->data->{target_server}{anvil_uuid}) |
|
{ |
|
# We have a name, get the UUID. |
|
$anvil->data->{target_server}{anvil_uuid} = $anvil->Cluster->get_anvil_uuid({anvil_name => $anvil->data->{target_server}{anvil_name}}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid} }}); |
|
|
|
# If the name is bad, error out if not interactive |
|
if (not $anvil->data->{target_server}{anvil_uuid}) |
|
{ |
|
# Bad server UUID. If it's a job, abort. Otherwise, clear and go back to |
|
my $variables = { anvil_name => $anvil->data->{target_server}{anvil_name} }; |
|
$anvil->Jobs->update_progress({ |
|
progress => 100, |
|
message => "error_0319", |
|
variables => $variables, |
|
job_status => "failed", |
|
log_level => 1, |
|
priority => "err", |
|
}); |
|
if ($anvil->data->{switches}{'job-uuid'}) |
|
{ |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
$anvil->data->{target_server}{anvil_name} = ""; |
|
} |
|
} |
|
elsif (not $anvil->data->{target_server}{anvil_name}) |
|
{ |
|
$anvil->data->{target_server}{anvil_name} = $anvil->Cluster->get_anvil_name({anvil_uuid => $anvil->data->{target_server}{anvil_uuid}}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "target_server::anvil_name" => $anvil->data->{target_server}{anvil_name} }}); |
|
|
|
# If the name is bad, error out if not interactive |
|
if (not $anvil->data->{target_server}{anvil_name}) |
|
{ |
|
# Bad server UUID. If it's a job, abort. Otherwise, clear and go back to |
|
my $variables = { anvil_uuid => $anvil->data->{target_server}{anvil_uuid} }; |
|
$anvil->Jobs->update_progress({ |
|
progress => 100, |
|
message => "error_0320", |
|
variables => $variables, |
|
job_status => "failed", |
|
log_level => 1, |
|
priority => "err", |
|
}); |
|
if ($anvil->data->{switches}{'job-uuid'}) |
|
{ |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
$anvil->data->{target_server}{anvil_uuid} = ""; |
|
} |
|
} |
|
|
|
### Server |
|
# First, has the user specified a server? If so, and if it's by name, make sure it's unique. If the |
|
# name exists on two or more Anvil! systems, we'll need an Anvil! name as well. If it's unique, we |
|
# can devine the Anvil! UUID. |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"switches::server" => $anvil->data->{switches}{server}, |
|
}}); |
|
if ($anvil->data->{switches}{server}) |
|
{ |
|
my $server = $anvil->data->{switches}{server}; |
|
if ($anvil->Validate->uuid({uuid => $server})) |
|
{ |
|
$anvil->data->{target_server}{server_uuid} = $server; |
|
$anvil->data->{target_server}{server_name} = exists $anvil->data->{servers}{server_uuid}{$server} ? $anvil->data->{servers}{server_uuid}{$server}{server_name} : ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::server_uuid" => $anvil->data->{target_server}{server_uuid}, |
|
"target_server::server_name" => $anvil->data->{target_server}{server_name}, |
|
}}); |
|
} |
|
else |
|
{ |
|
$anvil->data->{target_server}{server_name} = $server; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::server_name" => $anvil->data->{target_server}{server_name}, |
|
}}); |
|
if ($anvil->data->{target_server}{anvil_uuid}) |
|
{ |
|
my $anvil_uuid = $anvil->data->{target_server}{anvil_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { anvil_uuid => $anvil_uuid }}); |
|
|
|
$anvil->data->{target_server}{server_uuid} = exists $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$server} ? $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$server}{server_uuid} : ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::server_uuid" => $anvil->data->{target_server}{server_uuid}, |
|
}}); |
|
} |
|
} |
|
} |
|
|
|
# If we have a server UUID, make sure it's valid. |
|
if ($anvil->data->{target_server}{server_uuid}) |
|
{ |
|
# Pull up the server data. |
|
my $server_uuid = $anvil->data->{target_server}{server_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { server_uuid => $server_uuid }}); |
|
if (exists $anvil->data->{servers}{server_uuid}{$server_uuid}) |
|
{ |
|
# We can divine everthing from this. |
|
my $anvil_uuid = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_anvil_uuid}; |
|
my $server_name = $anvil->data->{target_server}{server_name}; |
|
my $server_host_uuid = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_host_uuid}; |
|
my $node1_host_uuid = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_node1_host_uuid}; |
|
my $node2_host_uuid = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_node1_host_uuid}; |
|
my $dr1_host_uuid = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_dr1_host_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
anvil_uuid => $anvil_uuid, |
|
server_name => $server_name, |
|
server_host_uuid => $server_host_uuid, |
|
node1_host_uuid => $node1_host_uuid, |
|
node2_host_uuid => $node2_host_uuid, |
|
dr1_host_uuid => $dr1_host_uuid, |
|
}}); |
|
|
|
$anvil->data->{target_server}{anvil_uuid} = $anvil_uuid; |
|
$anvil->data->{target_server}{server_name} = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_name}; |
|
$anvil->data->{target_server}{server_state} = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_state}; |
|
$anvil->data->{target_server}{anvil_name} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_name}; |
|
$anvil->data->{target_server}{anvil_description} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_description}; |
|
$anvil->data->{target_server}{anvil_node1_host_uuid} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_node1_host_uuid}; |
|
$anvil->data->{target_server}{anvil_node1_host_name} = $anvil->data->{hosts}{host_uuid}{$node1_host_uuid}{host_name}; |
|
$anvil->data->{target_server}{anvil_node2_host_uuid} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_node2_host_uuid}; |
|
$anvil->data->{target_server}{anvil_node2_host_name} = $anvil->data->{hosts}{host_uuid}{$node2_host_uuid}{host_name}; |
|
$anvil->data->{target_server}{anvil_dr1_host_uuid} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_node1_host_uuid}; |
|
$anvil->data->{target_server}{anvil_dr1_host_name} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_node1_host_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid}, |
|
"target_server::server_name" => $anvil->data->{target_server}{server_name}, |
|
"target_server::server_state" => $anvil->data->{target_server}{server_state}, |
|
"target_server::anvil_description" => $anvil->data->{target_server}{anvil_description}, |
|
"target_server::anvil_node1_host_uuid" => $anvil->data->{target_server}{anvil_node1_host_uuid}, |
|
"target_server::anvil_node1_host_name" => $anvil->data->{target_server}{anvil_node1_host_name}, |
|
"target_server::anvil_node2_host_uuid" => $anvil->data->{target_server}{anvil_node2_host_uuid}, |
|
"target_server::anvil_node2_host_name" => $anvil->data->{target_server}{anvil_node2_host_name}, |
|
"target_server::anvil_dr1_host_uuid" => $anvil->data->{target_server}{anvil_dr1_host_uuid}, |
|
"target_server::anvil_dr1_host_name" => $anvil->data->{target_server}{anvil_dr1_host_name}, |
|
}}); |
|
if ($dr1_host_uuid) |
|
{ |
|
$anvil->data->{target_server}{anvil_dr1_host_uuid} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{anvil_dr1_host_uuid}; |
|
$anvil->data->{target_server}{anvil_dr1_host_name} = $anvil->data->{hosts}{host_uuid}{$dr1_host_uuid}{host_name};; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_dr1_host_uuid" => $anvil->data->{target_server}{anvil_dr1_host_uuid}, |
|
"target_server::anvil_dr1_host_name" => $anvil->data->{target_server}{anvil_dr1_host_name}, |
|
}}); |
|
} |
|
|
|
### Pull out details of the server. |
|
# How much RAM are we using and how much is configured? |
|
$anvil->data->{target_server}{ram_in_use} = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_ram_in_use}; |
|
$anvil->data->{target_server}{configured_ram} = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_configured_ram}; |
|
$anvil->data->{target_server}{server_host_uuid} = $server_host_uuid; |
|
$anvil->data->{target_server}{server_host_name} = $anvil->data->{hosts}{host_uuid}{$server_host_uuid}{host_name}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::ram_in_use" => $anvil->Convert->add_commas({number => $anvil->data->{target_server}{ram_in_use}})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{target_server}{ram_in_use}}).")", |
|
"target_server::configured_ram" => $anvil->Convert->add_commas({number => $anvil->data->{target_server}{configured_ram}})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{target_server}{configured_ram}}).")", |
|
"target_server::server_host_uuid" => $anvil->data->{target_server}{server_host_uuid}, |
|
"target_server::server_host_name" => $anvil->data->{target_server}{server_host_name}, |
|
}}); |
|
if ($anvil->data->{target_server}{server_state} eq "shut off") |
|
{ |
|
$anvil->data->{target_server}{ram_in_use} = 0; |
|
$anvil->data->{target_server}{server_host_uuid} = ""; |
|
$anvil->data->{target_server}{server_host_name} = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::ram_in_use" => $anvil->Convert->add_commas({number => $anvil->data->{target_server}{ram_in_use}})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{target_server}{ram_in_use}}).")", |
|
"target_server::server_host_uuid" => $anvil->data->{target_server}{server_host_uuid}, |
|
"target_server::server_host_name" => $anvil->data->{target_server}{server_host_name}, |
|
}}); |
|
} |
|
|
|
# Does this server boot after others, or stay off? |
|
$anvil->data->{target_server}{boot}{after_server_name} = ""; |
|
$anvil->data->{target_server}{boot}{after_server_uuid} = ""; |
|
$anvil->data->{target_server}{boot}{start_delay} = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"servers::server_uuid::${server_uuid}::server_start_after_server_uuid" => $anvil->data->{servers}{server_uuid}{$server_uuid}{server_start_after_server_uuid}, |
|
}}); |
|
if (($anvil->data->{servers}{server_uuid}{$server_uuid}{server_start_after_server_uuid}) && ($anvil->data->{servers}{server_uuid}{$server_uuid}{server_start_after_server_uuid} ne "NULL")) |
|
{ |
|
my $start_after_server_uuid = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_start_after_server_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { start_after_server_uuid => $start_after_server_uuid }}); |
|
|
|
if ($start_after_server_uuid eq "00000000-0000-0000-0000-000000000000") |
|
{ |
|
# Stay off |
|
$anvil->data->{target_server}{boot}{after_server_name} = $anvil->Words->string({key => "striker_0292"}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::boot::after_server_name" => $anvil->data->{target_server}{boot}{after_server_name}, |
|
}}); |
|
} |
|
else |
|
{ |
|
# Server proper |
|
$anvil->data->{target_server}{boot}{after_server_name} = $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$start_after_server_uuid}{server_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::boot::after_server_name" => $anvil->data->{target_server}{boot}{after_server_name}, |
|
}}); |
|
} |
|
$anvil->data->{target_server}{boot}{after_server_uuid} = "00000000-0000-0000-0000-000000000000"; |
|
$anvil->data->{target_server}{boot}{start_delay} = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_start_delay}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::boot::after_server_uuid" => $anvil->data->{target_server}{boot}{after_server_uuid}, |
|
"target_server::boot::start_delay" => $anvil->data->{target_server}{boot}{start_delay}, |
|
}}); |
|
} |
|
|
|
# Get a list of files on this Anvil! |
|
foreach my $file_uuid (keys %{$anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}}) |
|
{ |
|
my $file_name = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_name}; |
|
my $file_type = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_type}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
file_uuid => $file_uuid, |
|
file_name => $file_name, |
|
file_type => $file_type, |
|
}}); |
|
|
|
$anvil->data->{files}{$file_type}{name}{$file_name}{directory} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_directory}; |
|
$anvil->data->{files}{$file_type}{name}{$file_name}{file_size} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_size}; |
|
$anvil->data->{files}{$file_type}{name}{$file_name}{md5sum} = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_md5sum}; |
|
$anvil->data->{files}{$file_type}{name}{$file_name}{file_uuid} = $file_uuid; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"files::${file_type}::name::${file_name}::directory" => $anvil->data->{files}{$file_type}{name}{$file_name}{directory}, |
|
"files::${file_type}::name::${file_name}::file_size" => $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->Convert->add_commas({number => $anvil->data->{files}{$file_type}{name}{$file_name}{file_size}})})." (".$anvil->data->{files}{$file_type}{name}{$file_name}{file_size}.")", |
|
"files::${file_type}::name::${file_name}::md5sum" => $anvil->data->{files}{$file_type}{name}{$file_name}{md5sum}, |
|
"files::${file_type}::name::${file_name}::file_uuid" => $anvil->data->{files}{$file_type}{name}{$file_name}{file_uuid}, |
|
}}); |
|
} |
|
|
|
# Get and parse the server's definition. |
|
$anvil->Database->get_server_definitions({ |
|
debug => 2, |
|
server_uuid => $server_uuid, |
|
}); |
|
|
|
my $short_host_name = $anvil->Get->short_host_name(); |
|
my $definition_uuid = $anvil->data->{server_definitions}{server_definition_server_uuid}{$server_uuid}{server_definition_uuid}; |
|
my $definition_xml = $anvil->data->{server_definitions}{server_definition_server_uuid}{$server_uuid}{server_definition_xml}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { |
|
's1:short_host_name' => $short_host_name, |
|
's2:definition_uuid' => $definition_uuid, |
|
's3:definition_xml' => $definition_xml, |
|
}}); |
|
|
|
$anvil->Server->parse_definition({ |
|
debug => 2, |
|
source => "from_db", |
|
server => $anvil->data->{target_server}{server_name}, |
|
definition => $definition_xml, |
|
host => $short_host_name, |
|
}); |
|
|
|
# If only VCPU is set, cores and threads will both be '1' but 'total' will be higher. |
|
# Windows (and others?) interprets this as X number of single core sockets. |
|
$anvil->data->{target_server}{server_cpu_total} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{cpu}{total_cores} if not defined $anvil->data->{target_server}{server_cpu_total}; |
|
$anvil->data->{target_server}{server_cpu_sockets} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{cpu}{sockets} if not defined $anvil->data->{target_server}{server_cpu_sockets}; |
|
$anvil->data->{target_server}{server_cpu_cores} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{cpu}{threads} if not defined $anvil->data->{target_server}{server_cpu_cores}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
's1:target_server::server_cpu_sockets' => $anvil->data->{target_server}{server_cpu_sockets}, |
|
's2:target_server::server_cpu_cores' => $anvil->data->{target_server}{server_cpu_cores}, |
|
's3:target_server::server_cpu_total' => $anvil->data->{target_server}{server_cpu_total}, |
|
}}); |
|
|
|
if (($anvil->data->{target_server}{server_cpu_sockets} == 1) && ($anvil->data->{target_server}{server_cpu_cores} == 1) && ($anvil->data->{target_server}{server_cpu_total} > 1)) |
|
{ |
|
$anvil->data->{target_server}{server_cpu_sockets} = $anvil->data->{target_server}{server_cpu_total}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
's1:target_server::server_cpu_sockets' => $anvil->data->{target_server}{server_cpu_sockets}, |
|
}}); |
|
} |
|
|
|
# Pull out the existing disks. |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{disk}{target}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { target => $target }}); |
|
|
|
$anvil->data->{target_server}{disk}{$target}{device_bus} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{disk}{target}{$target}{device_bus}; |
|
$anvil->data->{target_server}{disk}{$target}{boot_order} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{disk}{target}{$target}{boot_order} ? $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{disk}{target}{$target}{boot_order} : 0; |
|
$anvil->data->{target_server}{disk}{$target}{cache} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{disk}{target}{$target}{driver}{cache}; |
|
$anvil->data->{target_server}{disk}{$target}{io} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{disk}{target}{$target}{driver}{io}; |
|
$anvil->data->{target_server}{disk}{$target}{path} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{disk}{target}{$target}{path}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::disk::${target}::device_bus" => $anvil->data->{target_server}{disk}{$target}{device_bus}, |
|
"target_server::disk::${target}::boot_order" => $anvil->data->{target_server}{disk}{$target}{boot_order}, |
|
"target_server::disk::${target}::cache" => $anvil->data->{target_server}{disk}{$target}{cache}, |
|
"target_server::disk::${target}::io" => $anvil->data->{target_server}{disk}{$target}{io}, |
|
"target_server::disk::${target}::path" => $anvil->data->{target_server}{disk}{$target}{path}, |
|
}}); |
|
|
|
if ($anvil->data->{target_server}{disk}{$target}{boot_order}) |
|
{ |
|
my $boot_order = $anvil->data->{target_server}{disk}{$target}{boot_order}; |
|
$anvil->data->{target_server}{boot_order}{$boot_order} = $target; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::boot_order::${boot_order}::${target}" => $anvil->data->{target_server}{boot_order}{$boot_order}, |
|
}}); |
|
} |
|
} |
|
|
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{cdrom}{target}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { target => $target }}); |
|
|
|
$anvil->data->{target_server}{cdrom}{$target}{device_bus} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{cdrom}{target}{$target}{device_bus}; |
|
$anvil->data->{target_server}{cdrom}{$target}{boot_order} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{cdrom}{target}{$target}{boot_order} ? $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{cdrom}{target}{$target}{boot_order} : 0; |
|
$anvil->data->{target_server}{cdrom}{$target}{path} = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{cdrom}{target}{$target}{path}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::cdrom::${target}::device_bus" => $anvil->data->{target_server}{cdrom}{$target}{device_bus}, |
|
"target_server::cdrom::${target}::boot_order" => $anvil->data->{target_server}{cdrom}{$target}{boot_order}, |
|
"target_server::cdrom::${target}::path" => $anvil->data->{target_server}{cdrom}{$target}{path}, |
|
}}); |
|
|
|
if ($anvil->data->{target_server}{cdrom}{$target}{boot_order}) |
|
{ |
|
my $boot_order = $anvil->data->{target_server}{cdrom}{$target}{boot_order}; |
|
$anvil->data->{target_server}{boot_order}{$boot_order} = $target; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::boot_order::${boot_order}::${target}" => $anvil->data->{target_server}{boot_order}{$boot_order}, |
|
}}); |
|
} |
|
} |
|
|
|
foreach my $script ("pre_migration", "post_migration") |
|
{ |
|
my $file_uuid_key = "server_".$script."_file_uuid"; |
|
my $argument_key = "server_".$script."_arguments"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
script => $script, |
|
file_uuid_key => $file_uuid_key, |
|
}}); |
|
|
|
$anvil->data->{target_server}{scripts}{$script}{file_uuid} = ""; |
|
$anvil->data->{target_server}{scripts}{$script}{file_name} = ""; |
|
$anvil->data->{target_server}{scripts}{$script}{arguments} = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"servers::server_uuid::${server_uuid}::${file_uuid_key}" => $anvil->data->{servers}{server_uuid}{$server_uuid}{$file_uuid_key}, |
|
}}); |
|
if (($anvil->data->{servers}{server_uuid}{$server_uuid}{$file_uuid_key}) && ($anvil->data->{servers}{server_uuid}{$server_uuid}{$file_uuid_key} ne "NULL")) |
|
{ |
|
my $file_uuid = $anvil->data->{servers}{server_uuid}{$server_uuid}{$file_uuid_key}; |
|
my $file_name = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_name}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
file_uuid => $file_uuid, |
|
file_name => $file_name, |
|
}}); |
|
|
|
$anvil->data->{target_server}{scripts}{$script}{file_uuid} = $file_uuid; |
|
$anvil->data->{target_server}{scripts}{$script}{file_name} = $file_name; |
|
$anvil->data->{target_server}{scripts}{$script}{arguments} = $anvil->data->{servers}{server_uuid}{$server_uuid}{$argument_key}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::scripts::${script}::file_uuid" => $anvil->data->{target_server}{scripts}{$script}{file_uuid}, |
|
"target_server::scripts::${script}::file_name" => $anvil->data->{target_server}{scripts}{$script}{file_name}, |
|
"target_server::scripts::${script}::arguments" => $anvil->data->{target_server}{scripts}{$script}{arguments}, |
|
}}); |
|
} |
|
} |
|
|
|
# Get the available resources. |
|
$anvil->Get->available_resources({debug => 2}); |
|
} |
|
else |
|
{ |
|
# Bad server UUID. If it's a job, abort. Otherwise, clear and go back to |
|
my $variables = { server_uuid => $anvil->data->{target_server}{server_uuid} }; |
|
$anvil->Jobs->update_progress({ |
|
progress => 100, |
|
message => "error_0318", |
|
variables => $variables, |
|
job_status => "failed", |
|
log_level => 1, |
|
priority => "err", |
|
}); |
|
if ($anvil->data->{switches}{'job-uuid'}) |
|
{ |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
$anvil->data->{target_server}{server_uuid} = ""; |
|
} |
|
} |
|
|
|
# If we don't have an Anvil! UUID at this point, we need to ask the user. |
|
my $termios = new POSIX::Termios; |
|
$termios->getattr; |
|
my $ospeed = $termios->getospeed; |
|
|
|
my $terminal = Tgetent Term::Cap { TERM => undef, OSPEED => $ospeed }; |
|
$terminal->Trequire(qw/ce ku kd/); |
|
|
|
if (not $anvil->data->{target_server}{anvil_uuid}) |
|
{ |
|
interactive_ask_anvil_name($anvil, $terminal); |
|
} |
|
if (not $anvil->data->{target_server}{server_uuid}) |
|
{ |
|
interactive_ask_server_name($anvil, $terminal); |
|
} |
|
|
|
# Made it here? Show the menu. |
|
interactive_configure_main($anvil, $terminal); |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_configure_main |
|
{ |
|
my ($anvil, $terminal) = @_; |
|
|
|
while(1) |
|
{ |
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
|
|
my $changes = 0; |
|
my $cpu_star = ""; |
|
my $ram_star = ""; |
|
my $storage_star = ""; |
|
if (($anvil->data->{new_config}{cpu}{sockets}) or ($anvil->data->{new_config}{cpu}{cores})) |
|
{ |
|
$cpu_star = "*"; |
|
$changes = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cpu_star => $cpu_star, |
|
changes => $changes, |
|
}}); |
|
} |
|
if ($anvil->data->{new_config}{ram}{'bytes'}) |
|
{ |
|
$ram_star = "*"; |
|
$changes = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
ram_star => $ram_star, |
|
changes => $changes, |
|
}}); |
|
} |
|
if (exists $anvil->data->{new_config}{storage_group_data}) |
|
{ |
|
foreach my $storage_group_name (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::new_drive_size" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}, |
|
}}); |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}) |
|
{ |
|
$storage_star = "*"; |
|
$changes = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
storage_star => $storage_star, |
|
changes => $changes, |
|
}}); |
|
} |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { target => $target }}); |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}) |
|
{ |
|
$storage_star = "*"; |
|
$changes = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
storage_star => $storage_star, |
|
changes => $changes, |
|
}}); |
|
} |
|
} |
|
} |
|
} |
|
|
|
print "[ 1 ] - CPU".$cpu_star."\n"; |
|
print "[ 2 ] - RAM".$ram_star."\n"; |
|
print "[ 3 ] - Storage".$storage_star."\n"; |
|
print "[ 4 ] - Network\n"; |
|
print "[ 5 ] - Boot Order\n"; |
|
print "[ 6 ] - Cluster Management\n"; |
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
if ($changes) |
|
{ |
|
if (($anvil->data->{new_config}{cpu}{sockets}) or ($anvil->data->{new_config}{cpu}{cores})) |
|
{ |
|
$changes++; |
|
my $say_old_cpu = $anvil->data->{old_config}{cpu}{sockets}." socket(s), ".$anvil->data->{old_config}{cpu}{cores}." core(s)"; |
|
my $say_new_cpu = $anvil->data->{new_config}{cpu}{sockets}." socket(s), ".$anvil->data->{new_config}{cpu}{cores}." core(s)"; |
|
print " - Change CPU from: [".$say_old_cpu."] to: [".$say_new_cpu."]\n"; |
|
} |
|
if ($anvil->data->{new_config}{ram}{'bytes'}) |
|
{ |
|
$changes++; |
|
my $say_old_ram = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{old_config}{ram}{'bytes'}}); |
|
my $say_new_ram = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{new_config}{ram}{'bytes'}}); |
|
print " - Change RAM from: [".$say_old_ram."] to: [".$say_new_ram."]\n"; |
|
} |
|
if (exists $anvil->data->{new_config}{storage_group_data}) |
|
{ |
|
foreach my $storage_group_name (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::new_drive_size" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}, |
|
}}); |
|
|
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} =~ /new:(\d+)$/) |
|
{ |
|
my $say_new_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $1}); |
|
$changes++; |
|
print " - Create a new drive that is: [".$say_new_size."] large.\n"; |
|
} |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::target::${target}::changes" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}, |
|
}}); |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} =~ /grow:(\d+)$/) |
|
{ |
|
my $say_new_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $1}); |
|
my $say_old_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}}); |
|
$changes++; |
|
print " - Grow: [".$storage_group_name."/".$target."] from: [".$say_old_size."] to: [".$say_new_size."]\n"; |
|
} |
|
elsif ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} eq "delete") |
|
{ |
|
my $say_old_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}}); |
|
$changes++; |
|
print " - Delete: [".$storage_group_name."/".$target."], freeing up: [".$say_old_size."].\n"; |
|
} |
|
} |
|
} |
|
} |
|
|
|
print "[ S ] - Save and commit the changes.\n"; |
|
} |
|
print "\n"; |
|
print $terminal->Tgoto('cm', 0, (10+$changes))."? "; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
|
|
if ($answer eq "1") |
|
{ |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
elsif ($answer eq "2") |
|
{ |
|
interactive_configure_ram($anvil, $terminal); |
|
} |
|
elsif ($answer eq "3") |
|
{ |
|
interactive_configure_storage($anvil, $terminal); |
|
} |
|
elsif ($answer eq "4") |
|
{ |
|
print "Going to Network menu\n"; |
|
sleep 1; |
|
} |
|
elsif ($answer eq "5") |
|
{ |
|
print "Going to Boot order menu\n"; |
|
sleep 1; |
|
} |
|
elsif ($answer eq "6") |
|
{ |
|
print "Going to cluster manager menu\n"; |
|
sleep 1; |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
$anvil->data->{target_server}{server_name} = ""; |
|
$anvil->data->{target_server}{server_uuid} = ""; |
|
$anvil->data->{switches}{server} = ""; |
|
interactive_ask_server_name($anvil, $terminal); |
|
} |
|
elsif (lc($answer) eq "s") |
|
{ |
|
# Confirm changes |
|
print "Confirm chagnes menu\n"; |
|
sleep 1; |
|
} |
|
else |
|
{ |
|
print "Invalid selection, please enter the digit for the menu you want.\n"; |
|
sleep 1; |
|
} |
|
=cut |
|
1. CPU |
|
* Max (threads): X |
|
1. Sockets: |
|
2. Cores: |
|
2. RAM |
|
* Available: X |
|
* In use: y |
|
* Configured: z |
|
1. Size: |
|
3. Storage |
|
1. Optical media |
|
<list drives> |
|
1. Insert / change |
|
<file list> |
|
2. Eject |
|
2. Disks |
|
1. New |
|
<storage groups (size available)> |
|
<list drives> |
|
1. Grow |
|
2. Delete |
|
3. Move <when 2+ storage groups> |
|
3. Boot order |
|
<list disks, 0 == don't boot> |
|
4. Network |
|
<interface list> |
|
1. MAC Address |
|
2. emulation type |
|
3. <toggle> Plug in / Unplug |
|
4. Bridge |
|
5. Delete |
|
1. Add |
|
5. Boot Order |
|
=cut |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_configure_storage |
|
{ |
|
my ($anvil, $terminal) = @_; |
|
|
|
while(1) |
|
{ |
|
# Here, we'll list each storage pool and for each indicate if it's used and, if so |
|
$anvil->Database->get_storage_group_data(); |
|
my $index = 1; |
|
my $lines = 2; |
|
my $changes = ""; |
|
|
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
print "* Storage configuration.\n"; |
|
my $anvil_uuid = $anvil->data->{target_server}{anvil_uuid}; |
|
foreach my $storage_group_name (sort {$a cmp $b} keys %{$anvil->data->{storage_groups}{anvil_uuid}{$anvil_uuid}{storage_group_name}}) |
|
{ |
|
my $storage_group_uuid = $anvil->data->{storage_groups}{anvil_uuid}{$anvil_uuid}{storage_group_name}{$storage_group_name}{storage_group_uuid}; |
|
my $vg_size = $anvil->data->{anvil_resources}{$anvil_uuid}{storage_group}{$storage_group_uuid}{vg_size}; |
|
my $free_size = $anvil->data->{anvil_resources}{$anvil_uuid}{storage_group}{$storage_group_uuid}{free_size}; |
|
my $vg_size_on_dr = $anvil->data->{anvil_resources}{$anvil_uuid}{storage_group}{$storage_group_uuid}{vg_size_on_dr}; |
|
my $available_on_dr = $anvil->data->{anvil_resources}{$anvil_uuid}{storage_group}{$storage_group_uuid}{available_on_dr}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
's1:storage_group_name' => $storage_group_name, |
|
's2:storage_group_uuid' => $storage_group_uuid, |
|
's3:vg_size' => $vg_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $vg_size}).")", |
|
's4:free_size' => $free_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $free_size}).")", |
|
's5:vg_size_on_dr' => $vg_size_on_dr." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $vg_size_on_dr}).")", |
|
's6:available_on_dr' => $free_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $available_on_dr}).")", |
|
}}); |
|
|
|
# Store the SG options so we can pull up the details when a user selects one to work |
|
# with |
|
$anvil->data->{storage_group_data}{$index}{name} = $storage_group_name; |
|
$anvil->data->{storage_group_data}{$index}{uuid} = $storage_group_uuid; |
|
$anvil->data->{storage_group_data}{$index}{size} = $vg_size; |
|
$anvil->data->{storage_group_data}{$index}{free} = $free_size; |
|
$anvil->data->{storage_group_data}{$index}{used} = $vg_size - $free_size; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:storage_group_data::${index}::name" => $anvil->data->{storage_group_data}{$index}{name}, |
|
"s2:storage_group_data::${index}::uuid" => $anvil->data->{storage_group_data}{$index}{uuid}, |
|
"s3:storage_group_data::${index}::size" => $anvil->data->{storage_group_data}{$index}{size}." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{storage_group_data}{$index}{size}}).")", |
|
"s4:storage_group_data::${index}::free" => $anvil->data->{storage_group_data}{$index}{free}." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{storage_group_data}{$index}{free}}).")", |
|
"s5:storage_group_data::${index}::used" => $anvil->data->{storage_group_data}{$index}{used}." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{storage_group_data}{$index}{used}}).")", |
|
}}); |
|
|
|
if (not exists $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}) |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::new_drive_size" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}, |
|
}}); |
|
} |
|
|
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{target_server}{disk}}) |
|
{ |
|
my $device_bus = $anvil->data->{target_server}{disk}{$target}{device_bus}; |
|
my $cache = $anvil->data->{target_server}{disk}{$target}{cache}; |
|
my $io = $anvil->data->{target_server}{disk}{$target}{io}; |
|
my $this_path = $anvil->data->{target_server}{disk}{$target}{path}; |
|
my $boot_order = $anvil->data->{target_server}{disk}{$target}{boot_order} ? $anvil->data->{target_server}{disk}{$target}{boot_order} : ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
target => $target, |
|
device_bus => $device_bus, |
|
cache => $cache, |
|
io => $io, |
|
this_path => $this_path, |
|
boot_order => $boot_order, |
|
}}); |
|
|
|
my $this_storage_group_uuid = $anvil->Storage->get_storage_group_from_path({ |
|
debug => 2, |
|
anvil_uuid => $anvil_uuid, |
|
path => $this_path, |
|
}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { this_storage_group_uuid => $this_storage_group_uuid }}); |
|
|
|
if (($this_storage_group_uuid) && ($storage_group_uuid eq $this_storage_group_uuid)) |
|
{ |
|
$anvil->data->{storage_group_data}{$index}{target}{$target}{path} = $this_path; |
|
$anvil->data->{storage_group_data}{$index}{target}{$target}{boot_order} = $boot_order; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:storage_group_data::${index}::target::${target}::path" => $anvil->data->{storage_group_data}{$index}{target}{$target}{path}, |
|
"s2:storage_group_data::${index}::target::${target}::boot_order" => $anvil->data->{storage_group_data}{$index}{target}{$target}{boot_order}, |
|
}}); |
|
|
|
if (not exists $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}) |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} = ""; |
|
} |
|
$changes = $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} ? "*" : ""; |
|
} |
|
} |
|
|
|
$lines += 2; |
|
print "[ ".$index." ] - Name: \"".$storage_group_name."\" - Size: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $vg_size})."], Free: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $free_size})."]".$changes."\n"; |
|
|
|
my $path_count = keys %{$anvil->data->{storage_group_data}{$index}{target}}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { path_count => $path_count }}); |
|
if ($path_count) |
|
{ |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{storage_group_data}{$index}{target}}) |
|
{ |
|
my $path = $anvil->data->{storage_group_data}{$index}{target}{$target}{path}; |
|
my $boot_order = $anvil->data->{storage_group_data}{$index}{target}{$target}{boot_order}; |
|
my $size = $anvil->Storage->get_size_of_block_device({path => $path}); |
|
my $say_size = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
size => $size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $size}).")", |
|
}}); |
|
if ($size !~ /^\d+$/) |
|
{ |
|
$say_size = "<unknwon>"; |
|
} |
|
else |
|
{ |
|
$say_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $size}) |
|
} |
|
|
|
print " - Target: [".$target."], boot order: [".$boot_order."], backed by: [".$path."], Size: [".$say_size."]\n"; |
|
$lines++; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { lines => $lines }}); |
|
|
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}) |
|
{ |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} =~ /grow:(\d+)$/) |
|
{ |
|
my $new_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $1}); |
|
$lines++; |
|
print " - Will grow to: [".$new_size."]\n"; |
|
} |
|
elsif ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} eq "delete") |
|
{ |
|
$lines++; |
|
print " - Marked for deletion!\n"; |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
print " - <Storage group not used by this server yet>\n"; |
|
} |
|
|
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} =~ /new:(\d+)/) |
|
{ |
|
print " - New drive will be created that is: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $1})."] large.\n"; |
|
$lines++; |
|
} |
|
$index++; |
|
} |
|
|
|
# Optical drives |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{target_server}{cdrom}}) |
|
{ |
|
$anvil->data->{optical_drives}{$index}{target} = $target; |
|
$anvil->data->{optical_drives}{$index}{device_bus} = $anvil->data->{target_server}{cdrom}{$target}{device_bus}; |
|
$anvil->data->{optical_drives}{$index}{boot_order} = $anvil->data->{target_server}{cdrom}{$target}{boot_order}; |
|
$anvil->data->{optical_drives}{$index}{iso} = $anvil->data->{target_server}{cdrom}{$target}{path}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"optical_drives::${index}::target" => $anvil->data->{optical_drives}{$index}{target}, |
|
"optical_drives::${index}::device_bus" => $anvil->data->{optical_drives}{$index}{device_bus}, |
|
"optical_drives::${index}::boot_order" => $anvil->data->{optical_drives}{$index}{boot_order}, |
|
"optical_drives::${index}::iso" => $anvil->data->{optical_drives}{$index}{iso}, |
|
}}); |
|
|
|
my $say_disc = $anvil->data->{optical_drives}{$index}{iso} ? $anvil->data->{optical_drives}{$index}{iso} : "<ejected>"; |
|
print "[ ".$index." ] - Optical drive: [".$anvil->data->{optical_drives}{$index}{device_bus}."/".$target."], boot order: [".$anvil->data->{optical_drives}{$index}{boot_order}."], ISO: [".$say_disc."]\n"; |
|
$index++; |
|
$lines++; |
|
} |
|
|
|
foreach my $boot_order (sort {$a <=> $b} keys %{$anvil->data->{target_server}{boot_order}}) |
|
{ |
|
my $target = $anvil->data->{target_server}{boot_order}{$boot_order}; |
|
my $path = exists $anvil->data->{target_server}{disk}{$target} ? $anvil->data->{target_server}{disk}{$target}{boot_order} : $anvil->data->{target_server}{cdrom}{$target}{path}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:boot_order" => $boot_order, |
|
"s2:target" => $target, |
|
"s3:path" => $path, |
|
}}); |
|
} |
|
|
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
if ($changes) |
|
{ |
|
print "- Changes can be committed on the main page.\n"; |
|
print $terminal->Tgoto('cm', 0, ($lines+3))."? "; |
|
} |
|
else |
|
{ |
|
print $terminal->Tgoto('cm', 0, ($lines+2))."? "; |
|
} |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
if ($answer =~ /^\d+$/) |
|
{ |
|
if (exists $anvil->data->{storage_group_data}{$answer}) |
|
{ |
|
interactive_configure_storage_group($anvil, $terminal, $answer); |
|
} |
|
elsif (exists $anvil->data->{optical_drives}{$index}) |
|
{ |
|
interactive_configure_optical_disk($anvil, $terminal, $answer); |
|
} |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
interactive_configure_main($anvil, $terminal); |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_configure_optical_disk |
|
{ |
|
my ($anvil, $terminal, $index) = @_; |
|
|
|
while(1) |
|
{ |
|
# This refreshes files as well. |
|
$anvil->Database->get_anvils(); |
|
|
|
my $lines = 3; |
|
my $target = $anvil->data->{optical_drives}{$index}{target}; |
|
my $device_bus = $anvil->data->{optical_drives}{$index}{device_bus}; |
|
my $boot_order = $anvil->data->{optical_drives}{$index}{boot_order}; |
|
my $iso = $anvil->data->{optical_drives}{$index}{iso}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:target" => $target, |
|
"s2:device_bus" => $device_bus, |
|
"s3:boot_order" => $boot_order, |
|
"s4:iso" => $iso, |
|
}}); |
|
|
|
if (not exists $anvil->data->{new_config}{optical}{$target}) |
|
{ |
|
$anvil->data->{new_config}{optical}{$target}{changes} = ""; |
|
$anvil->data->{old_config}{optical}{$target}{disc} = $iso; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:new_config::optical::${target}::changes" => $anvil->data->{new_config}{optical}{$target}{changes}, |
|
"s1:old_config::optical::${target}::disc" => $anvil->data->{old_config}{optical}{$target}{disc}, |
|
}}); |
|
} |
|
if ($anvil->data->{new_config}{optical}{$target}{changes}) |
|
{ |
|
$changes = 1; |
|
} |
|
|
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
print "* Managing: [".$device_bus."/".$target."]\n"; |
|
if ($iso) |
|
{ |
|
print "[ E ] - Eject: [".$iso."]\n"; |
|
if ($anvil->data->{new_config}{optical}{$target}{changes} eq "eject") |
|
{ |
|
print " - To be ejected.\n"; |
|
$lines++; |
|
} |
|
print "[ C ] - Change disc.\n"; |
|
$lines += 2; |
|
} |
|
else |
|
{ |
|
print "[ I ] - Insert ISO\n"; |
|
$lines++; |
|
} |
|
|
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
if ($changes) |
|
{ |
|
print "- Changes can be committed on the main page.\n"; |
|
print $terminal->Tgoto('cm', 0, ($lines+3))."? "; |
|
} |
|
else |
|
{ |
|
print $terminal->Tgoto('cm', 0, ($lines+2))."? "; |
|
} |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
if ((lc($answer) eq "e") && ($iso)) |
|
{ |
|
$anvil->data->{new_config}{optical}{$target}{changes} = "eject"; |
|
$anvil->data->{old_config}{optical}{$target}{disc} = $iso; |
|
print "The disc: [".$iso."] will be ejected.\n"; |
|
hold_for_input($anvil); |
|
} |
|
elsif ((lc($answer) eq "c") && (lc($answer) eq "i")) |
|
{ |
|
my $file_uuid = pick_file($anvil, $terminal, $index); |
|
if ($file_uuid) |
|
{ |
|
my $file_name = $anvil->data->{files}{file_uuid}{$file_uuid}{file_name}; |
|
$anvil->data->{new_config}{optical}{$target}{changes} = "insert:".$file_uuid; |
|
if ($iso) |
|
{ |
|
print "- Will replace the disc with: [".$file_name."].\n" |
|
} |
|
else |
|
{ |
|
print "- Will insert the disc: [".$file_name."].\n"; |
|
} |
|
hold_for_input($anvil); |
|
} |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
interactive_configure_storage($anvil, $terminal); |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub pick_file |
|
{ |
|
my ($anvil, $terminal, $drive_index) = @_; |
|
|
|
my $file_uuid = ""; |
|
my $anvil_uuid = $anvil->data->{target_server}{anvil_uuid}; |
|
my $target = $anvil->data->{optical_drives}{$drive_index}{target}; |
|
my $device_bus = $anvil->data->{optical_drives}{$drive_index}{device_bus}; |
|
my $boot_order = $anvil->data->{optical_drives}{$drive_index}{boot_order}; |
|
my $iso = $anvil->data->{optical_drives}{$drive_index}{iso}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:drive_index" => $drive_index, |
|
"s2:anvil_uuid" => $anvil_uuid, |
|
"s3:target" => $target, |
|
"s4:device_bus" => $device_bus, |
|
"s5:boot_order" => $boot_order, |
|
"s6:iso" => $iso, |
|
}}); |
|
|
|
while(1) |
|
{ |
|
$anvil->Database->get_anvils(); |
|
|
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
|
|
my $index = 1; |
|
my $lines = 3; |
|
|
|
print "* What file do you want to insert into: [".$device_bus."/".$target."]?\n"; |
|
foreach my $file_name (sort {$a cmp $b} keys %{$anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_name}}) |
|
{ |
|
my $file_uuid = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_name}{$file_name}{file_uuid}; |
|
my $file_directory = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_directory}; |
|
my $file_size = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_size}; |
|
my $file_md5sum = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_md5sum}; |
|
my $file_type = $anvil->data->{anvils}{anvil_uuid}{$anvil_uuid}{file_uuid}{$file_uuid}{file_type}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:file_name" => $file_name, |
|
"s2:file_uuid" => $file_uuid, |
|
"s3:file_directory" => $file_directory, |
|
"s4:file_size" => $file_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $file_size}).")", |
|
"s5:file_md5sum" => $file_md5sum, |
|
"s6:file_type" => $file_type, |
|
}}); |
|
|
|
next if $file_type ne "iso"; |
|
print "[ ".$index."] - ".$file_name.", size: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $file_size})."], md5_sum: [".$file_md5sum."]\n"; |
|
|
|
$anvil->data->{iso_files}{$index}{file_uuid} = $file_uuid; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:iso_files::${index}::file_uuid" => $anvil->data->{iso_files}{$index}{file_uuid}, |
|
}}); |
|
} |
|
|
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
print $terminal->Tgoto('cm', 0, ($lines+2))."? "; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
if (($answer =~ /^\d+$/) && (exists $anvil->data->{iso_files}{$answer})) |
|
{ |
|
return($anvil->data->{iso_files}{$answer}{file_uuid}); |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
return(""); |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_configure_storage_group |
|
{ |
|
my ($anvil, $terminal, $selected_sg) = @_; |
|
|
|
while(1) |
|
{ |
|
$anvil->Database->get_storage_group_data(); |
|
my $storage_group_name = $anvil->data->{storage_group_data}{$selected_sg}{name}; |
|
my $storage_group_uuid = $anvil->data->{storage_group_data}{$selected_sg}{uuid}; |
|
my $storage_group_size = $anvil->data->{storage_group_data}{$selected_sg}{size}; |
|
my $storage_group_free = $anvil->data->{storage_group_data}{$selected_sg}{free}; |
|
my $storage_group_used = $anvil->data->{storage_group_data}{$selected_sg}{used}; |
|
my $say_max_free = $anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:storage_group_name" => $storage_group_name, |
|
"s2:storage_group_uuid" => $storage_group_uuid, |
|
"s3:storage_group_size" => $storage_group_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_size}).")", |
|
"s4:storage_group_free" => $storage_group_free." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}).")", |
|
"s5:storage_group_used" => $storage_group_used." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_used}).")", |
|
"s6:say_max_free" => $say_max_free, |
|
}}); |
|
|
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
|
|
foreach my $storage_group_name (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}}) |
|
{ |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}}) |
|
{ |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} =~ /grow:(\d+)$/) |
|
{ |
|
my $added = $1 - $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}; |
|
$storage_group_used += $added; |
|
$storage_group_free -= $added; |
|
$say_max_free = $anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:added" => $added." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $added}).")", |
|
"s2:storage_group_used" => $storage_group_used." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_used}).")", |
|
"s3:storage_group_free" => $storage_group_free." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}).")", |
|
"s4:say_max_free" => $say_max_free, |
|
}}); |
|
} |
|
elsif ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} eq "delete") |
|
{ |
|
my $old_size = $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}; |
|
$storage_group_used -= $old_size; |
|
$storage_group_free -= $old_size; |
|
$say_max_free = $anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:old_size" => $old_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $old_size}).")", |
|
"s2:storage_group_used" => $storage_group_used." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_used}).")", |
|
"s3:storage_group_free" => $storage_group_free." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}).")", |
|
"s4:say_max_free" => $say_max_free, |
|
}}); |
|
} |
|
} |
|
} |
|
|
|
my $changes = ""; |
|
my $index = 1; |
|
my $lines = 2; |
|
my $drive = {}; |
|
|
|
print "* Storage Group: [".$storage_group_name."] configuration.\n"; |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{storage_group_data}{$selected_sg}{target}}) |
|
{ |
|
my $path = $anvil->data->{storage_group_data}{$selected_sg}{target}{$target}{path}; |
|
my $boot_order = $anvil->data->{storage_group_data}{$selected_sg}{target}{$target}{boot_order}; |
|
my $size = $anvil->Storage->get_size_of_block_device({path => $path}); |
|
my $say_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $size}); |
|
|
|
$drive->{$index} = $target; |
|
|
|
$changes = $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} ? "*" : ""; |
|
print "[ ".$index." ] - Manage: [".$target."], boot order: [".$boot_order."], backed by: [".$path."], Size: [".$say_size."]".$changes."\n"; |
|
$index++; |
|
$lines++; |
|
if ($changes) |
|
{ |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} =~ /grow:(\d+)$/) |
|
{ |
|
my $new_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $1}); |
|
$lines++; |
|
print " - Will grow to: [".$new_size."]\n"; |
|
} |
|
elsif ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} eq "delete") |
|
{ |
|
$lines++; |
|
print " - Marked for deletion!\n"; |
|
|
|
} |
|
} |
|
} |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}) |
|
{ |
|
my $say_requested = ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} =~ /new:(\d+)$/)[0]; |
|
$say_requested = $anvil->Convert->bytes_to_human_readable({'bytes' => $say_requested}); |
|
print "[ C ] - Cancel creation of new: [".$say_requested."] sized drive.\n"; |
|
} |
|
else |
|
{ |
|
print "[ N ] - New Drive\n"; |
|
} |
|
|
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
if ($changes) |
|
{ |
|
print "- Changes can be committed on the main page.\n"; |
|
print $terminal->Tgoto('cm', 0, ($lines+5))."? "; |
|
} |
|
else |
|
{ |
|
print $terminal->Tgoto('cm', 0, ($lines+4))."? "; |
|
} |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
if (($answer =~ /^\d+$/) && (exists $drive->{$answer})) |
|
{ |
|
my $target = $drive->{$answer}; |
|
interactive_configure_storage_group_manage_drive($anvil, $terminal, $selected_sg, $target); |
|
} |
|
elsif (lc($answer) eq "n") |
|
{ |
|
print "- How big would you like the new drive to be? Maximum is: [".$say_max_free."]\n"; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$answer =~ s/^\s+//; |
|
$answer =~ s/\s+$//; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
|
|
if ($answer) |
|
{ |
|
# Convert to bytes |
|
my $requested_bytes = $answer; |
|
if ($requested_bytes =~ /\D/) |
|
{ |
|
$requested_bytes = $anvil->Convert->human_readable_to_bytes({ |
|
base2 => 1, |
|
size => $requested_bytes, |
|
}); |
|
if ($requested_bytes eq "!!error!!") |
|
{ |
|
# Problem. |
|
$requested_bytes = ""; |
|
print "[ Error ] - The answer: [".$answer."] could not be interpretted as a size.\n"; |
|
hold_for_input($anvil); |
|
} |
|
} |
|
|
|
if (($requested_bytes =~ /^\d+$/) && ($requested_bytes > $storage_group_free)) |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::new_drive_size" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}, |
|
}}); |
|
print "[ Error ] - You asked for: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $requested_bytes})."] (".$anvil->Convert->add_commas({number => $requested_bytes})." bytes), but the max available is: [".$say_max_free."] (".$anvil->Convert->add_commas({number => $storage_group_free})." bytes).\n"; |
|
hold_for_input($anvil); |
|
} |
|
elsif ($requested_bytes) |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} = "new:".$requested_bytes; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::new_drive_size" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}, |
|
}}); |
|
} |
|
} |
|
} |
|
elsif ((lc($answer) eq "c") && ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size})) |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::new_drive_size" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}, |
|
}}); |
|
print "- New volume will NOT be created.\n"; |
|
hold_for_input($anvil); |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
interactive_configure_storage($anvil, $terminal); |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_configure_storage_group_manage_drive |
|
{ |
|
my ($anvil, $terminal, $selected_sg, $target) = @_; |
|
|
|
while(1) |
|
{ |
|
$anvil->Database->get_storage_group_data(); |
|
my $storage_group_name = $anvil->data->{storage_group_data}{$selected_sg}{name}; |
|
my $storage_group_uuid = $anvil->data->{storage_group_data}{$selected_sg}{uuid}; |
|
my $storage_group_size = $anvil->data->{storage_group_data}{$selected_sg}{size}; |
|
my $storage_group_free = $anvil->data->{storage_group_data}{$selected_sg}{free}; |
|
my $storage_group_used = $anvil->data->{storage_group_data}{$selected_sg}{used}; |
|
my $path = $anvil->data->{storage_group_data}{$selected_sg}{target}{$target}{path}; |
|
my $boot_order = $anvil->data->{storage_group_data}{$selected_sg}{target}{$target}{boot_order}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:selected_sg" => $selected_sg, |
|
"s2:target" => $target, |
|
"s3:storage_group_name" => $storage_group_name, |
|
"s4:storage_group_uuid" => $storage_group_uuid, |
|
"s5:storage_group_size" => $storage_group_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_size}).")", |
|
"s6:storage_group_free" => $storage_group_free." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}).")", |
|
"s6:storage_group_used" => $storage_group_used." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_used}).")", |
|
"s7:path" => $path, |
|
"s8:boot_order" => $boot_order, |
|
}}); |
|
|
|
my $size = $anvil->Storage->get_size_of_block_device({path => $path}); |
|
my $say_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $size}); |
|
my $max_assignable = ($size + $storage_group_free); |
|
my $say_max_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $max_assignable}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:size" => $size, |
|
"s2:max_assignable" => $say_size, |
|
"s3:say_max_size" => $say_max_size, |
|
}}); |
|
|
|
foreach my $storage_group_name (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::new_drive_size" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size}, |
|
}}); |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{new_drive_size} =~ /new:(\d+)$/) |
|
{ |
|
my $to_create = $1; |
|
$storage_group_used += $to_create; |
|
$storage_group_free -= $to_create; |
|
$max_assignable = $size + $storage_group_free; |
|
$say_max_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $max_assignable}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:to_create" => $to_create." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $to_create}).")", |
|
"s2:storage_group_used" => $storage_group_used." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_used}).")", |
|
"s3:storage_group_free" => $storage_group_free." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}).")", |
|
"s4:max_assignable" => $max_assignable, |
|
"s5:say_max_size" => $say_max_size, |
|
}}); |
|
} |
|
foreach my $target (sort {$a cmp $b} keys %{$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}}) |
|
{ |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} =~ /grow:(\d+)$/) |
|
{ |
|
my $added = $1 - $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}; |
|
$storage_group_used += $added; |
|
$storage_group_free -= $added; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:added" => $added." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $added}).")", |
|
"s2:storage_group_used" => $storage_group_used." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_used}).")", |
|
"s3:storage_group_free" => $storage_group_free." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}).")", |
|
}}); |
|
} |
|
elsif ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} eq "delete") |
|
{ |
|
my $old_size = $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}; |
|
$storage_group_used -= $old_size; |
|
$storage_group_free += $old_size; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:old_size" => $old_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $old_size}).")", |
|
"s2:storage_group_used" => $storage_group_used." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_used}).")", |
|
"s3:storage_group_free" => $storage_group_free." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free}).")", |
|
}}); |
|
} |
|
} |
|
} |
|
|
|
my $say_new_max_size = $say_max_size; |
|
my $new_max_assignable = $max_assignable; |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} =~ /grow:(\d+)$/) |
|
{ |
|
# Add the space assigned to the max size |
|
my $added = $1; |
|
$max_assignable = ($size + $storage_group_free + $added); |
|
$say_max_size = $anvil->Convert->bytes_to_human_readable({'bytes' => $max_assignable}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"s1:added" => $added." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $added}).")", |
|
"s2:max_assignable" => $say_size, |
|
"s3:say_max_size" => $say_max_size, |
|
}}); |
|
} |
|
|
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
|
|
my $say_requested = ""; |
|
my $say_delete = ""; |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}) |
|
{ |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} =~ /grow:(\d+)$/) |
|
{ |
|
$say_requested = $anvil->Convert->bytes_to_human_readable({'bytes' => $1}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { say_requested => $say_requested }}); |
|
} |
|
} |
|
my $changes = $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} ? "*" : " "; |
|
print "* Manage: [".$target."], boot order: [".$boot_order."], backed by: [".$path."], Size: [".$say_size."]\n"; |
|
print " - In storage Group: [".$storage_group_name."], Size: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_size})."], Free space: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $storage_group_free})."].\n"; |
|
print "[ G ] - Grow (Current size: [".$say_size."], Requested: [".$say_requested."], Max: [".$say_max_size."]".$changes."\n"; |
|
if ($boot_order == 1) |
|
{ |
|
print "[ - ] - <Cannot delete the boot disk>.\n"; |
|
} |
|
else |
|
{ |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} eq "delete") |
|
{ |
|
print "[ D ] - Abort Deletion (Currently scheduled for deletion!)\n"; |
|
} |
|
else |
|
{ |
|
print "[ D ] - Delete\n"; |
|
} |
|
} |
|
|
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}) |
|
{ |
|
print "- Changes can be committed on the main page.\n"; |
|
print $terminal->Tgoto('cm', 0, 9)."? "; |
|
} |
|
else |
|
{ |
|
print $terminal->Tgoto('cm', 0, 8)."? "; |
|
} |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
if (lc($answer) eq "g") |
|
{ |
|
my $say_new_max_size = $say_max_size; |
|
my $new_max_assignable = $max_assignable; |
|
# Ask what size they want. |
|
print "- How big do you want the drive to be? You can enter up to: [".$say_max_size."];\n"; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$answer =~ s/^\s+//; |
|
$answer =~ s/\s+$//; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
if (not $answer) |
|
{ |
|
# Go back |
|
interactive_configure_storage_group_manage_drive($anvil, $terminal, $selected_sg, $target); |
|
} |
|
else |
|
{ |
|
# Convert to bytes |
|
my $requested_bytes = $answer; |
|
if ($requested_bytes =~ /\D/) |
|
{ |
|
$requested_bytes = $anvil->Convert->human_readable_to_bytes({ |
|
base2 => 1, |
|
size => $requested_bytes, |
|
}); |
|
if ($requested_bytes eq "!!error!!") |
|
{ |
|
# Problem. |
|
$requested_bytes = ""; |
|
print "[ Error ] - The answer: [".$answer."] could not be interpretted as a size.\n"; |
|
hold_for_input($anvil); |
|
} |
|
} |
|
|
|
if (($requested_bytes =~ /^\d+$/) && ($requested_bytes > $max_assignable)) |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} = ""; |
|
print "[ Error ] - You asked for: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $requested_bytes})."] (".$anvil->Convert->add_commas({number => $requested_bytes})." bytes), but the max available is: [".$say_max_size."] (".$anvil->Convert->add_commas({number => $max_assignable})." bytes).\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_storage_group_manage_drive($anvil, $terminal, $selected_sg, $target); |
|
} |
|
elsif ($requested_bytes) |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} = "grow:".$requested_bytes; |
|
$anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size} = $size; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::target::${target}::changes" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}, |
|
"old_config::storage_group_data::${storage_group_name}::target::${target}::size" => $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}, |
|
}}); |
|
} |
|
} |
|
} |
|
if (lc($answer) eq "d") |
|
{ |
|
if ($anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} eq "delete") |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::target::${target}::changes" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}, |
|
}}); |
|
} |
|
else |
|
{ |
|
$anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes} = "delete"; |
|
$anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size} = $size; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::storage_group_data::${storage_group_name}::target::${target}::changes" => $anvil->data->{new_config}{storage_group_data}{$storage_group_name}{target}{$target}{changes}, |
|
"old_config::storage_group_data::${storage_group_name}::target::${target}::size" => $anvil->data->{old_config}{storage_group_data}{$storage_group_name}{target}{$target}{size}, |
|
}}); |
|
} |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
interactive_configure_storage_group($anvil, $terminal, $selected_sg); |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub hold_for_input |
|
{ |
|
my ($anvil) = @_; |
|
|
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
|
|
return(0); |
|
} |
|
|
|
sub check_answer |
|
{ |
|
my ($anvil, $answer) = @_; |
|
|
|
if (lc($answer) eq "q") |
|
{ |
|
print "NO CARRIER, good bye.\n"; |
|
$anvil->nice_exit({exit_code => 0}); |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_configure_ram |
|
{ |
|
my ($anvil, $terminal) = @_; |
|
|
|
while(1) |
|
{ |
|
# Threads will be the maximum, even without hyperthreading being available. |
|
my $anvil_uuid = $anvil->data->{target_server}{anvil_uuid}; |
|
my $say_current_ram = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{target_server}{configured_ram}}); |
|
my $say_total_ram = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{anvil_resources}{$anvil_uuid}{ram}{hardware}}); |
|
my $say_available_ram = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{anvil_resources}{$anvil_uuid}{ram}{available}}); |
|
my $max_assignable = $anvil->data->{anvil_resources}{$anvil_uuid}{ram}{available} + $anvil->data->{target_server}{configured_ram}; |
|
my $say_max_assignable = $anvil->Convert->bytes_to_human_readable({'bytes' => $max_assignable}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
anvil_uuid => $anvil_uuid, |
|
say_current_ram => $say_current_ram, |
|
say_total_ram => $say_total_ram, |
|
say_available_ram => $say_available_ram, |
|
say_max_assignable => $say_max_assignable, |
|
}}); |
|
|
|
my $changes = 0; |
|
my $say_new_ram = 0; |
|
if ($anvil->data->{new_config}{ram}{'bytes'}) |
|
{ |
|
$say_new_ram = $anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{new_config}{ram}{'bytes'}}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { say_new_ram => $say_new_ram }}); |
|
} |
|
|
|
my $ram_star = " "; |
|
if (($anvil->data->{new_config}{ram}{'bytes'}) && ($anvil->data->{new_config}{ram}{'bytes'} ne $anvil->data->{target_server}{server_ram_bytes})) |
|
{ |
|
$ram_star = "*"; |
|
$changes = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
ram_star => $ram_star, |
|
changes => $changes, |
|
}}); |
|
$anvil->data->{old_config}{ram}{'bytes'} = $anvil->data->{target_server}{configured_ram}; |
|
} |
|
|
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
print "* RAM configuration. Currently allocated: [".$say_current_ram."], Maximum RAM: [".$say_max_assignable."] (current + free).\n"; |
|
print "[ 1 ] - RAM".$ram_star." (currently: [".$say_current_ram."], new: [".$say_new_ram."])\n"; |
|
|
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
if ($changes) |
|
{ |
|
print "- Changes can be committed on the main page.\n"; |
|
print $terminal->Tgoto('cm', 0, 7)."? "; |
|
} |
|
else |
|
{ |
|
print $terminal->Tgoto('cm', 0, 6)."? "; |
|
} |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
|
|
if ($answer eq "1") |
|
{ |
|
print "- Can specify in bytes or base2 human readible (ie: '4 GiB', '4G', etc)\n"; |
|
print "How much RAM would you like? "; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$answer =~ s/^\s+//; |
|
$answer =~ s/\s+$//; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
if (not $answer) |
|
{ |
|
# Go back |
|
interactive_configure_ram($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
# Convert to bytes |
|
my $requested_bytes = $answer; |
|
if ($requested_bytes =~ /\D/) |
|
{ |
|
$requested_bytes = $anvil->Convert->human_readable_to_bytes({ |
|
base2 => 1, |
|
size => $requested_bytes, |
|
}); |
|
if ($requested_bytes eq "!!error!!") |
|
{ |
|
# Problem. |
|
print "[ Error ] - The answer: [".$answer."] could not be interpretted.\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_ram($anvil, $terminal); |
|
} |
|
} |
|
elsif (not $requested_bytes) |
|
{ |
|
interactive_configure_ram($anvil, $terminal); |
|
} |
|
|
|
if (($requested_bytes =~ /^\d+$/) && ($requested_bytes > $max_assignable)) |
|
{ |
|
$anvil->data->{new_config}{ram}{'bytes'} = 0; |
|
print "[ Error ] - You asked for: [".$anvil->Convert->bytes_to_human_readable({'bytes' => $requested_bytes})."] (".$anvil->Convert->add_commas({number => $max_assignable})." bytes) RAM, but the max available is: [".$say_max_assignable."] (".$anvil->Convert->add_commas({number => $max_assignable})." bytes).\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_ram($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
$anvil->data->{new_config}{ram}{'bytes'} = $requested_bytes; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::ram::bytes" => $anvil->data->{new_config}{ram}{'bytes'}, |
|
}}); |
|
} |
|
} |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
interactive_configure_main($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
interactive_configure_ram($anvil, $terminal); |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_configure_cpu |
|
{ |
|
my ($anvil, $terminal) = @_; |
|
|
|
while(1) |
|
{ |
|
# Threads will be the maximum, even without hyperthreading being available. |
|
my $anvil_uuid = $anvil->data->{target_server}{anvil_uuid}; |
|
my $maximum_cores = $anvil->data->{anvil_resources}{$anvil_uuid}{cpu}{threads}; |
|
my $current_cores = $anvil->data->{target_server}{server_cpu_cores}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
anvil_uuid => $anvil_uuid, |
|
maximum_cores => $maximum_cores, |
|
current_cores => $current_cores, |
|
}}); |
|
|
|
my $changes = 0; |
|
my $star_cores = " "; |
|
if (($anvil->data->{new_config}{cpu}{cores}) && ($anvil->data->{new_config}{cpu}{cores} ne $anvil->data->{target_server}{server_cpu_cores})) |
|
{ |
|
$star_cores = "*"; |
|
$changes = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
star_cores => $star_cores, |
|
changes => $changes, |
|
}}); |
|
$anvil->data->{old_config}{cpu}{cores} = $anvil->data->{target_server}{server_cpu_cores}; |
|
} |
|
my $star_sockets = " "; |
|
if (($anvil->data->{new_config}{cpu}{sockets}) && ($anvil->data->{new_config}{cpu}{sockets} ne $anvil->data->{target_server}{server_cpu_sockets})) |
|
{ |
|
$star_sockets = "*"; |
|
$changes = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
star_sockets => $star_sockets, |
|
changes => $changes, |
|
}}); |
|
$anvil->data->{old_config}{cpu}{sockets} = $anvil->data->{target_server}{server_cpu_sockets}; |
|
} |
|
|
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "job_0355", variables => { |
|
anvil_name => $anvil->data->{target_server}{anvil_name}, |
|
server_name => $anvil->data->{target_server}{server_name}, |
|
}})."\n"; |
|
print "* CPU configuration. Maximum cores X sockets is: [".$maximum_cores."]\n"; |
|
print "[ 1 ] - Cores per socket".$star_cores." (currently: [".$anvil->data->{target_server}{server_cpu_cores}."], new: [".$anvil->data->{new_config}{cpu}{cores}."])\n"; |
|
print "[ 2 ] - Sockets".$star_sockets." (currently: [".$anvil->data->{target_server}{server_cpu_sockets}."], new: [".$anvil->data->{new_config}{cpu}{sockets}."])\n"; |
|
|
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
if ($changes) |
|
{ |
|
print "- Changes can be committed on the main page.\n"; |
|
print $terminal->Tgoto('cm', 0, 8)."? "; |
|
} |
|
else |
|
{ |
|
print $terminal->Tgoto('cm', 0, 7)."? "; |
|
} |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
|
|
if ($answer eq "1") |
|
{ |
|
print "How many cores per socket would you like? "; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
if (not $answer) |
|
{ |
|
# Go back |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
elsif ($answer =~ /\D/) |
|
{ |
|
print "[ Error ] - The answer: [".$answer."] is not valid. You need to specify a digit.\n"; |
|
print "Press any key to continue.\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
# Did they ask for too many? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::cpu::sockets" => $anvil->data->{new_config}{cpu}{sockets}, |
|
"target_server::server_cpu_sockets" => $anvil->data->{target_server}{server_cpu_sockets}, |
|
maximum_cores => $maximum_cores, |
|
}}); |
|
if (($anvil->data->{new_config}{cpu}{sockets}) && (($answer * $anvil->data->{new_config}{cpu}{sockets}) > $maximum_cores)) |
|
{ |
|
print "[ Error ] - With the current socket count of: [".$anvil->data->{new_config}{cpu}{sockets}."], the requested number of cores: [".$answer."] would result in: [".($answer * $anvil->data->{new_config}{cpu}{sockets})."] total cores.\n"; |
|
print " The maximum available on this Anvil! is: [".$maximum_cores."].\n"; |
|
if ($anvil->data->{new_config}{cpu}{sockets} > 1) |
|
{ |
|
print " You may wish to reduce the socket count first.\n"; |
|
} |
|
print __LINE__."; Press any key to continue.\n"; |
|
my $answer = <STDIN>; |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
elsif ((not $anvil->data->{new_config}{cpu}{sockets}) && (($answer * $anvil->data->{target_server}{server_cpu_sockets}) > $maximum_cores)) |
|
{ |
|
print "[ Error ] - With the current socket count of: [".$anvil->data->{target_server}{server_cpu_sockets}."], the requested number of cores: [".$answer."] would result in: [".($answer * $anvil->data->{target_server}{server_cpu_sockets})."] total cores.\n"; |
|
print " The maximum available on this Anvil! is: [".$maximum_cores."].\n"; |
|
if ($anvil->data->{target_server}{server_cpu_sockets} > 1) |
|
{ |
|
print " You may wish to reduce the socket count first.\n"; |
|
} |
|
print __LINE__."; Press any key to continue.\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
$anvil->data->{new_config}{cpu}{cores} = $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::cpu::cores" => $anvil->data->{new_config}{cpu}{cores}, |
|
}}); |
|
} |
|
} |
|
} |
|
elsif ($answer eq "2") |
|
{ |
|
print "How many sockets would you like? "; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
if (not $answer) |
|
{ |
|
# Go back |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
elsif ($answer =~ /\D/) |
|
{ |
|
print "[ Error ] - The answer: [".$answer."] is not valid. You need to specify a digit.\n"; |
|
print "Press any key to continue.\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
# Did they ask for too many? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::cpu::cores" => $anvil->data->{new_config}{cpu}{cores}, |
|
"target_server::server_cpu_cores" => $anvil->data->{target_server}{server_cpu_cores}, |
|
maximum_cores => $maximum_cores, |
|
}}); |
|
if (($anvil->data->{new_config}{cpu}{cores}) && (($answer * $anvil->data->{new_config}{cpu}{cores}) > $maximum_cores)) |
|
{ |
|
print "[ Error ] - With the current core count of: [".$anvil->data->{new_config}{cpu}{cores}."], the requested number of sockets: [".$answer."] would result in: [".($answer * $anvil->data->{new_config}{cpu}{cores})."] total cores.\n"; |
|
print " The maximum available on this Anvil! is: [".$maximum_cores."].\n"; |
|
if ($anvil->data->{new_config}{cpu}{cores} > 1) |
|
{ |
|
print " You may wish to reduce the core count first.\n"; |
|
} |
|
print __LINE__."; Press any key to continue.\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
elsif ((not $anvil->data->{new_config}{cpu}{cores}) && (($answer * $anvil->data->{target_server}{server_cpu_cores}) > $maximum_cores)) |
|
{ |
|
print "[ Error ] - With the current core count of: [".$anvil->data->{target_server}{server_cpu_cores}."], the requested number of sockets: [".$answer."] would result in: [".($answer * $anvil->data->{target_server}{server_cpu_cores})."] total cores.\n"; |
|
print " The maximum available on this Anvil! is: [".$maximum_cores."].\n"; |
|
if ($anvil->data->{target_server}{server_cpu_sockets} > 1) |
|
{ |
|
print " You may wish to reduce the core count first.\n"; |
|
} |
|
print __LINE__."; Press any key to continue.\n"; |
|
hold_for_input($anvil); |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
$anvil->data->{new_config}{cpu}{sockets} = $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_config::cpu::sockets" => $anvil->data->{new_config}{cpu}{sockets}, |
|
}}); |
|
} |
|
} |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
interactive_configure_main($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
interactive_configure_cpu($anvil, $terminal); |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_ask_anvil_name |
|
{ |
|
my ($anvil, $terminal) = @_; |
|
|
|
my $retry = 0; |
|
while(1) |
|
{ |
|
my $default = ""; |
|
if ($anvil->data->{target_server}{anvil_name}) |
|
{ |
|
$default = $anvil->data->{target_server}{anvil_name}; |
|
} |
|
print $terminal->Tputs('cl'); |
|
print $anvil->Words->string({key => "message_0257"})."\n"; |
|
|
|
my $anvil_selection = []; |
|
push @{$anvil_selection}, "NULL"; |
|
|
|
my $anvil_count = 0; |
|
my $longest_anvil_name = 0; |
|
foreach my $anvil_name (sort {$a cmp $b} keys %{$anvil->data->{anvils}{anvil_name}}) |
|
{ |
|
my $anvil_uuid = $anvil->data->{anvils}{anvil_name}{$anvil_name}{anvil_uuid}; |
|
my $anvil_description = $anvil->data->{anvils}{anvil_name}{$anvil_name}{anvil_description}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
anvil_name => $anvil_name, |
|
anvil_uuid => $anvil_uuid, |
|
anvil_description => $anvil_description, |
|
}}); |
|
next if $anvil_description eq "DELETED"; |
|
|
|
$anvil_count++; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { anvil_count => $anvil_count }}); |
|
push @{$anvil_selection}, $anvil_name; |
|
|
|
if (length($anvil_name) > $longest_anvil_name) |
|
{ |
|
$longest_anvil_name = length($anvil_name); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { longest_anvil_name => $longest_anvil_name }}); |
|
} |
|
} |
|
|
|
my $number_length = length($anvil_count + 1); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { number_length => $number_length }}); |
|
for (my $i = 1; $i < @{$anvil_selection}; $i++) |
|
{ |
|
my $anvil_name = $anvil_selection->[$i]; |
|
next if $anvil_name eq "NULL"; |
|
my $anvil_uuid = $anvil->data->{anvils}{anvil_name}{$anvil_name}{anvil_uuid}; |
|
my $anvil_description = $anvil->data->{anvils}{anvil_name}{$anvil_name}{anvil_description}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
i => $i, |
|
anvil_name => $anvil_name, |
|
anvil_uuid => $anvil_uuid, |
|
anvil_description => $anvil_description, |
|
}}); |
|
|
|
print $anvil->Words->string({key => "message_0258", variables => { |
|
number => sprintf("%-${number_length}s", $i), |
|
anvil_name => sprintf("%-${longest_anvil_name}s", $anvil_name), |
|
anvil_description => $anvil_description, |
|
}})."\n"; |
|
} |
|
print "\n"; |
|
print "[ Q ] - Quit\n"; |
|
print "\n"; |
|
|
|
my $column = 3 + $anvil_count; |
|
print $terminal->Tgoto('cm', 0, $column)."? "; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
|
|
if ((not $answer) && ($default)) |
|
{ |
|
$answer = $default; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
} |
|
|
|
# Reload in case a new anvil! was saved while we waited. |
|
$anvil->Database->get_anvils(); |
|
if (($answer =~ /^\d+$/) && (exists $anvil_selection->[$answer]) && (not exists $anvil->data->{anvils}{anvil_name}{$answer})) |
|
{ |
|
$answer = $anvil_selection->[$answer]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
|
|
$anvil->data->{target_server}{anvil_name} = $answer; |
|
$anvil->data->{target_server}{anvil_uuid} = $anvil->Cluster->get_anvil_uuid({anvil_name => $answer}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_name" => $anvil->data->{target_server}{anvil_name}, |
|
"target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid}, |
|
}}); |
|
last; |
|
} |
|
elsif ((exists $anvil->data->{anvils}{anvil_name}{$answer}) && (ref($anvil->data->{anvils}{anvil_name}{$answer}) eq "HASH")) |
|
{ |
|
# Valid. |
|
$anvil->data->{target_server}{anvil_name} = $answer; |
|
$anvil->data->{target_server}{anvil_uuid} = $anvil->Cluster->get_anvil_uuid({anvil_name => $answer}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::anvil_name" => $anvil->data->{target_server}{anvil_name}, |
|
"target_server::anvil_uuid" => $anvil->data->{target_server}{anvil_uuid}, |
|
}}); |
|
last; |
|
} |
|
else |
|
{ |
|
$retry = 1; |
|
} |
|
} |
|
|
|
interactive_question($anvil); |
|
|
|
return(0); |
|
} |
|
|
|
sub interactive_ask_server_name |
|
{ |
|
my ($anvil, $terminal) = @_; |
|
|
|
$anvil->Database->get_servers({debug => 2}); |
|
|
|
### TODO: Figure out how many rows we have and break the server list into columns if too long. |
|
### tput cols |
|
### tput rows |
|
my $retry = 0; |
|
my $not_found = ""; |
|
while(1) |
|
{ |
|
my $default = ""; |
|
if ($anvil->data->{target_server}{server_name}) |
|
{ |
|
$default = $anvil->data->{target_server}{server_name}; |
|
} |
|
print $terminal->Tputs('cl'); |
|
|
|
# Show all the current server names. |
|
if ($retry) |
|
{ |
|
print $anvil->Words->string({key => "job_0353"})."\n\n"; |
|
} |
|
my $anvil_uuid = $anvil->data->{target_server}{anvil_uuid}; |
|
print $anvil->Words->string({key => "job_0354", variables => { anvil_name => $anvil->data->{target_server}{anvil_name} }})."\n"; |
|
|
|
# Push the server names into an array, with '0' being null so the list we show the user |
|
# starts at '1'. |
|
my $server_selection = []; |
|
push @{$server_selection}, "NULL"; |
|
|
|
my $server_count = 0; |
|
my $longest_server_name = 0; |
|
foreach my $server_name (sort {$a cmp $b} keys %{$anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}}) |
|
{ |
|
my $server_uuid = $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$server_name}{server_uuid}; |
|
my $server_state = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_state}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
server_name => $server_name, |
|
server_uuid => $server_uuid, |
|
server_state => $server_state, |
|
}}); |
|
next if $server_state eq "DELETED"; |
|
|
|
$server_count++; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { server_count => $server_count }}); |
|
push @{$server_selection}, $server_name; |
|
|
|
if (length($server_name) > $longest_server_name) |
|
{ |
|
$longest_server_name = length($server_name); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { longest_server_name => $longest_server_name }}); |
|
} |
|
} |
|
|
|
my $number_length = length($server_count + 1); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { number_length => $number_length }}); |
|
for (my $i = 1; $i < @{$server_selection}; $i++) |
|
{ |
|
my $server_name = $server_selection->[$i]; |
|
next if $server_name eq "NULL"; |
|
my $server_uuid = $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$server_name}{server_uuid}; |
|
my $server_state = $anvil->data->{servers}{server_uuid}{$server_uuid}{server_state}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
server_name => $server_name, |
|
server_uuid => $server_uuid, |
|
server_state => $server_state, |
|
}}); |
|
|
|
print $anvil->Words->string({key => "message_0256", variables => { |
|
number => sprintf("%-${number_length}s", $i), |
|
server_name => sprintf("%-${longest_server_name}s", $server_name), |
|
server_state => $server_state, |
|
}})."\n"; |
|
} |
|
print "\n"; |
|
print "[ B ] - Back\n"; |
|
print "[ Q ] - Quit\n"; |
|
print "\n"; |
|
|
|
my $column = 4 + $server_count; |
|
print $terminal->Tgoto('cm', 0, $column)."? "; |
|
my $answer = <STDIN>; |
|
chomp $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
check_answer($anvil, $answer); |
|
|
|
if ((not $answer) && ($default)) |
|
{ |
|
$answer = $default; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
} |
|
|
|
# Reload in case a new anvil! was saved while we waited. |
|
$anvil->Database->get_servers(); |
|
if ($answer) |
|
{ |
|
# Found? |
|
if (($answer =~ /^\d+$/) && (exists $server_selection->[$answer]) && (not exists $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$answer})) |
|
{ |
|
$answer = $server_selection->[$answer]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { answer => $answer }}); |
|
} |
|
if ((exists $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$answer}) && (ref($anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$answer}) eq "HASH")) |
|
{ |
|
# Valid |
|
$anvil->data->{target_server}{server_name} = $answer; |
|
$anvil->data->{target_server}{server_uuid} = $anvil->data->{servers}{anvil_uuid}{$anvil_uuid}{server_name}{$answer}{server_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"target_server::server_name" => $anvil->data->{target_server}{server_name}, |
|
"target_server::server_uuid" => $anvil->data->{target_server}{server_uuid}, |
|
}}); |
|
last; |
|
} |
|
elsif (lc($answer) eq "b") |
|
{ |
|
$anvil->data->{target_server}{anvil_name} = ""; |
|
$anvil->data->{target_server}{anvil_uuid} = ""; |
|
$anvil->data->{switches}{anvil} = ""; |
|
$anvil->data->{switches}{'anvil-name'} = ""; |
|
$anvil->data->{switches}{'anvil-uuid'} = ""; |
|
print "Going back\n"; |
|
interactive_ask_anvil_name($anvil, $terminal); |
|
} |
|
else |
|
{ |
|
# Inalid. |
|
$not_found = $answer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { not_found => $not_found }}); |
|
} |
|
last; |
|
} |
|
else |
|
{ |
|
$retry = 1; |
|
} |
|
} |
|
interactive_question($anvil); |
|
|
|
return(0); |
|
} |
|
|
|
sub show_stats |
|
{ |
|
my ($anvil) = @_; |
|
|
|
# Load the server's details. |
|
my $server_xml = $anvil->Server->get_definition({server_uuid => $anvil->data->{sys}{server_uuid}}); |
|
my $server_name = $anvil->data->{sys}{server_name}; |
|
my $short_host_name = $anvil->Get->short_host_name(); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
's1:short_host_name' => $short_host_name, |
|
's2:server_name' => $server_name, |
|
's3:server_xml' => $server_xml, |
|
}}); |
|
|
|
$anvil->Server->parse_definition({ |
|
debug => 2, |
|
source => "from_db", |
|
definition => $server_xml, |
|
server => $server_name, |
|
}); |
|
|
|
my $cpu_cores = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{cpu}{total_cores}; |
|
my $ram_bytes = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{memory}; |
|
my $say_ram = $anvil->Convert->bytes_to_human_readable({'bytes' => $ram_bytes}); |
|
print "Cores: [".$cpu_cores."], RAM: [".$say_ram."] (".$ram_bytes." bytes)\n"; |
|
|
|
# Show disks |
|
foreach my $device ("disk", "cdrom") |
|
{ |
|
print "- Device: [".$device."]\n"; |
|
foreach my $device_target (sort {$a cmp $b} keys %{$anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{$device}{target}}) |
|
{ |
|
my $boot_order = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{$device}{target}{$device_target}{boot_order}; |
|
my $type = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{$device}{target}{$device_target}{type}; |
|
my $device_bus = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{$device}{target}{$device_target}{device_bus}; |
|
my $path = $anvil->data->{server}{$short_host_name}{$server_name}{from_db}{device}{$device}{target}{$device_target}{path}; |
|
print " - Target: [".$device_target."], type: [".$type."], boot order: [".$boot_order."], bus: [".$device_bus."]\n"; |
|
print " - Path: [".$path."]\n"; |
|
if ($device eq "disk") |
|
{ |
|
# Pull the size |
|
my $volume = ($path =~ /\/(\d+)$/)[0]; |
|
print " - Volume: [".$volume."]\n"; |
|
foreach my $host_name (sort {$a cmp $b} keys %{$anvil->data->{new}{resource}{$server_name}{host}}) |
|
{ |
|
my $host_uuid = $anvil->Get->host_uuid_from_name({host_name => $host_name}); |
|
my $device_path = $anvil->data->{new}{resource}{$server_name}{host}{$host_name}{volume}{$volume}{device_path}; |
|
my $backing_disk = $anvil->data->{new}{resource}{$server_name}{host}{$host_name}{volume}{$volume}{backing_disk}; |
|
print " - Host: [".$host_name."] (".$host_uuid."), path: [".$device_path."], backing disk: [".$backing_disk."]\n"; |
|
} |
|
} |
|
else |
|
{ |
|
} |
|
} |
|
} |
|
|
|
return(0); |
|
}
|
|
|