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.
5240 lines
294 KiB
5240 lines
294 KiB
#!/usr/bin/perl |
|
# |
|
# This software was created by Alteeve's Niche! Inc. and has been released |
|
# under the terms of the GNU GPL version 2. |
|
# |
|
# ScanCore Scan Agent for HPE type RAID controllers using the 'hpacucli' command line tool. |
|
# |
|
# https://alteeve.com |
|
# |
|
# Exit Codes: |
|
# 0 - Success |
|
# 1 - hpacucli not installed |
|
# 2 - hpacucli is installed but it is not executable. |
|
# 3 - No HPE type controllers found. |
|
# 4 - Controller numeric value is invalid. |
|
# 5 - Cache module numeric value is invalid. |
|
# 6 - Array numeric value is invalid. |
|
# 7 - Logical drive numeric value is invalid. |
|
# 8 - Physical drive numeric value is invalid. |
|
# 9 - Physical drive has no serial number. |
|
# |
|
# 255 - The host's UUID isn't in the hosts table yet, ScanCore itself hasn't been run. |
|
# |
|
# TODO: |
|
# - |
|
# |
|
# NOTE: |
|
# - Health values |
|
# - Controller - Correctable errors = 1 |
|
# - Controller - Uncorrectable errors = 5 |
|
# - Controller - Status changes = 5 |
|
# - Drive group - partially degraded = 5 |
|
# - Drive group - degraded = 10 |
|
# - Cachevault - Replacement needed = 5 |
|
# - BBU - Replacement needed = 5 |
|
# - Temperature - Critical = 2 |
|
# - Temperature - Warning = 1 |
|
|
|
# Use my modules. |
|
use strict; |
|
use warnings; |
|
use Anvil::Tools; |
|
use Data::Dumper; |
|
use Math::BigInt; |
|
no warnings 'recursion'; |
|
|
|
# Disable buffering |
|
$| = 1; |
|
|
|
# Prevent a discrepency between UID/GID and EUID/EGID from throwing an error. |
|
$< = $>; |
|
$( = $); |
|
|
|
my $THIS_FILE = ($0 =~ /^.*\/(.*)$/)[0]; |
|
my $running_directory = ($0 =~ /^(.*?)\/$THIS_FILE$/)[0]; |
|
if (($running_directory =~ /^\./) && ($ENV{PWD})) |
|
{ |
|
$running_directory =~ s/^\./$ENV{PWD}/; |
|
} |
|
|
|
my $anvil = Anvil::Tools->new(); |
|
|
|
# Make sure we're running as 'root' |
|
# $< == real UID, $> == effective UID |
|
if (($< != 0) && ($> != 0)) |
|
{ |
|
# Not root |
|
print $anvil->Words->string({key => "error_0005"})."\n"; |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
|
|
# Here we store data and variables for this agent. |
|
$anvil->data->{'scan-hpacucli'} = { |
|
health => { |
|
old => {}, |
|
new => {}, |
|
}, |
|
|
|
# This will keep track of devices with serial numbers so that it is easy to look up |
|
# the UUID from the serial numbers and vice versa. |
|
controllers => { |
|
by_serial => {}, |
|
by_uuid => {}, |
|
}, |
|
physical_drives => { |
|
by_serial => {}, |
|
by_uuid => {}, |
|
}, |
|
# Checking the drives for errors is expensive, so it is only done every hour (or |
|
# there abouts). Change the interval if you want to check more or less often. |
|
diagnostics_interval => 1800, |
|
disable => 0, |
|
ignore_maximum_temperature => 0, |
|
language => "en_CA", |
|
log_level => 1, |
|
log_language => "en_CA", |
|
log_file => "/var/log/ScanCore.log", |
|
log_db_transactions => 0, |
|
thresholds => { |
|
# This is used for unknown sensors and really shouldn't be used at all. |
|
'default' => { |
|
high_warning => 50, |
|
high_critical => 55, |
|
low_warning => 15, |
|
low_critical => 10, |
|
jump => 5, |
|
buffer => 3, |
|
}, |
|
drives => { |
|
# http://storage.toshiba.com/docs/product-datasheets/mk01grrb-r.pdf |
|
# http://toshiba.semicon-storage.com/us/product/storage-products/enterprise-ssd/px02smb-px02smfxxx.html |
|
high_warning => 50, |
|
high_critical => 55, |
|
low_warning => 5, |
|
low_critical => 0, |
|
jump => 5, |
|
buffer => 2, |
|
}, |
|
# I've not found official ranges on this yet... These are best-guess values |
|
controller_temperature => { |
|
high_warning => 100, |
|
high_critical => 105, |
|
low_warning => 15, |
|
low_critical => 10, |
|
jump => 10, |
|
buffer => 5, |
|
}, |
|
# I've not found official ranges on this yet... These are best-guess values |
|
capacitor => { |
|
high_warning => 50, |
|
high_critical => 55, |
|
low_warning => 15, |
|
low_critical => 10, |
|
jump => 5, |
|
buffer => 3, |
|
}, |
|
# https://support.hpe.com/hpsc/doc/public/display?docId=c04441382 |
|
cache => { |
|
high_warning => 50, |
|
high_critical => 55, |
|
low_warning => 15, |
|
low_critical => 10, |
|
jump => 5, |
|
buffer => 3, |
|
}, |
|
}, |
|
sys => { |
|
alert_sort => 2, |
|
controller => {}, |
|
controller_count => 0, |
|
# When a lock is requested, this is set to the time the lock was set. |
|
# DB->do_db_write() and DB->do_db_read() will check this and if its age is >50% of |
|
# scancore::locking::reap_age, it will renew the lock. |
|
lock_active => 0, |
|
process_diagnostics => 0, |
|
}, |
|
queries => [], |
|
}; |
|
|
|
$anvil->Storage->read_config(); |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, 'print' => 1, key => "log_0115", variables => { program => $THIS_FILE }}); |
|
|
|
# Read switches |
|
$anvil->data->{switches}{force} = 0; |
|
$anvil->data->{switches}{purge} = 0; |
|
$anvil->Get->switches; |
|
|
|
# Handle start-up tasks |
|
my $problem = $anvil->ScanCore->agent_startup({agent => $THIS_FILE}); |
|
if ($problem) |
|
{ |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
|
|
if ($anvil->data->{switches}{purge}) |
|
{ |
|
# This can be called when doing bulk-database purges. |
|
my $schema_file = $anvil->data->{path}{directories}{scan_agents}."/".$THIS_FILE."/".$THIS_FILE.".sql"; |
|
$anvil->Database->purge_data({ |
|
debug => 2, |
|
tables => $anvil->Database->get_tables_from_schema({schema_file => $schema_file}), |
|
}); |
|
$anvil->nice_exit({exit_code => 0}); |
|
} |
|
|
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 2, key => "scan_hpacucli_message_0001"}); |
|
|
|
# This does two things; It checks to see if hpacucli is installed (exits '1' if not, exits '2' if not |
|
# executable) and then checks to see if any controllers are found in the system (exits '3' if not). |
|
find_hp_controllers($anvil); |
|
|
|
# If we're still alive, start gathering data. |
|
gather_data($anvil); |
|
|
|
# Figure out, other than temperatures, what should be added to or removed from health. |
|
pre_process_health($anvil); |
|
|
|
# Look for changes. |
|
find_changes($anvil); |
|
|
|
# Process temperatures! This also sets health values for warning and critical temperatures so make sure we |
|
# always call this before process_health(). |
|
process_temperatures($anvil); |
|
|
|
# Finally, process health weights. |
|
process_health($anvil); |
|
|
|
# Shut down. |
|
$anvil->ScanCore->agent_shutdown({agent => $THIS_FILE}); |
|
|
|
|
|
############################################################################################################# |
|
# Function below # |
|
############################################################################################################# |
|
|
|
# This reads in the last scan data from one of the databases and compares it against the just-read data. If |
|
# anything changed, register an alert. |
|
sub find_changes |
|
{ |
|
my ($anvil) = @_; |
|
|
|
# Read in the old data. As we compare and UPDATE if needed, then we'll delete. If any are not found, |
|
# then it must be new and will be INSERTed. Any old records left over will have vanished. |
|
read_last_scan($anvil); |
|
|
|
### NOTE: We will loop through each section of data we scanned, deleting records as we process them |
|
### that existed in the DB, and then marking as removed anything left in the databased data not |
|
### seen in this scan. |
|
process_controllers($anvil); |
|
|
|
# Now that controllers have been proceesed, we can process drives (and their arrays) |
|
process_drives($anvil); |
|
|
|
# If we processed diagnostics, update |
|
if ($anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics}) |
|
{ |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_controllers |
|
SET |
|
scan_hpacucli_controller_last_diagnostics = ".time.", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_controller_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
$anvil->Database->write({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
# This reads in all health wieghts previously set, alters ones as needed, INSERTs new ones and DELETEs old |
|
# ones. |
|
sub process_health |
|
{ |
|
my ($anvil) = @_; |
|
|
|
# This will hold our updates. |
|
$anvil->data->{'scan-hpacucli'}{queries} = []; |
|
|
|
# Read in previous health values. |
|
my $query = " |
|
SELECT |
|
health_uuid, |
|
health_agent_name, |
|
health_source_name, |
|
health_source_weight |
|
FROM |
|
health |
|
WHERE |
|
health_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
AND |
|
health_agent_name = ".$anvil->Database->quote($THIS_FILE)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
my $results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
my $count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
foreach my $row (@{$results}) |
|
{ |
|
my $health_uuid = $row->[0]; |
|
my $health_agent_name = $row->[1]; |
|
my $health_source_name = $row->[2]; |
|
my $health_source_weight = $row->[3]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
health_uuid => $health_uuid, |
|
health_agent_name => $health_agent_name, |
|
health_source_name => $health_source_name, |
|
health_source_weight => $health_source_weight, |
|
}}); |
|
|
|
$anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}{uuid} = $health_uuid; |
|
$anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}{value} = $health_source_weight; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::health::old::${health_source_name}::uuid" => $anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}{uuid}, |
|
"scan-hpacucli::health::old::${health_source_name}::value" => $anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}{value}, |
|
}}); |
|
} |
|
|
|
# Read in the new ones |
|
foreach my $health_source_name (sort {$a cmp $b} keys %{$anvil->data->{'scan-hpacucli'}{health}{new}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
|
|
my $health_uuid = ""; |
|
if (exists $anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}) |
|
{ |
|
$health_uuid = $anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}{uuid}; |
|
} |
|
$health_uuid = $anvil->Database->insert_or_update_health({ |
|
debug => 2, |
|
cache => $anvil->data->{'scan-hpacucli'}{queries}, |
|
health_uuid => $health_uuid, |
|
health_host_uuid => $anvil->Get->host_uuid, |
|
health_agent_name => $THIS_FILE, |
|
health_source_name => $health_source_name, |
|
health_source_weight => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { health_uuid => $health_uuid }}); |
|
|
|
if (exists $anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}) |
|
{ |
|
# Delete the new old key, regardless of whether it has changed now. |
|
delete $anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}; |
|
} |
|
} |
|
|
|
# Delete any old entries that are left. |
|
foreach my $health_source_name (sort {$a cmp $b} keys %{$anvil->data->{'scan-hpacucli'}{health}{old}}) |
|
{ |
|
# Well set the source name to 'DELETED'. |
|
my $health_uuid = $anvil->Database->insert_or_update_health({ |
|
debug => 2, |
|
cache => $anvil->data->{'scan-hpacucli'}{queries}, |
|
'delete' => 1, |
|
health_uuid => $anvil->data->{'scan-hpacucli'}{health}{old}{$health_source_name}{uuid}, |
|
}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { health_uuid => $health_uuid }}); |
|
} |
|
|
|
# Now commit the changes. |
|
$anvil->Database->write({query => $anvil->data->{'scan-hpacucli'}{queries}, source => $THIS_FILE, line => __LINE__}); |
|
$anvil->data->{'scan-hpacucli'}{queries} = []; |
|
|
|
return(0); |
|
} |
|
|
|
# This reads in the various temperature sensors we read from this run and will set the temperature table |
|
# and/or set/clear warnings/critical states. |
|
sub process_temperatures |
|
{ |
|
my ($anvil) = @_; |
|
|
|
### NOTE: We use 'sensor_host' to hold the serial number of the device hosting the sensor. |
|
# First, read in all existing entries. We'll compare and UPDATE or INSERT as needed and DELETE any |
|
# stale entries. |
|
my $query = " |
|
SELECT |
|
temperature_uuid, |
|
temperature_sensor_name, |
|
temperature_sensor_host, |
|
temperature_value_c, |
|
temperature_state, |
|
temperature_is |
|
FROM |
|
temperature |
|
WHERE |
|
temperature_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
AND |
|
temperature_agent_name = ".$anvil->Database->quote($THIS_FILE)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
my $results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
|
|
# One or more records were found. |
|
foreach my $row (@{$results}) |
|
{ |
|
my $temperature_sensor_name = $row->[1]; |
|
my $temperature_sensor_host = $row->[2]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_sensor_name => $temperature_sensor_name, |
|
temperature_sensor_host => $temperature_sensor_host, |
|
}}); |
|
|
|
$anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_uuid} = $row->[0]; |
|
$anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_value_c} = $row->[3]; |
|
$anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_state} = $row->[4]; |
|
$anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_is} = $row->[5]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"old::temperature::${temperature_sensor_name}::${temperature_sensor_host}::temperature_uuid" => $anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_uuid}, |
|
"old::temperature::${temperature_sensor_name}::${temperature_sensor_host}::temperature_value_c" => $anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_value_c}, |
|
"old::temperature::${temperature_sensor_name}::${temperature_sensor_host}::temperature_state" => $anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_state}, |
|
"old::temperature::${temperature_sensor_name}::${temperature_sensor_host}::temperature_is" => $anvil->data->{old}{temperature}{$temperature_sensor_name}{$temperature_sensor_host}{temperature_is}, |
|
}}); |
|
} |
|
|
|
# Loop through the temperature from this scan. |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{new}{temperature}}) |
|
{ |
|
foreach my $serial_number (sort {$a cmp $b} keys %{$anvil->data->{new}{temperature}{$variable}}) |
|
{ |
|
my $new_temperature_value_c = $anvil->data->{new}{temperature}{$variable}{$serial_number}{temperature_value_c}; |
|
my $new_temperature_state = $anvil->data->{new}{temperature}{$variable}{$serial_number}{temperature_state}; |
|
my $new_temperature_is = $anvil->data->{new}{temperature}{$variable}{$serial_number}{temperature_is}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
variable => $variable, |
|
serial_number => $serial_number, |
|
new_temperature_value_c => $new_temperature_value_c, |
|
new_temperature_state => $new_temperature_state, |
|
new_temperature_is => $new_temperature_is, |
|
}}); |
|
|
|
# If the state is 'warning', set a health weight of 1 and set critical to 2. |
|
my $health_source_name = "temperature:".$serial_number; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 0; |
|
if ($new_temperature_state eq "warning") |
|
{ |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 1; |
|
} |
|
elsif ($new_temperature_state eq "critical") |
|
{ |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 2; |
|
} |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
|
|
my $temperature_uuid = ""; |
|
if (exists $anvil->data->{old}{temperature}{$variable}{$serial_number}) |
|
{ |
|
$temperature_uuid = $anvil->data->{old}{temperature}{$variable}{$serial_number}{temperature_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { temperature_uuid => $temperature_uuid }}); |
|
delete $anvil->data->{old}{temperature}{$variable}{$serial_number}; |
|
} |
|
$temperature_uuid = $anvil->Database->insert_or_update_temperature({ |
|
cache => $anvil->data->{'scan-hpacucli'}{queries}, |
|
debug => 2, |
|
temperature_uuid => $temperature_uuid, |
|
temperature_host_uuid => $anvil->Get->host_uuid, |
|
temperature_agent_name => $THIS_FILE, |
|
temperature_sensor_host => $serial_number, |
|
temperature_sensor_name => $variable, |
|
temperature_value_c => $new_temperature_value_c, |
|
temperature_state => $new_temperature_state, |
|
temperature_is => $new_temperature_is, |
|
temperature_weight => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { temperature_uuid => $temperature_uuid }}); |
|
} |
|
} |
|
|
|
# Now, if any undeleted old entries remain, delete them from the database. |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{old}{temperature}}) |
|
{ |
|
foreach my $serial_number (sort {$a cmp $b} keys %{$anvil->data->{old}{temperature}{$variable}}) |
|
{ |
|
my $temperature_uuid = $anvil->data->{old}{temperature}{$variable}{$serial_number}{temperature_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"variable" => $variable, |
|
"serial_number" => $serial_number, |
|
"temperature_uuid" => $temperature_uuid, |
|
}}); |
|
|
|
# Mark the sensor as DELETEd. |
|
$anvil->Database->insert_or_update_temperature({ |
|
cache => $anvil->data->{'scan-hpacucli'}{queries}, |
|
debug => 2, |
|
'delete' => 1, |
|
temperature_uuid => $temperature_uuid, |
|
}); |
|
} |
|
} |
|
|
|
# Commit the queries. |
|
$anvil->Database->write({query => $anvil->data->{'scan-hpacucli'}{queries}, source => $THIS_FILE, line => __LINE__}); |
|
$anvil->data->{'scan-hpacucli'}{queries} = []; |
|
|
|
return(0); |
|
} |
|
|
|
# Process drives (and their arrays and logical drives). |
|
sub process_drives |
|
{ |
|
my ($anvil) = @_; |
|
|
|
# Look for new, changed or deleted controllers. |
|
$anvil->data->{'scan-hpacucli'}{queries} = []; |
|
|
|
# This is to collected data from every sweep. |
|
foreach my $scan_hpacucli_controller_serial_number (sort {$a cmp $b} keys %{$anvil->data->{controller}}) |
|
{ |
|
# Controller data; |
|
next if $scan_hpacucli_controller_serial_number eq "metadata"; |
|
my $scan_hpacucli_controller_uuid = $anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
scan_hpacucli_controller_uuid => $scan_hpacucli_controller_uuid, |
|
}}); |
|
|
|
# Array |
|
foreach my $scan_hpacucli_array_name (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}}) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_array_name => $scan_hpacucli_array_name }}); |
|
|
|
# Data, there is no temperature |
|
my $new_scan_hpacucli_array_type = "virtual"; |
|
my $new_scan_hpacucli_array_status = "virtual"; |
|
my $new_scan_hpacucli_array_error_message = ""; |
|
|
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{array_type}) |
|
{ |
|
$new_scan_hpacucli_array_type = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{array_type}; |
|
} |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{status}) |
|
{ |
|
# Array transitions (OK -> Eject -> Plug back in) |
|
#scan-hpacucli 3117; - Data; status: [OK] |
|
#scan-hpacucli 3117; - Data; status: [Failed Physical Drive] |
|
#scan-hpacucli 3148; - Data; status: [OK] |
|
$new_scan_hpacucli_array_status = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{status}; |
|
} |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{error_message}) |
|
{ |
|
$new_scan_hpacucli_array_error_message = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{error_message}; |
|
} |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_array_name => $scan_hpacucli_array_name, |
|
new_scan_hpacucli_array_type => $new_scan_hpacucli_array_type, |
|
new_scan_hpacucli_array_status => $new_scan_hpacucli_array_status, |
|
new_scan_hpacucli_array_error_message => $new_scan_hpacucli_array_error_message, |
|
}}); |
|
|
|
# Does this array exist already? |
|
my $scan_hpacucli_array_uuid = $anvil->data->{'scan-hpacucli'}{virtual_drives}{by_name}{$scan_hpacucli_array_name} ? $anvil->data->{'scan-hpacucli'}{virtual_drives}{by_name}{$scan_hpacucli_array_name} : ""; |
|
if (($scan_hpacucli_array_uuid) && (exists $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid})) |
|
{ |
|
# Look for changes. |
|
my $old_scan_hpacucli_array_controller_uuid = $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_controller_uuid}; |
|
my $old_scan_hpacucli_controller_serial_number = $anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$old_scan_hpacucli_array_controller_uuid}; |
|
my $old_scan_hpacucli_array_type = $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_type}; |
|
my $old_scan_hpacucli_array_status = $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_status}; |
|
my $old_scan_hpacucli_array_error_message = $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_error_message}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
old_scan_hpacucli_array_controller_uuid => $old_scan_hpacucli_array_controller_uuid, |
|
old_scan_hpacucli_controller_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
old_scan_hpacucli_array_type => $old_scan_hpacucli_array_type, |
|
old_scan_hpacucli_array_status => $old_scan_hpacucli_array_status, |
|
old_scan_hpacucli_array_error_message => $old_scan_hpacucli_array_error_message, |
|
}}); |
|
|
|
# Delete the old one so we know we've seen it. |
|
delete $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}; |
|
|
|
# Has anything changed? Note that we don't check the name as that is how we |
|
# find if it exists already or not. |
|
if (($scan_hpacucli_controller_serial_number ne $old_scan_hpacucli_controller_serial_number) or |
|
($new_scan_hpacucli_array_type ne $old_scan_hpacucli_array_type) or |
|
($new_scan_hpacucli_array_status ne $old_scan_hpacucli_array_status) or |
|
($new_scan_hpacucli_array_error_message ne $old_scan_hpacucli_array_error_message)) |
|
{ |
|
### Something changed. |
|
# If the array is not OK, clear alerts. |
|
if ($new_scan_hpacucli_array_status ne $old_scan_hpacucli_array_status) |
|
{ |
|
my $cleared = 0; |
|
my $message_key = "scan_hpacucli_note_0023"; |
|
# Came back or went OK? |
|
if ($old_scan_hpacucli_array_status eq "VANISHED") |
|
{ |
|
$message_key = "scan_hpacucli_note_0032"; |
|
} |
|
elsif (lc($new_scan_hpacucli_array_status) eq "ok") |
|
{ |
|
$cleared = 1; |
|
$message_key = "scan_hpacucli_note_0024"; |
|
} |
|
my $variables = { |
|
name => $scan_hpacucli_array_name, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
new_status => $new_scan_hpacucli_array_status, |
|
old_status => $old_scan_hpacucli_array_status, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => "warning", |
|
message => $message_key, |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# Did the controller change? |
|
if ($scan_hpacucli_controller_serial_number ne $old_scan_hpacucli_controller_serial_number) |
|
{ |
|
# yup. This is a notice as the new controller will have |
|
# generated a warning alert. |
|
my $variables = { |
|
name => $scan_hpacucli_array_name, |
|
new_serial_number => $scan_hpacucli_controller_serial_number, |
|
old_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0025", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0025", |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# Has the error message changed? |
|
if ($new_scan_hpacucli_array_error_message ne $old_scan_hpacucli_array_error_message) |
|
{ |
|
# Default is 'changed' |
|
my $cleared = 0; |
|
my $message_key = "scan_hpacucli_note_0026"; |
|
if (not $new_scan_hpacucli_array_error_message) |
|
{ |
|
# Cleared |
|
$cleared = 0; |
|
$message_key = "scan_hpacucli_note_0027"; |
|
} |
|
elsif (not $old_scan_hpacucli_array_error_message) |
|
{ |
|
# New error |
|
$message_key = "scan_hpacucli_note_0028"; |
|
} |
|
my $variables = { |
|
name => $scan_hpacucli_array_name, |
|
new_error_message => $new_scan_hpacucli_array_error_message, |
|
old_error_message => $old_scan_hpacucli_array_error_message, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => "warning", |
|
message => $message_key, |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# Did the controller change? |
|
if ($new_scan_hpacucli_array_type ne $old_scan_hpacucli_array_type) |
|
{ |
|
# yup. This is a warning because it should never change. |
|
my $variables = { |
|
name => $scan_hpacucli_array_name, |
|
new_type => $new_scan_hpacucli_array_type, |
|
old_type => $old_scan_hpacucli_array_type, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0030", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0030", |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# UPDATE |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_arrays |
|
SET |
|
scan_hpacucli_array_controller_uuid = ".$anvil->Database->quote($scan_hpacucli_controller_uuid).", |
|
scan_hpacucli_array_type = ".$anvil->Database->quote($new_scan_hpacucli_array_type).", |
|
scan_hpacucli_array_status = ".$anvil->Database->quote($new_scan_hpacucli_array_status).", |
|
scan_hpacucli_array_error_message = ".$anvil->Database->quote($new_scan_hpacucli_array_error_message).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_array_uuid = ".$anvil->Database->quote($scan_hpacucli_array_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
else |
|
{ |
|
# New. |
|
$scan_hpacucli_array_uuid = $anvil->Get->uuid(); |
|
$anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number} = $scan_hpacucli_controller_uuid; |
|
$anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$scan_hpacucli_controller_uuid} = $scan_hpacucli_controller_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::controllers::by_serial::${scan_hpacucli_controller_serial_number}" => $anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number}, |
|
"scan-hpacucli::controllers::by_uuid::${scan_hpacucli_controller_uuid}" => $anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$scan_hpacucli_controller_uuid}, |
|
}}); |
|
|
|
print $THIS_FILE." ".__LINE__."; - New Array: [$scan_hpacucli_array_name] (UUID: [$scan_hpacucli_array_uuid]); Type: [$new_scan_hpacucli_array_type], status: [$new_scan_hpacucli_array_status], error message: [$new_scan_hpacucli_array_error_message]\n"; |
|
|
|
# Alert the user if this isn't the virtual array. |
|
if ($scan_hpacucli_array_name ne "ZZZZ") |
|
{ |
|
# If the array is OK, it will be a notice. |
|
my $alert_level = "notice"; |
|
my $message_key = "scan_hpacucli_note_0021"; |
|
if (lc($new_scan_hpacucli_array_status) ne "ok") |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0022"; |
|
} |
|
my $variables = { |
|
name => $scan_hpacucli_array_name, |
|
type => $new_scan_hpacucli_array_type, |
|
status => $new_scan_hpacucli_array_status, |
|
error => $new_scan_hpacucli_array_error_message, |
|
}; |
|
my $log_level = $alert_level eq "warning" ? 1 : 2; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => $log_level, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => $alert_level, |
|
message => $message_key, |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_arrays |
|
( |
|
scan_hpacucli_array_uuid, |
|
scan_hpacucli_array_host_uuid, |
|
scan_hpacucli_array_controller_uuid, |
|
scan_hpacucli_array_name, |
|
scan_hpacucli_array_type, |
|
scan_hpacucli_array_status, |
|
scan_hpacucli_array_error_message, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($scan_hpacucli_array_uuid).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_controller_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_array_name).", |
|
".$anvil->Database->quote($new_scan_hpacucli_array_type).", |
|
".$anvil->Database->quote($new_scan_hpacucli_array_status).", |
|
".$anvil->Database->quote($new_scan_hpacucli_array_error_message).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
|
|
# Logical Drive |
|
foreach my $scan_hpacucli_logical_drive_name (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}}) |
|
{ |
|
# No thermal data |
|
my $scan_hpacucli_logical_drive_uuid = $anvil->data->{'scan-hpacucli'}{logical_drives}{by_name}{$scan_hpacucli_logical_drive_name} ? $anvil->data->{'scan-hpacucli'}{logical_drives}{by_name}{$scan_hpacucli_logical_drive_name} : ""; |
|
my $new_scan_hpacucli_logical_drive_caching = ""; |
|
my $new_scan_hpacucli_logical_drive_os_device_name = ""; |
|
my $new_scan_hpacucli_logical_drive_type = ""; |
|
my $new_scan_hpacucli_logical_drive_raid_level = ""; |
|
my $new_scan_hpacucli_logical_drive_size = ""; |
|
my $new_scan_hpacucli_logical_drive_strip_size = ""; |
|
my $new_scan_hpacucli_logical_drive_stripe_size = ""; |
|
my $new_scan_hpacucli_logical_drive_status = ""; |
|
|
|
# If this is the virtual array, set the sizes to 0. |
|
if ($scan_hpacucli_logical_drive_name eq "9999") |
|
{ |
|
$new_scan_hpacucli_logical_drive_size = 0; |
|
$new_scan_hpacucli_logical_drive_strip_size = 0; |
|
$new_scan_hpacucli_logical_drive_stripe_size = 0; |
|
} |
|
|
|
### Gather the variables. |
|
# Caching |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{caching}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_caching = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{caching}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_logical_drive_caching => $new_scan_hpacucli_logical_drive_caching }}); |
|
} |
|
# Disk name (in the OS) |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{disk_name}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_os_device_name = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{disk_name}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_logical_drive_os_device_name => $new_scan_hpacucli_logical_drive_os_device_name }}); |
|
} |
|
# Drive type |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{drive_type}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_type = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{drive_type}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_logical_drive_type => $new_scan_hpacucli_logical_drive_type }}); |
|
} |
|
# RAID level |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{fault_tolerance}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_raid_level = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{fault_tolerance}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_logical_drive_raid_level => $new_scan_hpacucli_logical_drive_raid_level }}); |
|
} |
|
# Drive size - Needs to be converted to bytes at initial processing. |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{size}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_size = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{size}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_scan_hpacucli_logical_drive_size" => $new_scan_hpacucli_logical_drive_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_size}).")", |
|
}}); |
|
} |
|
# Strip size |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{strip_size}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_strip_size = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{strip_size}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_scan_hpacucli_logical_drive_strip_size" => $new_scan_hpacucli_logical_drive_strip_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_strip_size}).")", |
|
}}); |
|
} |
|
# Stripe size |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{full_stripe_size}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_stripe_size = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{full_stripe_size}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_scan_hpacucli_logical_drive_stripe_size" => $new_scan_hpacucli_logical_drive_stripe_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_stripe_size}).")", |
|
}}); |
|
} |
|
# Status |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{status}) |
|
{ |
|
$new_scan_hpacucli_logical_drive_status = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{status}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_logical_drive_status => $new_scan_hpacucli_logical_drive_status }}); |
|
} |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
new_scan_hpacucli_logical_drive_caching => $new_scan_hpacucli_logical_drive_caching, |
|
new_scan_hpacucli_logical_drive_os_device_name => $new_scan_hpacucli_logical_drive_os_device_name, |
|
new_scan_hpacucli_logical_drive_type => $new_scan_hpacucli_logical_drive_type, |
|
new_scan_hpacucli_logical_drive_raid_level => $new_scan_hpacucli_logical_drive_raid_level, |
|
new_scan_hpacucli_logical_drive_size => $new_scan_hpacucli_logical_drive_size, |
|
new_scan_hpacucli_logical_drive_strip_size => $new_scan_hpacucli_logical_drive_strip_size, |
|
new_scan_hpacucli_logical_drive_stripe_size => $new_scan_hpacucli_logical_drive_stripe_size, |
|
new_scan_hpacucli_logical_drive_status => $new_scan_hpacucli_logical_drive_status, |
|
}}); |
|
|
|
if (($scan_hpacucli_logical_drive_uuid) && (exists $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid})) |
|
{ |
|
my $old_scan_hpacucli_logical_drive_array_uuid = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_array_uuid}; |
|
my $old_scan_hpacucli_logical_drive_name = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_name}; |
|
my $old_scan_hpacucli_logical_drive_caching = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_caching}; |
|
my $old_scan_hpacucli_logical_drive_os_device_name = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_os_device_name}; |
|
my $old_scan_hpacucli_logical_drive_type = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_type}; |
|
my $old_scan_hpacucli_logical_drive_raid_level = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_raid_level}; |
|
my $old_scan_hpacucli_logical_drive_size = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_size}; |
|
my $old_scan_hpacucli_logical_drive_strip_size = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_strip_size}; |
|
my $old_scan_hpacucli_logical_drive_stripe_size = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_stripe_size}; |
|
my $old_scan_hpacucli_logical_drive_status = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_status}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_logical_drive_uuid => $scan_hpacucli_logical_drive_uuid, |
|
old_scan_hpacucli_logical_drive_array_uuid => $old_scan_hpacucli_logical_drive_array_uuid, |
|
old_scan_hpacucli_logical_drive_name => $old_scan_hpacucli_logical_drive_name, |
|
old_scan_hpacucli_logical_drive_caching => $old_scan_hpacucli_logical_drive_caching, |
|
old_scan_hpacucli_logical_drive_os_device_name => $old_scan_hpacucli_logical_drive_os_device_name, |
|
old_scan_hpacucli_logical_drive_type => $old_scan_hpacucli_logical_drive_type, |
|
old_scan_hpacucli_logical_drive_raid_level => $old_scan_hpacucli_logical_drive_raid_level, |
|
old_scan_hpacucli_logical_drive_size => $old_scan_hpacucli_logical_drive_size, |
|
old_scan_hpacucli_logical_drive_strip_size => $old_scan_hpacucli_logical_drive_strip_size, |
|
old_scan_hpacucli_logical_drive_stripe_size => $old_scan_hpacucli_logical_drive_stripe_size, |
|
old_scan_hpacucli_logical_drive_status => $old_scan_hpacucli_logical_drive_status, |
|
}}); |
|
|
|
# Delete this so we know it was processed |
|
delete $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}; |
|
|
|
my $update = 0; |
|
my $recovered = ""; |
|
if ($new_scan_hpacucli_logical_drive_caching ne $old_scan_hpacucli_logical_drive_caching) |
|
{ |
|
# Did it go enabled or disabled? |
|
$update = 1; |
|
my $cleared = 0; |
|
my $message_key = "scan_hpacucli_note_0034"; |
|
if (lc($new_scan_hpacucli_logical_drive_caching) eq "enabled") |
|
{ |
|
# We're back. |
|
$cleared = 1; |
|
$message_key = "scan_hpacucli_note_0035"; |
|
} |
|
if (lc($new_scan_hpacucli_logical_drive_caching) eq "disabled") |
|
{ |
|
# Warn the user about a possible performance hit. |
|
$message_key = "scan_hpacucli_note_0036"; |
|
} |
|
|
|
# Send an alert telling the user that we've found a new controller. |
|
my $variables = { |
|
logical_drive => $scan_hpacucli_logical_drive_name, |
|
array => $scan_hpacucli_array_name, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
new_value => $new_scan_hpacucli_logical_drive_caching, |
|
old_value => $old_scan_hpacucli_logical_drive_caching, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => "warning", |
|
message => $message_key, |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
elsif ($new_scan_hpacucli_logical_drive_status ne $old_scan_hpacucli_logical_drive_status) |
|
{ |
|
# NOTE: Auto-restored a drive that was re-inserted |
|
# Example messages; "Interim Recovery Mode" |
|
# "Recovering, 0% complete" |
|
# LD transitions (OK -> Eject -> Plug back in) |
|
$update = 1; |
|
my $cleared = 0; |
|
my $alert_level = "warning"; |
|
my $message_key = "scan_hpacucli_note_0037"; |
|
if ($old_scan_hpacucli_logical_drive_status eq "VANISHED") |
|
{ |
|
# It's back |
|
$cleared = 1; |
|
$message_key = "scan_hpacucli_note_0045"; |
|
} |
|
elsif (lc($new_scan_hpacucli_logical_drive_status) eq "ok") |
|
{ |
|
# Back to healthy. |
|
$cleared = 1; |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0038"; |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_logical_drive_uuid.":rebuilding_logical_drive:".$scan_hpacucli_logical_drive_name, set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
} |
|
elsif ($new_scan_hpacucli_logical_drive_status =~ /Recovering, (.*?)% complete/i) |
|
{ |
|
# We'll set an alert so that one alert goes out when |
|
# the rebuild starts. |
|
$recovered = $1; |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_logical_drive_uuid.":rebuilding_logical_drive:".$scan_hpacucli_logical_drive_name, set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
recovered => $recovered, |
|
changed => $changed, |
|
}}); |
|
if ($changed) |
|
{ |
|
# Let the user know the rebuild has started. |
|
$message_key = "scan_hpacucli_note_0039"; |
|
} |
|
else |
|
{ |
|
# Still under way |
|
$alert_level = "notice"; |
|
$message_key = "scan_hpacucli_note_0040"; |
|
} |
|
} |
|
elsif (lc($new_scan_hpacucli_logical_drive_status) eq "interim recovery mode") |
|
{ |
|
# Drive just failed. |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0041"; |
|
} |
|
|
|
# Send the alert |
|
my $variables = { |
|
logical_drive => $scan_hpacucli_logical_drive_name, |
|
array => $scan_hpacucli_array_name, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
new_value => $new_scan_hpacucli_logical_drive_status, |
|
old_value => $old_scan_hpacucli_logical_drive_status, |
|
recovered => $recovered, |
|
}; |
|
my $log_level = (($alert_level eq "warning") or ($alert_level eq "critical")) ? 1 : 2; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => $log_level, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => $alert_level, |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
elsif (($new_scan_hpacucli_logical_drive_os_device_name ne $old_scan_hpacucli_logical_drive_os_device_name) or |
|
($new_scan_hpacucli_logical_drive_type ne $old_scan_hpacucli_logical_drive_type) or |
|
($new_scan_hpacucli_logical_drive_raid_level ne $old_scan_hpacucli_logical_drive_raid_level) or |
|
($new_scan_hpacucli_logical_drive_size ne $old_scan_hpacucli_logical_drive_size) or |
|
($new_scan_hpacucli_logical_drive_strip_size ne $old_scan_hpacucli_logical_drive_strip_size) or |
|
($new_scan_hpacucli_logical_drive_stripe_size ne $old_scan_hpacucli_logical_drive_stripe_size)) |
|
{ |
|
# Something else changed. This should normally never happen. |
|
$update = 1; |
|
my $variables = { |
|
logical_drive => $scan_hpacucli_logical_drive_name, |
|
array => $scan_hpacucli_array_name, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
new_os_drive_name => $new_scan_hpacucli_logical_drive_os_device_name, |
|
old_os_drive_name => $old_scan_hpacucli_logical_drive_os_device_name, |
|
new_type => $new_scan_hpacucli_logical_drive_type, |
|
old_type => $old_scan_hpacucli_logical_drive_type, |
|
new_raid_level => $new_scan_hpacucli_logical_drive_raid_level, |
|
old_raid_level => $old_scan_hpacucli_logical_drive_raid_level, |
|
new_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_size}), |
|
old_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hpacucli_logical_drive_size}), |
|
new_strip_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_strip_size}), |
|
old_strip_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hpacucli_logical_drive_strip_size}), |
|
new_stripe_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_stripe_size}), |
|
old_stripe_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hpacucli_logical_drive_stripe_size}), |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0042", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0042", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# If something changed, UPDATE. |
|
if ($update) |
|
{ |
|
# Quote the numbers. |
|
my $quoted_scan_hpacucli_logical_drive_size = $anvil->Database->quote($new_scan_hpacucli_logical_drive_size); |
|
my $quoted_scan_hpacucli_logical_drive_strip_size = $anvil->Database->quote($new_scan_hpacucli_logical_drive_strip_size); |
|
my $quoted_scan_hpacucli_logical_drive_stripe_size = $anvil->Database->quote($new_scan_hpacucli_logical_drive_stripe_size); |
|
$quoted_scan_hpacucli_logical_drive_size =~ s/^'(.*?)'$/$1/; |
|
$quoted_scan_hpacucli_logical_drive_strip_size =~ s/^'(.*?)'$/$1/; |
|
$quoted_scan_hpacucli_logical_drive_stripe_size =~ s/^'(.*?)'$/$1/; |
|
|
|
# Do the update |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_logical_drives |
|
SET |
|
scan_hpacucli_logical_drive_array_uuid = ".$anvil->Database->quote($scan_hpacucli_array_uuid).", |
|
scan_hpacucli_logical_drive_name = ".$anvil->Database->quote($scan_hpacucli_logical_drive_name).", |
|
scan_hpacucli_logical_drive_caching = ".$anvil->Database->quote($new_scan_hpacucli_logical_drive_caching).", |
|
scan_hpacucli_logical_drive_os_device_name = ".$anvil->Database->quote($new_scan_hpacucli_logical_drive_os_device_name).", |
|
scan_hpacucli_logical_drive_type = ".$anvil->Database->quote($new_scan_hpacucli_logical_drive_type).", |
|
scan_hpacucli_logical_drive_raid_level = ".$anvil->Database->quote($new_scan_hpacucli_logical_drive_raid_level).", |
|
scan_hpacucli_logical_drive_size = $quoted_scan_hpacucli_logical_drive_size, |
|
scan_hpacucli_logical_drive_strip_size = $quoted_scan_hpacucli_logical_drive_strip_size, |
|
scan_hpacucli_logical_drive_stripe_size = $quoted_scan_hpacucli_logical_drive_stripe_size, |
|
scan_hpacucli_logical_drive_status = ".$anvil->Database->quote($new_scan_hpacucli_logical_drive_status).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_logical_drive_uuid = ".$anvil->Database->quote($scan_hpacucli_logical_drive_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
else |
|
{ |
|
# New, INSERT. |
|
$scan_hpacucli_logical_drive_uuid = $anvil->Get->uuid(); |
|
$anvil->data->{'scan-hpacucli'}{logical_drives}{by_name}{$scan_hpacucli_logical_drive_name} = $scan_hpacucli_logical_drive_uuid; |
|
$anvil->data->{'scan-hpacucli'}{logical_drives}{by_uuid}{$scan_hpacucli_logical_drive_uuid} = $scan_hpacucli_logical_drive_name; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::logical_drives::by_name::${scan_hpacucli_logical_drive_name}" => $anvil->data->{'scan-hpacucli'}{logical_drives}{by_name}{$scan_hpacucli_logical_drive_name}, |
|
"scan-hpacucli::logical_drives::by_uuid::${scan_hpacucli_logical_drive_uuid}" => $anvil->data->{'scan-hpacucli'}{logical_drives}{by_uuid}{$scan_hpacucli_logical_drive_uuid}, |
|
}}); |
|
|
|
# Send an alert telling the user that we've found a new controller. |
|
my $variables = { |
|
name => $scan_hpacucli_array_name, |
|
logical_drive => $scan_hpacucli_logical_drive_name, |
|
new_caching => $new_scan_hpacucli_logical_drive_caching, |
|
new_os_device_name => $new_scan_hpacucli_logical_drive_os_device_name, |
|
new_type => $new_scan_hpacucli_logical_drive_type, |
|
new_raid_level => $new_scan_hpacucli_logical_drive_raid_level, |
|
new_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_size}), |
|
new_strip_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_strip_size}), |
|
new_stripe_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_logical_drive_stripe_size}), |
|
new_status => $new_scan_hpacucli_logical_drive_status, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0033", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0033", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
### NOTE: The rest of the alerts will be in the format '- Variable: [$value]'. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0003", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0003", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# Quote some stuff manually |
|
my $quoted_scan_hpacucli_logical_drive_size = $anvil->Database->quote($new_scan_hpacucli_logical_drive_size); |
|
my $quoted_scan_hpacucli_logical_drive_strip_size = $anvil->Database->quote($new_scan_hpacucli_logical_drive_strip_size); |
|
my $quoted_scan_hpacucli_logical_drive_stripe_size = $anvil->Database->quote($new_scan_hpacucli_logical_drive_stripe_size); |
|
$quoted_scan_hpacucli_logical_drive_size =~ s/^'(.*?)'$/$1/; |
|
$quoted_scan_hpacucli_logical_drive_strip_size =~ s/^'(.*?)'$/$1/; |
|
$quoted_scan_hpacucli_logical_drive_stripe_size =~ s/^'(.*?)'$/$1/; |
|
|
|
# Now INERT variables. |
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_logical_drives |
|
( |
|
scan_hpacucli_logical_drive_uuid, |
|
scan_hpacucli_logical_drive_host_uuid, |
|
scan_hpacucli_logical_drive_array_uuid, |
|
scan_hpacucli_logical_drive_name, |
|
scan_hpacucli_logical_drive_caching, |
|
scan_hpacucli_logical_drive_os_device_name, |
|
scan_hpacucli_logical_drive_type, |
|
scan_hpacucli_logical_drive_raid_level, |
|
scan_hpacucli_logical_drive_size, |
|
scan_hpacucli_logical_drive_strip_size, |
|
scan_hpacucli_logical_drive_stripe_size, |
|
scan_hpacucli_logical_drive_status, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($scan_hpacucli_logical_drive_uuid).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_array_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_logical_drive_name).", |
|
".$anvil->Database->quote($new_scan_hpacucli_logical_drive_caching).", |
|
".$anvil->Database->quote($new_scan_hpacucli_logical_drive_os_device_name).", |
|
".$anvil->Database->quote($new_scan_hpacucli_logical_drive_type).", |
|
".$anvil->Database->quote($new_scan_hpacucli_logical_drive_raid_level).", |
|
$quoted_scan_hpacucli_logical_drive_size, |
|
$quoted_scan_hpacucli_logical_drive_strip_size, |
|
$quoted_scan_hpacucli_logical_drive_stripe_size, |
|
".$anvil->Database->quote($new_scan_hpacucli_logical_drive_status).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
|
|
# Process logical drive variables now. Note that there are no temperatures. |
|
foreach my $scan_hpacucli_variable_name (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}}) |
|
{ |
|
# Insert the variables. |
|
my $new_scan_hpacucli_variable_value = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{data}{detail}{$scan_hpacucli_variable_name}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_name => $scan_hpacucli_variable_name, |
|
new_scan_hpacucli_variable_value => $new_scan_hpacucli_variable_value, |
|
}}); |
|
|
|
# Have we seen this variable before? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_variables::scan_hpacucli_variable_uuid::source_table::scan_hpacucli_logical_drives::source_uuid::${scan_hpacucli_logical_drive_uuid}::detail::${scan_hpacucli_variable_name}::scan_hpacucli_variable_uuid" => $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_logical_drives}{source_uuid}{$scan_hpacucli_logical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}, |
|
}}); |
|
if ($anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_logical_drives}{source_uuid}{$scan_hpacucli_logical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}) |
|
{ |
|
# Exists. Has it changed? |
|
my $scan_hpacucli_variable_uuid = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_logical_drives}{source_uuid}{$scan_hpacucli_logical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}; |
|
my $old_scan_hpacucli_variable_value = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_logical_drives}{source_uuid}{$scan_hpacucli_logical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_value}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_uuid => $scan_hpacucli_variable_uuid, |
|
old_scan_hpacucli_variable_value => $old_scan_hpacucli_variable_value, |
|
}}); |
|
|
|
# delete this so that we know it was processed. |
|
delete $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_logical_drives}{source_uuid}{$scan_hpacucli_logical_drive_uuid}{detail}{$scan_hpacucli_variable_name}; |
|
|
|
if ($old_scan_hpacucli_variable_value ne $new_scan_hpacucli_variable_value) |
|
{ |
|
# Now update. Alert the user as a warning, this |
|
# should rarely ever change. |
|
my $variables = { |
|
logical_drive => $scan_hpacucli_logical_drive_name, |
|
array => $scan_hpacucli_array_name, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
variable_name => $scan_hpacucli_variable_name, |
|
old_value => $old_scan_hpacucli_variable_value ? $old_scan_hpacucli_variable_value : "--", |
|
new_value => $new_scan_hpacucli_variable_value ? $new_scan_hpacucli_variable_value : "--", |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0066", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0066", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# UPDATE |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_variables |
|
SET |
|
scan_hpacucli_variable_value = ".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_variable_uuid = ".$anvil->Database->quote($scan_hpacucli_variable_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
else |
|
{ |
|
# New. Alert the user. |
|
my $variables = { |
|
name => $scan_hpacucli_variable_name, |
|
value => $new_scan_hpacucli_variable_value, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0004", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0004", |
|
variables => $variables, |
|
show_header => 0, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# INSERT |
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_variables |
|
( |
|
scan_hpacucli_variable_uuid, |
|
scan_hpacucli_variable_host_uuid, |
|
scan_hpacucli_variable_source_table, |
|
scan_hpacucli_variable_source_uuid, |
|
scan_hpacucli_variable_is_temperature, |
|
scan_hpacucli_variable_name, |
|
scan_hpacucli_variable_value, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($anvil->Get->uuid()).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
'scan_hpacucli_logical_drives', |
|
".$anvil->Database->quote($scan_hpacucli_logical_drive_uuid).", |
|
FALSE, |
|
".$anvil->Database->quote($scan_hpacucli_variable_name).", |
|
".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
|
|
# Physical Disks. |
|
foreach my $port (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}}) |
|
{ |
|
foreach my $box (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}}) |
|
{ |
|
foreach my $bay (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}}) |
|
{ |
|
# Throw this into a function to get out of |
|
# indent-hell. |
|
process_a_drive($anvil, $scan_hpacucli_controller_serial_number, $scan_hpacucli_logical_drive_uuid, $scan_hpacucli_array_name, $scan_hpacucli_logical_drive_name, $port, $box, $bay); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
# Look for deleted arrays. |
|
foreach my $scan_hpacucli_array_uuid (keys %{$anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}}) |
|
{ |
|
my $old_scan_hpacucli_array_name = $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_name}; |
|
my $old_scan_hpacucli_array_controller_uuid = $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_controller_uuid}; |
|
my $old_scan_hpacucli_controller_serial_number = $anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$old_scan_hpacucli_array_controller_uuid}; |
|
my $old_scan_hpacucli_array_status = $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_status}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
old_scan_hpacucli_array_name => $old_scan_hpacucli_array_name, |
|
old_scan_hpacucli_array_controller_uuid => $old_scan_hpacucli_array_controller_uuid, |
|
old_scan_hpacucli_controller_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
old_scan_hpacucli_array_status => $old_scan_hpacucli_array_status, |
|
}}); |
|
|
|
next if $old_scan_hpacucli_array_name eq "ZZZZ"; |
|
next if $old_scan_hpacucli_array_status eq "VANISHED"; |
|
|
|
my $variables = { |
|
name => $old_scan_hpacucli_array_name, |
|
serial_number => $old_scan_hpacucli_controller_serial_number, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0031", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0031", |
|
variables => $variables, |
|
show_header => 0, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_arrays |
|
SET |
|
scan_hpacucli_array_status = 'VANISHED', |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_array_uuid = ".$anvil->Database->quote($scan_hpacucli_array_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
|
|
# Look for deleted logical drives. |
|
foreach my $scan_hpacucli_logical_drive_uuid (keys %{$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}}) |
|
{ |
|
# Look for changes |
|
my $old_scan_hpacucli_logical_drive_array_uuid = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_array_uuid}; |
|
my $old_scan_hpacucli_logical_drive_name = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_name}; |
|
my $old_scan_hpacucli_logical_drive_status = $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_status}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_logical_drive_uuid => $scan_hpacucli_logical_drive_uuid, |
|
old_scan_hpacucli_logical_drive_array_uuid => $old_scan_hpacucli_logical_drive_array_uuid, |
|
old_scan_hpacucli_logical_drive_name => $old_scan_hpacucli_logical_drive_name, |
|
old_scan_hpacucli_logical_drive_status => $old_scan_hpacucli_logical_drive_status, |
|
}}); |
|
|
|
next if $old_scan_hpacucli_logical_drive_name eq "9999"; |
|
next if $old_scan_hpacucli_logical_drive_status eq "VANISHED"; |
|
|
|
my $variables = { |
|
logical_drive => $old_scan_hpacucli_logical_drive_name, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0044", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0044", |
|
variables => $variables, |
|
show_header => 0, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_logical_drives |
|
SET |
|
scan_hpacucli_logical_drive_status = 'VANISHED', |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_logical_drive_uuid = ".$anvil->Database->quote($scan_hpacucli_logical_drive_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
|
|
# Now commit the changes. |
|
$anvil->Database->write({query => $anvil->data->{'scan-hpacucli'}{queries}, source => $THIS_FILE, line => __LINE__}); |
|
$anvil->data->{'scan-hpacucli'}{queries} = []; |
|
|
|
return(0); |
|
} |
|
|
|
# Process a specific drive |
|
sub process_a_drive |
|
{ |
|
my ($anvil, $scan_hpacucli_controller_serial_number, $scan_hpacucli_logical_drive_uuid, $scan_hpacucli_array_name, $scan_hpacucli_logical_drive_name, $port, $box, $bay) = @_; |
|
|
|
my $scan_hpacucli_physical_drive_uuid = ""; |
|
my $scan_hpacucli_physical_drive_serial_number = ""; |
|
my $new_scan_hpacucli_physical_drive_model = ""; |
|
my $new_scan_hpacucli_physical_drive_interface = ""; |
|
my $new_scan_hpacucli_physical_drive_status = ""; |
|
my $new_scan_hpacucli_physical_drive_size = 0; |
|
my $new_scan_hpacucli_physical_drive_type = ""; |
|
my $new_scan_hpacucli_physical_drive_rpm = 0; |
|
my $new_scan_hpacucli_physical_drive_temperature = ""; |
|
my $new_scan_hpacucli_physical_drive_last_failure_reason = ""; |
|
my $maximum_drive_temperature = 0; |
|
|
|
# Serial Number |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{serial_number}) |
|
{ |
|
$scan_hpacucli_physical_drive_serial_number = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{serial_number}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_physical_drive_serial_number => $scan_hpacucli_physical_drive_serial_number }}); |
|
} |
|
# Model |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{model}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_model = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{model}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_physical_drive_model => $new_scan_hpacucli_physical_drive_model }}); |
|
} |
|
# Interface |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{interface_type}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_interface = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{interface_type}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_physical_drive_interface => $new_scan_hpacucli_physical_drive_interface }}); |
|
} |
|
# Status |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{status}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_status = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{status}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_physical_drive_status => $new_scan_hpacucli_physical_drive_status }}); |
|
} |
|
# Size |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{size}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_size = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{size}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new_scan_hpacucli_physical_drive_size" => $new_scan_hpacucli_physical_drive_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_physical_drive_size}).")", |
|
}}); |
|
} |
|
# Type |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{drive_type}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_type = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{drive_type}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_physical_drive_type => $new_scan_hpacucli_physical_drive_type }}); |
|
} |
|
# RPM (0 if SSD) |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{rotational_speed}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_rpm = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{rotational_speed}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_physical_drive_rpm => $new_scan_hpacucli_physical_drive_rpm }}); |
|
} |
|
# Temperature |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{temperature}{current_temperature}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_temperature = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{temperature}{current_temperature}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_physical_drive_temperature => $new_scan_hpacucli_physical_drive_temperature }}); |
|
} |
|
# Last failure reason |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{last_failure_reason}) |
|
{ |
|
$new_scan_hpacucli_physical_drive_last_failure_reason = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{last_failure_reason}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_physical_drive_last_failure_reason => $new_scan_hpacucli_physical_drive_last_failure_reason }}); |
|
} |
|
# Maximum temperature |
|
if ($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{temperature}{maximum_temperature}) |
|
{ |
|
$maximum_drive_temperature = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{temperature}{maximum_temperature}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { maximum_drive_temperature => $maximum_drive_temperature }}); |
|
} |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_physical_drive_serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
new_scan_hpacucli_physical_drive_model => $new_scan_hpacucli_physical_drive_model, |
|
new_scan_hpacucli_physical_drive_interface => $new_scan_hpacucli_physical_drive_interface, |
|
new_scan_hpacucli_physical_drive_status => $new_scan_hpacucli_physical_drive_status, |
|
new_scan_hpacucli_physical_drive_size => $new_scan_hpacucli_physical_drive_size, |
|
new_scan_hpacucli_physical_drive_type => $new_scan_hpacucli_physical_drive_type, |
|
new_scan_hpacucli_physical_drive_rpm => $new_scan_hpacucli_physical_drive_rpm, |
|
new_scan_hpacucli_physical_drive_temperature => $new_scan_hpacucli_physical_drive_temperature, |
|
new_scan_hpacucli_physical_drive_last_failure_reason => $new_scan_hpacucli_physical_drive_last_failure_reason, |
|
maximum_drive_temperature => $maximum_drive_temperature, |
|
}}); |
|
|
|
# Delete the Port, Box and Bay values so that they don't get processed as their own variables. |
|
delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{port}; |
|
delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{box}; |
|
delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{bay}; |
|
|
|
# Die if we don't have a serial number |
|
if (not $scan_hpacucli_physical_drive_serial_number) |
|
{ |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 0, key => "scan_hpacucli_error_0011", variables => { |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
array_name => $scan_hpacucli_array_name, |
|
logical_drive_name => $scan_hpacucli_logical_drive_name, |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}}); |
|
$anvil->nice_exit({exit_code => 9}); |
|
} |
|
|
|
# Have we seen this drive before? |
|
if ($anvil->data->{'scan-hpacucli'}{physical_drives}{by_serial}{$scan_hpacucli_physical_drive_serial_number}) |
|
{ |
|
# Yup! Look for changes. |
|
$scan_hpacucli_physical_drive_uuid = $anvil->data->{'scan-hpacucli'}{physical_drives}{by_serial}{$scan_hpacucli_physical_drive_serial_number}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_physical_drive_uuid => $scan_hpacucli_physical_drive_uuid }}); |
|
|
|
# Gather the old data. |
|
my $old_scan_hpacucli_logical_drive_uuid = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_logical_drive_uuid}; |
|
my $old_scan_hpacucli_physical_drive_model = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_model}; |
|
my $old_scan_hpacucli_physical_drive_interface = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_interface}; |
|
my $old_scan_hpacucli_physical_drive_status = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_status}; |
|
my $old_scan_hpacucli_physical_drive_size = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_size}; |
|
my $old_scan_hpacucli_physical_drive_type = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_type}; |
|
my $old_scan_hpacucli_physical_drive_rpm = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_rpm}; |
|
my $old_scan_hpacucli_physical_drive_temperature = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_temperature}; |
|
my $old_scan_hpacucli_physical_drive_last_failure_reason = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_last_failure_reason}; |
|
my $old_scan_hpacucli_physical_drive_port = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_port}; |
|
my $old_scan_hpacucli_physical_drive_box = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_box}; |
|
my $old_scan_hpacucli_physical_drive_bay = $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_bay}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
old_scan_hpacucli_logical_drive_uuid => $old_scan_hpacucli_logical_drive_uuid, |
|
old_scan_hpacucli_physical_drive_model => $old_scan_hpacucli_physical_drive_model, |
|
old_scan_hpacucli_physical_drive_interface => $old_scan_hpacucli_physical_drive_interface, |
|
old_scan_hpacucli_physical_drive_status => $old_scan_hpacucli_physical_drive_status, |
|
old_scan_hpacucli_physical_drive_size => $old_scan_hpacucli_physical_drive_size, |
|
old_scan_hpacucli_physical_drive_type => $old_scan_hpacucli_physical_drive_type, |
|
old_scan_hpacucli_physical_drive_rpm => $old_scan_hpacucli_physical_drive_rpm, |
|
old_scan_hpacucli_physical_drive_temperature => $old_scan_hpacucli_physical_drive_temperature, |
|
old_scan_hpacucli_physical_drive_last_failure_reason => $old_scan_hpacucli_physical_drive_last_failure_reason, |
|
old_scan_hpacucli_physical_drive_port => $old_scan_hpacucli_physical_drive_port, |
|
old_scan_hpacucli_physical_drive_box => $old_scan_hpacucli_physical_drive_box, |
|
old_scan_hpacucli_physical_drive_bay => $old_scan_hpacucli_physical_drive_bay, |
|
}}); |
|
|
|
# delete this so that we know it was processed. |
|
delete $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}; |
|
|
|
my $update = 0; |
|
# Did the drive move between logical drives? |
|
if ($scan_hpacucli_logical_drive_uuid ne $old_scan_hpacucli_logical_drive_uuid) |
|
{ |
|
$update = 1; |
|
|
|
# We'll need to get the host, controller serial number and array name |
|
my $query = " |
|
SELECT |
|
a.host_name, |
|
b.scan_hpacucli_controller_serial_number, |
|
c.scan_hpacucli_array_name, |
|
d.scan_hpacucli_logical_drive_name |
|
FROM |
|
hosts a, |
|
scan_hpacucli_controllers b, |
|
scan_hpacucli_arrays c, |
|
scan_hpacucli_logical_drives d |
|
WHERE |
|
a.host_uuid = b.scan_hpacucli_controller_host_uuid |
|
AND |
|
b.scan_hpacucli_controller_uuid = c.scan_hpacucli_array_controller_uuid |
|
AND |
|
c.scan_hpacucli_array_uuid = d.scan_hpacucli_logical_drive_array_uuid |
|
AND |
|
c.scan_hpacucli_array_uuid = ".$anvil->Database->quote($old_scan_hpacucli_logical_drive_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
my $results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
my $count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
my $old_host_name = $results->[0]->[0] ? $results->[0]->[0] : "--"; |
|
my $old_scan_hpacucli_controller_serial_number = $results->[0]->[1] ? $results->[0]->[1] : "--"; |
|
my $old_scan_hpacucli_array_name = $results->[0]->[2] ? $results->[0]->[2] : "--"; |
|
my $old_scan_hpacucli_logical_drive_name = $results->[0]->[3] ? $results->[0]->[3] : "--"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
old_host_name => $old_host_name, |
|
old_scan_hpacucli_controller_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
old_scan_hpacucli_array_name => $old_scan_hpacucli_array_name, |
|
old_scan_hpacucli_logical_drive_name => $old_scan_hpacucli_logical_drive_name, |
|
}}); |
|
|
|
# Send an alert telling the drive has moved. |
|
my $variables = { |
|
drive_serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
old_host_name => $old_host_name, |
|
new_host_name => $anvil->Get->host_name, |
|
new_controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
old_scan_hpacucli_controller_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
new_array_name => $scan_hpacucli_array_name, |
|
old_array_name => $scan_hpacucli_array_name, |
|
new_logical_drive_name => $scan_hpacucli_logical_drive_name, |
|
old_logical_drive_name => $old_scan_hpacucli_logical_drive_name |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0047", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0047", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# Has the status changed? |
|
if ($old_scan_hpacucli_physical_drive_status ne $new_scan_hpacucli_physical_drive_status) |
|
{ |
|
$update = 1; |
|
|
|
# Yup. Start with an alert about it being not OK, and change if it is now OK. |
|
my $cleared = 0; |
|
my $message_key = "scan_hpacucli_note_0048"; |
|
|
|
# Did it return? |
|
if ($old_scan_hpacucli_physical_drive_status eq "VANISHED") |
|
{ |
|
# The drive is back. |
|
$message_key = "scan_hpacucli_note_0050"; |
|
} |
|
elsif (lc($new_scan_hpacucli_physical_drive_status) eq "ok") |
|
{ |
|
# Drive is OK again. |
|
$cleared = 1; |
|
$message_key = "scan_hpacucli_note_0051"; |
|
} |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
old_status => $old_scan_hpacucli_physical_drive_status, |
|
new_status => $new_scan_hpacucli_physical_drive_status, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => "warning", |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# Did the temperature change? Whether it did or not, we need to record the current |
|
# temperature state. |
|
### NOTE: HP tells us the maximum temperature each of its drives can handle. This is |
|
### a low number, so we need to tighten up some thresholds compared to usual |
|
### ranges. |
|
# Set defaults |
|
my $high_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{high_critical}; |
|
my $high_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{high_warning}; |
|
my $low_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{low_warning}; |
|
my $low_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{low_critical}; |
|
my $jump = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{jump}; |
|
my $buffer = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{buffer}; |
|
my $clear_high_critical = $high_critical - $buffer; |
|
my $clear_high_warning = $high_warning - $buffer; |
|
my $clear_low_critical = $low_critical - $buffer; |
|
my $clear_low_warning = $low_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
high_critical => $high_critical, |
|
high_warning => $high_warning, |
|
low_warning => $low_warning, |
|
low_critical => $low_critical, |
|
jump => $jump, |
|
buffer => $buffer, |
|
clear_high_critical => $clear_high_critical, |
|
clear_high_warning => $clear_high_warning, |
|
clear_low_critical => $clear_low_critical, |
|
clear_low_warning => $clear_low_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
|
|
# Did we get a maximum temperature from the drive? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
maximum_drive_temperature => $maximum_drive_temperature, |
|
"scan-hpacucli::ignore_maximum_temperature" => $anvil->data->{'scan-hpacucli'}{ignore_maximum_temperature}, |
|
}}); |
|
if (($maximum_drive_temperature) && (not $anvil->data->{'scan-hpacucli'}{ignore_maximum_temperature})) |
|
{ |
|
$high_critical = $maximum_drive_temperature; |
|
$high_warning = $maximum_drive_temperature - 2; |
|
$clear_high_critical = $high_critical - $buffer; |
|
$clear_high_warning = $high_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
high_critical => $high_critical, |
|
high_warning => $high_warning, |
|
clear_high_critical => $clear_high_critical, |
|
clear_high_warning => $clear_high_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
} |
|
|
|
# Clear alerts, if needed. The order is important as clearing a warning will replace |
|
# clearing a critical when a sensor goes critical -> ok in one scan. Once done, we'll |
|
# check if we've crossed into a warning or critical state. If so, those will replace |
|
# any cleared messages. |
|
my $cleared = 0; |
|
my $alert_level = "info"; |
|
my $message_key = "scan_hpacucli_note_0053"; |
|
my $delta = 0; |
|
if ($new_scan_hpacucli_physical_drive_temperature) |
|
{ |
|
if ($new_scan_hpacucli_physical_drive_temperature < $clear_high_critical) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_high_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$cleared = 1; |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0054"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
if ($new_scan_hpacucli_physical_drive_temperature < $clear_high_warning) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_high_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
# The temperature is no longer |
|
# warning, and it didn't just go |
|
# critical |
|
$cleared = 1; |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0055"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
if ($new_scan_hpacucli_physical_drive_temperature > $clear_low_critical) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_low_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$cleared = 1; |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0056"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
if ($new_scan_hpacucli_physical_drive_temperature > $clear_low_warning) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_low_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$cleared = 1; |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0057"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
|
|
# Now see if the temperature has crossed into a warning or critical state. |
|
my $temperature_state = "ok"; |
|
my $temperature_is = "nominal"; |
|
if ($new_scan_hpacucli_physical_drive_temperature > $high_critical) |
|
{ |
|
# Crossed the high critical threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_high_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0060"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_physical_drive_temperature > $high_warning) |
|
{ |
|
# Crossed the high warning threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_high_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0061"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_physical_drive_temperature < $low_critical) |
|
{ |
|
# Dropped below the low critical threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_low_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0062"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"temperature_state" => $temperature_state, |
|
"temperature_is" => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_physical_drive_temperature < $low_warning) |
|
{ |
|
# Crossed the low warning threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_low_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0063"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
else |
|
{ |
|
# Did it change enough to trigger a jump alert? |
|
if ($new_scan_hpacucli_physical_drive_temperature > $old_scan_hpacucli_physical_drive_temperature) |
|
{ |
|
# Jumped |
|
$delta = $new_scan_hpacucli_physical_drive_temperature - $old_scan_hpacucli_physical_drive_temperature; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { delta => $delta }}); |
|
if ($delta >= $jump) |
|
{ |
|
# Big jump. |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0058"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
else |
|
{ |
|
# Dropped |
|
$delta = $old_scan_hpacucli_physical_drive_temperature - $new_scan_hpacucli_physical_drive_temperature; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { delta => $delta }}); |
|
if ($delta >= $jump) |
|
{ |
|
# Big drop. |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0059"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
} |
|
|
|
# Record this for later processing into the 'temperature' table. |
|
my $sensor_host_key = "physical_drive:".$scan_hpacucli_physical_drive_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { sensor_host_key => $sensor_host_key }}); |
|
|
|
$anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_value_c} = $new_scan_hpacucli_physical_drive_temperature; |
|
$anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_state} = $temperature_state; |
|
$anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_is} = $temperature_is; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new::temperature::scan_hpacucli_physical_drive_temperature::${sensor_host_key}::temperature_value_c" => $anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_value_c}, |
|
"new::temperature::scan_hpacucli_physical_drive_temperature::${sensor_host_key}::temperature_state" => $anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_state}, |
|
"new::temperature::scan_hpacucli_physical_drive_temperature::${sensor_host_key}::temperature_is" => $anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_is}, |
|
}}); |
|
} |
|
|
|
# Now, if the temperature changed, update and send an alert if appropriate. |
|
if ($new_scan_hpacucli_physical_drive_temperature ne $old_scan_hpacucli_physical_drive_temperature) |
|
{ |
|
# Yup. Analyze |
|
$update = 1; |
|
|
|
# Send an alert telling the user that we've found a variable for this drive. Note |
|
# that we add ' C' to the temperatures so that they get translated to '°F' if desired |
|
# by the reader. |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
old_temperature => $old_scan_hpacucli_physical_drive_temperature ? $old_scan_hpacucli_physical_drive_temperature." °C" : "--", |
|
new_temperature => $new_scan_hpacucli_physical_drive_temperature ? $new_scan_hpacucli_physical_drive_temperature." °C" : "--", |
|
delta => $delta." °C", |
|
high_critical_temperature => $high_critical." °C", |
|
high_warning_temperature => $high_warning." °C", |
|
low_critical_temperature => $low_critical." °C", |
|
low_warning_temperature => $low_warning." °C", |
|
}; |
|
my $log_level = (($alert_level eq "warning") or ($alert_level eq "critical")) ? 1 : 2; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => $log_level, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => $alert_level, |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
# Anything else? |
|
if (($old_scan_hpacucli_physical_drive_model ne $new_scan_hpacucli_physical_drive_model) or |
|
($old_scan_hpacucli_physical_drive_interface ne $new_scan_hpacucli_physical_drive_interface) or |
|
($old_scan_hpacucli_physical_drive_size ne $new_scan_hpacucli_physical_drive_size) or |
|
($old_scan_hpacucli_physical_drive_rpm ne $new_scan_hpacucli_physical_drive_rpm) or |
|
($new_scan_hpacucli_physical_drive_last_failure_reason ne $old_scan_hpacucli_physical_drive_last_failure_reason) or |
|
($port ne $old_scan_hpacucli_physical_drive_port) or |
|
($box ne $old_scan_hpacucli_physical_drive_box) or |
|
($bay ne $old_scan_hpacucli_physical_drive_bay)) |
|
{ |
|
# Something else changed. These normally shouldn't change... |
|
$update = 1; |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
old_model => $old_scan_hpacucli_physical_drive_model, |
|
new_model => $new_scan_hpacucli_physical_drive_model, |
|
old_interface => $old_scan_hpacucli_physical_drive_interface, |
|
new_interface => $new_scan_hpacucli_physical_drive_interface, |
|
old_size => $anvil->Database->quote($old_scan_hpacucli_physical_drive_size), |
|
new_size => $anvil->Database->quote($new_scan_hpacucli_physical_drive_size), |
|
old_rpm => $old_scan_hpacucli_physical_drive_rpm, |
|
new_rpm => $new_scan_hpacucli_physical_drive_rpm, |
|
old_last_failure_reason => $old_scan_hpacucli_physical_drive_last_failure_reason ? $old_scan_hpacucli_physical_drive_last_failure_reason : "--", |
|
new_last_failure_reason => $new_scan_hpacucli_physical_drive_last_failure_reason ? $new_scan_hpacucli_physical_drive_last_failure_reason : "--", |
|
old_port => $old_scan_hpacucli_physical_drive_port, |
|
new_port => $port, |
|
old_box => $old_scan_hpacucli_physical_drive_box, |
|
new_box => $box, |
|
old_bay => $old_scan_hpacucli_physical_drive_bay, |
|
new_bay => $bay, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0052", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0052", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
if ($update) |
|
{ |
|
# UPDATE |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_physical_drives |
|
SET |
|
scan_hpacucli_physical_drive_logical_drive_uuid = ".$anvil->Database->quote($scan_hpacucli_logical_drive_uuid).", |
|
scan_hpacucli_physical_drive_serial_number = ".$anvil->Database->quote($scan_hpacucli_physical_drive_serial_number).", |
|
scan_hpacucli_physical_drive_model = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_model).", |
|
scan_hpacucli_physical_drive_interface = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_interface).", |
|
scan_hpacucli_physical_drive_status = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_status).", |
|
scan_hpacucli_physical_drive_size = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_size).", |
|
scan_hpacucli_physical_drive_type = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_type).", |
|
scan_hpacucli_physical_drive_rpm = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_rpm).", |
|
scan_hpacucli_physical_drive_temperature = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_temperature).", |
|
scan_hpacucli_physical_drive_last_failure_reason = ".$anvil->Database->quote($new_scan_hpacucli_physical_drive_last_failure_reason).", |
|
scan_hpacucli_physical_drive_port = ".$anvil->Database->quote($port).", |
|
scan_hpacucli_physical_drive_box = ".$anvil->Database->quote($box).", |
|
scan_hpacucli_physical_drive_bay = ".$anvil->Database->quote($bay).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_physical_drive_uuid = ".$anvil->Database->quote($scan_hpacucli_physical_drive_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
else |
|
{ |
|
# New, INSERT it. |
|
$scan_hpacucli_physical_drive_uuid = $anvil->Get->uuid(); |
|
$anvil->data->{'scan-hpacucli'}{physical_drives}{by_serial}{$scan_hpacucli_physical_drive_serial_number} = $scan_hpacucli_physical_drive_uuid; |
|
$anvil->data->{'scan-hpacucli'}{physical_drives}{by_uuid}{$scan_hpacucli_physical_drive_uuid} = $scan_hpacucli_physical_drive_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::physical_drives::by_serial::${scan_hpacucli_physical_drive_serial_number}" => $anvil->data->{'scan-hpacucli'}{physical_drives}{by_serial}{$scan_hpacucli_physical_drive_serial_number}, |
|
"scan-hpacucli::physical_drives::by_uuid::${scan_hpacucli_physical_drive_uuid}" => $anvil->data->{'scan-hpacucli'}{physical_drives}{by_uuid}{$scan_hpacucli_physical_drive_uuid}, |
|
}}); |
|
|
|
# Send an alert telling the user we found a new drive. |
|
my $variables = { |
|
controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
array_name => $scan_hpacucli_array_name, |
|
logical_drive_name => $scan_hpacucli_logical_drive_name, |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
drive_serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
model => $new_scan_hpacucli_physical_drive_model, |
|
interface => $new_scan_hpacucli_physical_drive_interface, |
|
status => $new_scan_hpacucli_physical_drive_status, |
|
size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_physical_drive_size}), |
|
type => $new_scan_hpacucli_physical_drive_type, |
|
rpm => $new_scan_hpacucli_physical_drive_rpm, |
|
temperature => $new_scan_hpacucli_physical_drive_temperature ? $new_scan_hpacucli_physical_drive_temperature." °C" : "--", |
|
last_failure_reason => $new_scan_hpacucli_physical_drive_last_failure_reason ? $new_scan_hpacucli_physical_drive_last_failure_reason : "--", |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0046", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0046", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# Check for problems with this new drive. |
|
if (lc($new_scan_hpacucli_physical_drive_status) ne "ok") |
|
{ |
|
# There's a problem, send an alert. |
|
my $variables = { |
|
controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0064", variables => $variables}); |
|
$anvil->Alert->register({ |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0064", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
|
|
# Check the temperature, if we read one. |
|
if ($new_scan_hpacucli_physical_drive_temperature =~ /^\d+/) |
|
{ |
|
### NOTE: HP tells us the maximum temperature each of its drives can handle. This is |
|
### a low number, so we need to tighten up some thresholds compared to usual |
|
### ranges. |
|
# Set defaults |
|
my $high_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{high_critical}; |
|
my $high_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{high_warning}; |
|
my $low_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{low_warning}; |
|
my $low_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{low_critical}; |
|
my $jump = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{jump}; |
|
my $buffer = $anvil->data->{'scan-hpacucli'}{thresholds}{drives}{buffer}; |
|
my $clear_high_critical = $high_critical - $buffer; |
|
my $clear_high_warning = $high_warning - $buffer; |
|
my $clear_low_critical = $low_critical - $buffer; |
|
my $clear_low_warning = $low_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
high_critical => $high_critical, |
|
high_warning => $high_warning, |
|
low_warning => $low_warning, |
|
low_critical => $low_critical, |
|
jump => $jump, |
|
buffer => $buffer, |
|
clear_high_critical => $clear_high_critical, |
|
clear_high_warning => $clear_high_warning, |
|
clear_low_critical => $clear_low_critical, |
|
clear_low_warning => $clear_low_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
|
|
# Did we get a maximum temperature from the drive? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
maximum_drive_temperature => $maximum_drive_temperature, |
|
"scan-hpacucli::ignore_maximum_temperature" => $anvil->data->{'scan-hpacucli'}{ignore_maximum_temperature}, |
|
}}); |
|
if (($maximum_drive_temperature) && (not $anvil->data->{'scan-hpacucli'}{ignore_maximum_temperature})) |
|
{ |
|
$high_critical = $maximum_drive_temperature; |
|
$high_warning = $maximum_drive_temperature - 2; |
|
$clear_high_critical = $high_critical - $buffer; |
|
$clear_high_warning = $high_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
high_critical => $high_critical, |
|
high_warning => $high_warning, |
|
clear_high_critical => $clear_high_critical, |
|
clear_high_warning => $clear_high_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
} |
|
|
|
# See if the temperature outside of the warning or critical thresholds. |
|
my $temperature_state = "ok"; |
|
my $temperature_is = "nominal"; |
|
my $alert_level = "warning"; |
|
my $message_key = ""; |
|
if ($new_scan_hpacucli_physical_drive_temperature > $high_critical) |
|
{ |
|
# Crossed the high critical threshold. This should always be unset because it |
|
# is a new variable, but check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_high_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0060"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_physical_drive_temperature > $high_warning) |
|
{ |
|
# Crossed the high warning threshold. This should always be unset because it |
|
# is a new variable, but check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_high_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0061"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_physical_drive_temperature < $low_critical) |
|
{ |
|
# Dropped below the low critical threshold. This should always be unset |
|
# because it is a new variable, but check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_low_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0062"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_physical_drive_temperature < $low_warning) |
|
{ |
|
# Crossed the low warning threshold. This should always be unset because it |
|
# is a new variable, but check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":physical_drive_low_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0063"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
|
|
# Record this for later processing into the 'temperature' table. |
|
my $sensor_host_key = "physical_drive:".$scan_hpacucli_physical_drive_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { sensor_host_key => $sensor_host_key }}); |
|
|
|
$anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_value_c} = $new_scan_hpacucli_physical_drive_temperature; |
|
$anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_state} = $temperature_state; |
|
$anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_is} = $temperature_is; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new::temperature::scan_hpacucli_physical_drive_temperature::${sensor_host_key}::temperature_value_c" => $anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_value_c}, |
|
"new::temperature::scan_hpacucli_physical_drive_temperature::${sensor_host_key}::temperature_state" => $anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_state}, |
|
"new::temperature::scan_hpacucli_physical_drive_temperature::${sensor_host_key}::temperature_is" => $anvil->data->{new}{temperature}{scan_hpacucli_physical_drive_temperature}{$sensor_host_key}{temperature_is}, |
|
}}); |
|
|
|
if ($message_key) |
|
{ |
|
# Send an alert telling the user that we've found a drive outside nominal |
|
# temperature. Note that we add ' C' to the temperatures so that they get |
|
# translated to '°F' if desired by the reader. |
|
my $variables = { |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
temperature => $new_scan_hpacucli_physical_drive_temperature ? $new_scan_hpacucli_physical_drive_temperature." °C" : "--", |
|
high_critical_temperature => $high_critical." °C", |
|
high_warning_temperature => $high_warning." °C", |
|
low_critical_temperature => $low_critical." °C", |
|
low_warning_temperature => $low_warning." °C", |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => $alert_level, |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
### NOTE: The rest of the alerts will be in the format '- Variable: [$value]'. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0003", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0003", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
} |
|
|
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_physical_drives |
|
( |
|
scan_hpacucli_physical_drive_uuid, |
|
scan_hpacucli_physical_drive_host_uuid, |
|
scan_hpacucli_physical_drive_logical_drive_uuid, |
|
scan_hpacucli_physical_drive_serial_number, |
|
scan_hpacucli_physical_drive_model, |
|
scan_hpacucli_physical_drive_interface, |
|
scan_hpacucli_physical_drive_status, |
|
scan_hpacucli_physical_drive_size, |
|
scan_hpacucli_physical_drive_type, |
|
scan_hpacucli_physical_drive_rpm, |
|
scan_hpacucli_physical_drive_temperature, |
|
scan_hpacucli_physical_drive_last_failure_reason, |
|
scan_hpacucli_physical_drive_port, |
|
scan_hpacucli_physical_drive_box, |
|
scan_hpacucli_physical_drive_bay, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($scan_hpacucli_physical_drive_uuid).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_logical_drive_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_physical_drive_serial_number).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_model).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_interface).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_status).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_size).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_type).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_rpm).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_temperature).", |
|
".$anvil->Database->quote($new_scan_hpacucli_physical_drive_last_failure_reason).", |
|
".$anvil->Database->quote($port).", |
|
".$anvil->Database->quote($box).", |
|
".$anvil->Database->quote($bay).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
|
|
# Process physical drive variables now. Note that there are no temperatures. |
|
foreach my $scan_hpacucli_variable_name (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}}) |
|
{ |
|
my $new_scan_hpacucli_variable_value = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{$scan_hpacucli_variable_name}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan_hpacucli_variable_name" => $scan_hpacucli_variable_name, |
|
"new_scan_hpacucli_variable_value" => $new_scan_hpacucli_variable_value, |
|
}}); |
|
|
|
# Have we seen this variable before? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_variables::scan_hpacucli_variable_uuid::source_table::scan_hpacucli_physical_drives::source_uuid::${scan_hpacucli_physical_drive_uuid}::detail::${scan_hpacucli_variable_name}::scan_hpacucli_variable_uuid" => $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}, |
|
}}); |
|
if ($anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}) |
|
{ |
|
# Exists. Has it changed? |
|
my $scan_hpacucli_variable_uuid = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}; |
|
my $old_scan_hpacucli_variable_value = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_value}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_uuid => $scan_hpacucli_variable_uuid, |
|
old_scan_hpacucli_variable_value => $old_scan_hpacucli_variable_value, |
|
}}); |
|
|
|
# delete this so that we know it was processed. |
|
delete $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}; |
|
|
|
if ($old_scan_hpacucli_variable_value ne $new_scan_hpacucli_variable_value) |
|
{ |
|
# Now update. Alert the user as a warning, these should rarely ever change. |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
variable_name => $scan_hpacucli_variable_name, |
|
old_value => $old_scan_hpacucli_variable_value ? $old_scan_hpacucli_variable_value : "--", |
|
new_value => $new_scan_hpacucli_variable_value ? $new_scan_hpacucli_variable_value : "--", |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0065", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0065", |
|
variables => $variables, |
|
show_header => 0, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# UPDATE |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_variables |
|
SET |
|
scan_hpacucli_variable_value = ".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_variable_uuid = ".$anvil->Database->quote($scan_hpacucli_variable_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
else |
|
{ |
|
# Clear the hash key that was autovivified in the previous check so that it doesn't |
|
# cause a loop when looking for vanished values. |
|
delete $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}; |
|
|
|
# New. Alert the user. |
|
my $variables = { |
|
name => $scan_hpacucli_variable_name, |
|
value => $new_scan_hpacucli_variable_value, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0004", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0004", |
|
variables => $variables, |
|
show_header => 0, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# INSERT |
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_variables |
|
( |
|
scan_hpacucli_variable_uuid, |
|
scan_hpacucli_variable_host_uuid, |
|
scan_hpacucli_variable_source_table, |
|
scan_hpacucli_variable_source_uuid, |
|
scan_hpacucli_variable_is_temperature, |
|
scan_hpacucli_variable_name, |
|
scan_hpacucli_variable_value, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($anvil->Get->uuid()).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
'scan_hpacucli_physical_drives', |
|
".$anvil->Database->quote($scan_hpacucli_physical_drive_uuid).", |
|
FALSE, |
|
".$anvil->Database->quote($scan_hpacucli_variable_name).", |
|
".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
|
|
# Look for vanished variables for this drive. |
|
foreach my $scan_hpacucli_variable_name (sort {$a cmp $b} keys %{$anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}}) |
|
{ |
|
my $old_scan_hpacucli_variable_value = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_value}; |
|
my $old_scan_hpacucli_variable_uuid = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drives}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{detail}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_name => $scan_hpacucli_variable_name, |
|
old_scan_hpacucli_variable_value => $old_scan_hpacucli_variable_value, |
|
old_scan_hpacucli_variable_uuid => $old_scan_hpacucli_variable_uuid, |
|
}}); |
|
|
|
# If the old alarm state is already 'VANISHED', ignore it. |
|
next if $old_scan_hpacucli_variable_value eq "VANISHED"; |
|
|
|
# Still here? Alert and UPDATE. |
|
### NOTE: For now, we're going to use warning level because cache_modules |
|
### should never vanish unless one failed. If that is the case, the |
|
### admin already knows, but this will let other notification targets |
|
### know that the change has happened. |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
name => $scan_hpacucli_variable_name, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0067", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0067", |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_variables |
|
SET |
|
scan_hpacucli_variable_value = 'VANISHED', |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_variable_uuid = ".$anvil->Database->quote($old_scan_hpacucli_variable_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
|
|
# If this was a diagnostics run, check for error counters |
|
if ($anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics}) |
|
{ |
|
# These are stored in the DB as standard variables, but we use the source is |
|
# 'scan_hpacucli_physical_drive_diagnostics' to distinguish them. |
|
if (exists $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_hard}) |
|
{ |
|
# We got the data |
|
foreach my $scan_hpacucli_variable_name (sort {$a cmp $b} keys %{$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}}) |
|
{ |
|
# Store this in the main hash. |
|
my $new_scan_hpacucli_variable_value = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$scan_hpacucli_logical_drive_name}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{'diagnostics'}{$scan_hpacucli_variable_name}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_name => $scan_hpacucli_variable_name, |
|
new_scan_hpacucli_variable_value => $new_scan_hpacucli_variable_value, |
|
}}); |
|
|
|
### TODO |
|
# If the variable name has 'error' in it and the value is numeric, see if it |
|
# is > 5 and, if so, set the health. |
|
|
|
# Have we seen this variable before? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_variables::scan_hpacucli_variable_uuid::source_table::scan_hpacucli_physical_drive_diagnostics::source_uuid::${scan_hpacucli_physical_drive_uuid}::diagnostics::${scan_hpacucli_variable_name}::scan_hpacucli_variable_uuid" => $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}, |
|
}}); |
|
if ($anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}) |
|
{ |
|
# Exists. Has it changed? |
|
my $scan_hpacucli_variable_uuid = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}; |
|
my $old_scan_hpacucli_variable_value = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_value}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_uuid => $scan_hpacucli_variable_uuid, |
|
old_scan_hpacucli_variable_value => $old_scan_hpacucli_variable_value, |
|
}}); |
|
|
|
# Delete this so that we know it was processed. |
|
delete $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}; |
|
|
|
if ($old_scan_hpacucli_variable_value ne $new_scan_hpacucli_variable_value) |
|
{ |
|
# Now update. Alert the user as a warning, these should rarely ever change. |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
variable_name => $scan_hpacucli_variable_name, |
|
old_value => $old_scan_hpacucli_variable_value ? $old_scan_hpacucli_variable_value : "--", |
|
new_value => $new_scan_hpacucli_variable_value ? $new_scan_hpacucli_variable_value : "--", |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0065", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0065", |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# UPDATE |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_variables |
|
SET |
|
scan_hpacucli_variable_value = ".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_variable_uuid = ".$anvil->Database->quote($scan_hpacucli_variable_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
else |
|
{ |
|
# Clear the hash key that was autovivified in the previous check so |
|
# that it doesn't cause a loop when looking for vanished values. |
|
delete $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}; |
|
|
|
# New. Alert the user. |
|
my $variables = { |
|
name => $scan_hpacucli_variable_name, |
|
value => $new_scan_hpacucli_variable_value, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0004", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0004", |
|
show_header => 0, |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# INSERT |
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_variables |
|
( |
|
scan_hpacucli_variable_uuid, |
|
scan_hpacucli_variable_host_uuid, |
|
scan_hpacucli_variable_source_table, |
|
scan_hpacucli_variable_source_uuid, |
|
scan_hpacucli_variable_is_temperature, |
|
scan_hpacucli_variable_name, |
|
scan_hpacucli_variable_value, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($anvil->Get->uuid()).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
'scan_hpacucli_physical_drive_diagnostics', |
|
".$anvil->Database->quote($scan_hpacucli_physical_drive_uuid).", |
|
FALSE, |
|
".$anvil->Database->quote($scan_hpacucli_variable_name).", |
|
".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
} |
|
|
|
# Look for vanished diagnostics variables. |
|
foreach my $scan_hpacucli_variable_name (sort {$a cmp $b} keys %{$anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}}) |
|
{ |
|
my $old_scan_hpacucli_variable_value = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_value}; |
|
my $old_scan_hpacucli_variable_uuid = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_physical_drive_diagnostics}{source_uuid}{$scan_hpacucli_physical_drive_uuid}{'diagnostics'}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_name => $scan_hpacucli_variable_name, |
|
old_scan_hpacucli_variable_value => $old_scan_hpacucli_variable_value, |
|
old_scan_hpacucli_variable_uuid => $old_scan_hpacucli_variable_uuid, |
|
}}); |
|
|
|
# If the old alarm state is already 'VANISHED', ignore it. |
|
next if $old_scan_hpacucli_variable_value eq "VANISHED"; |
|
|
|
# Still here? Alert and UPDATE. |
|
### NOTE: For now, we're going to use warning level because cache_modules |
|
### should never vanish unless one failed. If that is the case, the |
|
### admin already knows, but this will let other notification targets |
|
### know that the change has happened. |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
name => $scan_hpacucli_variable_name, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0068", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0068", |
|
show_header => 1, |
|
variables => $variables, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_variables |
|
SET |
|
scan_hpacucli_variable_value = 'VANISHED', |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_variable_uuid = ".$anvil->Database->quote($old_scan_hpacucli_variable_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
# Look for added, changed or deleted controllers. |
|
sub process_controllers |
|
{ |
|
my ($anvil) = @_; |
|
|
|
# Look for new, changed or deleted controllers. |
|
$anvil->data->{'scan-hpacucli'}{queries} = []; |
|
|
|
foreach my $scan_hpacucli_controller_serial_number (sort {$a cmp $b} keys %{$anvil->data->{controller}}) |
|
{ |
|
# Controller data; |
|
next if $scan_hpacucli_controller_serial_number eq "metadata"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
"scan-hpacucli::controllers::by_serial::$scan_hpacucli_controller_serial_number" => $anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number}, |
|
}}); |
|
|
|
# Have we seen this controller before? |
|
my $scan_hpacucli_controller_uuid = ""; |
|
my $controller_is_new = 0; |
|
if ($anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number}) |
|
{ |
|
# Yup! |
|
$scan_hpacucli_controller_uuid = $anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_controller_uuid => $scan_hpacucli_controller_uuid }}); |
|
} |
|
else |
|
{ |
|
# No, this is a new controller. Create a new UUID for it. |
|
$scan_hpacucli_controller_uuid = $anvil->Get->uuid(); |
|
$controller_is_new = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_controller_uuid => $scan_hpacucli_controller_uuid, |
|
controller_is_new => $controller_is_new, |
|
}}); |
|
|
|
# Add the keys for looking it up by UUID or serial number. |
|
$anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number} = $scan_hpacucli_controller_uuid; |
|
$anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$scan_hpacucli_controller_uuid} = $scan_hpacucli_controller_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::controllers::by_serial::$scan_hpacucli_controller_serial_number" => $anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number}, |
|
"scan-hpacucli::controllers::by_uuid::$scan_hpacucli_controller_uuid" => $anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$scan_hpacucli_controller_uuid}, |
|
}}); |
|
} |
|
|
|
# These are the values for the controller and cache tables. Anything else will go in the |
|
# variables table which will be processed after the controller. |
|
# Controller |
|
my $new_scan_hpacucli_controller_model = ""; |
|
my $new_scan_hpacucli_controller_status = ""; |
|
my $new_scan_hpacucli_controller_last_diagnostics = $anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics} ? time : ""; |
|
my $new_scan_hpacucli_controller_cache_present = "unknown"; |
|
my $new_scan_hpacucli_controller_drive_write_cache = ""; |
|
my $new_scan_hpacucli_controller_firmware_version = ""; |
|
my $new_scan_hpacucli_controller_unsafe_writeback_cache = ""; |
|
|
|
# Cache |
|
my $new_scan_hpacucli_cache_module_size = ""; |
|
my $new_scan_hpacucli_cache_module_serial_number = ""; |
|
my $new_scan_hpacucli_cache_module_status = ""; |
|
my $new_scan_hpacucli_cache_module_type = ""; |
|
|
|
foreach my $type ("detail", "temperature") |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { type => $type }}); |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}}) |
|
{ |
|
# Pick up the variables for the controller |
|
if (($type eq "detail") && ($variable eq "model_name")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_controller_model = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_controller_model => $new_scan_hpacucli_controller_model }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "controller_status")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_controller_status = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$new_scan_hpacucli_controller_status = lc($new_scan_hpacucli_controller_status); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_controller_status => $new_scan_hpacucli_controller_status }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "cache_board_present")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_controller_cache_present = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$new_scan_hpacucli_controller_cache_present = lc($new_scan_hpacucli_controller_cache_present); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_controller_cache_present => $new_scan_hpacucli_controller_cache_present }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "drive_write_cache")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_controller_drive_write_cache = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$new_scan_hpacucli_controller_drive_write_cache = lc($new_scan_hpacucli_controller_drive_write_cache); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_controller_drive_write_cache => $new_scan_hpacucli_controller_drive_write_cache }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "firmware_version")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_controller_firmware_version = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_controller_firmware_version => $new_scan_hpacucli_controller_firmware_version }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "no_battery_write_cache")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_controller_unsafe_writeback_cache = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$new_scan_hpacucli_controller_unsafe_writeback_cache = lc($new_scan_hpacucli_controller_unsafe_writeback_cache); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_controller_unsafe_writeback_cache => $new_scan_hpacucli_controller_unsafe_writeback_cache }}); |
|
next; |
|
} |
|
# Pick up the data for the cache. |
|
elsif (($type eq "detail") && ($variable eq "total_cache_size")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_cache_module_size = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_cache_module_size => $new_scan_hpacucli_cache_module_size }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "cache_serial_number")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_cache_module_serial_number = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_cache_module_serial_number => $new_scan_hpacucli_cache_module_serial_number }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "cache_status")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_cache_module_status = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$new_scan_hpacucli_cache_module_status = lc($new_scan_hpacucli_cache_module_status); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_cache_module_status => $new_scan_hpacucli_cache_module_status }}); |
|
next; |
|
} |
|
elsif (($type eq "detail") && ($variable eq "cache_backup_power_source")) |
|
{ |
|
# Store and delete the value |
|
$new_scan_hpacucli_cache_module_type = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
$new_scan_hpacucli_cache_module_type = lc($new_scan_hpacucli_cache_module_type); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { new_scan_hpacucli_cache_module_type => $new_scan_hpacucli_cache_module_type }}); |
|
next; |
|
} |
|
else |
|
{ |
|
# Just for debug |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::data::${type}::${variable}" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}, |
|
}}); |
|
} |
|
} |
|
} |
|
|
|
# Pull out the rest of the variables now. If the controller is new, all variables will be |
|
# INSERTed. If the controller exists, each variable will be examined and new ones will be |
|
# INSERTed, existing ones will be checked for changes and UPDATEd as needed. If the |
|
# controller is NOT new, then variables from the old data will be deleted as we go and any |
|
# not found in the current data set will be left over. We'll use this to determine variables |
|
# that have vanished. They will not be deleted, but their value will be set to 'VANISHED'. |
|
if ($controller_is_new) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
new_scan_hpacucli_controller_model => $new_scan_hpacucli_controller_model, |
|
new_scan_hpacucli_controller_cache_present => $new_scan_hpacucli_controller_cache_present, |
|
new_scan_hpacucli_controller_drive_write_cache => $new_scan_hpacucli_controller_drive_write_cache, |
|
new_scan_hpacucli_controller_firmware_version => $new_scan_hpacucli_controller_firmware_version, |
|
new_scan_hpacucli_controller_unsafe_writeback_cache => $new_scan_hpacucli_controller_unsafe_writeback_cache, |
|
}}); |
|
|
|
# Send an alert telling the user that we've found a new controller. |
|
my $variables = { |
|
model => $new_scan_hpacucli_controller_model, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
status => $new_scan_hpacucli_controller_status, |
|
drive_write_cache => $new_scan_hpacucli_controller_drive_write_cache, |
|
firmware_version => $new_scan_hpacucli_controller_firmware_version, |
|
unsafe_writeback_cache => $new_scan_hpacucli_controller_unsafe_writeback_cache, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0001", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0001", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# INSERT |
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_controllers |
|
( |
|
scan_hpacucli_controller_uuid, |
|
scan_hpacucli_controller_host_uuid, |
|
scan_hpacucli_controller_serial_number, |
|
scan_hpacucli_controller_model, |
|
scan_hpacucli_controller_status, |
|
scan_hpacucli_controller_last_diagnostics, |
|
scan_hpacucli_controller_cache_present, |
|
scan_hpacucli_controller_drive_write_cache, |
|
scan_hpacucli_controller_firmware_version, |
|
scan_hpacucli_controller_unsafe_writeback_cache, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($scan_hpacucli_controller_uuid).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_controller_serial_number).", |
|
".$anvil->Database->quote($new_scan_hpacucli_controller_model).", |
|
".$anvil->Database->quote($new_scan_hpacucli_controller_status).", |
|
".$anvil->Database->quote($new_scan_hpacucli_controller_last_diagnostics).", |
|
".$anvil->Database->quote($new_scan_hpacucli_controller_cache_present).", |
|
".$anvil->Database->quote($new_scan_hpacucli_controller_drive_write_cache).", |
|
".$anvil->Database->quote($new_scan_hpacucli_controller_firmware_version).", |
|
".$anvil->Database->quote($new_scan_hpacucli_controller_unsafe_writeback_cache).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
else |
|
{ |
|
### NOTE: The serial number and model should never change (a changed SN/controller |
|
### should be picked up as a new controller), but we check/update just to be |
|
### safe. |
|
# Controller already exists, check for changes. |
|
my $old_scan_hpacucli_controller_serial_number = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_serial_number}; |
|
my $old_scan_hpacucli_controller_model = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_model}; |
|
my $old_scan_hpacucli_controller_status = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_status}; |
|
my $old_scan_hpacucli_controller_last_diagnostics = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_last_diagnostics}; |
|
my $old_scan_hpacucli_controller_cache_present = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_cache_present}; |
|
my $old_scan_hpacucli_controller_drive_write_cache = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_drive_write_cache}; |
|
my $old_scan_hpacucli_controller_firmware_version = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_firmware_version}; |
|
my $old_scan_hpacucli_controller_unsafe_writeback_cache = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_unsafe_writeback_cache}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
old_scan_hpacucli_controller_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
old_scan_hpacucli_controller_model => $old_scan_hpacucli_controller_model, |
|
old_scan_hpacucli_controller_status => $old_scan_hpacucli_controller_status, |
|
old_scan_hpacucli_controller_last_diagnostics => $old_scan_hpacucli_controller_last_diagnostics, |
|
old_scan_hpacucli_controller_cache_present => $old_scan_hpacucli_controller_cache_present, |
|
old_scan_hpacucli_controller_drive_write_cache => $old_scan_hpacucli_controller_drive_write_cache, |
|
old_scan_hpacucli_controller_firmware_version => $old_scan_hpacucli_controller_firmware_version, |
|
old_scan_hpacucli_controller_unsafe_writeback_cache => $old_scan_hpacucli_controller_unsafe_writeback_cache, |
|
}}); |
|
|
|
# Delete this from the old cache. |
|
delete $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}; |
|
|
|
# NOTE: We don't check if the last diagnostics changed because it will change every |
|
# 10 minutes or so. |
|
if (($scan_hpacucli_controller_serial_number ne $old_scan_hpacucli_controller_serial_number) or |
|
($new_scan_hpacucli_controller_model ne $old_scan_hpacucli_controller_model) or |
|
($new_scan_hpacucli_controller_status ne $old_scan_hpacucli_controller_status) or |
|
($new_scan_hpacucli_controller_cache_present ne $old_scan_hpacucli_controller_cache_present) or |
|
($new_scan_hpacucli_controller_drive_write_cache ne $old_scan_hpacucli_controller_drive_write_cache) or |
|
($new_scan_hpacucli_controller_firmware_version ne $old_scan_hpacucli_controller_firmware_version) or |
|
($new_scan_hpacucli_controller_unsafe_writeback_cache ne $old_scan_hpacucli_controller_unsafe_writeback_cache)) |
|
{ |
|
# Send a warning level alert because the most likely change is 'status'. If, |
|
# however, the status is now 'ok', then we'll clear the alert. |
|
my $cleared = 0; |
|
my $message_key = "scan_hpacucli_warning_0002"; |
|
if ($new_scan_hpacucli_controller_status ne $old_scan_hpacucli_controller_status) |
|
{ |
|
if (($new_scan_hpacucli_controller_status ne $old_scan_hpacucli_controller_status) && ($old_scan_hpacucli_controller_status eq "VANISHED")) |
|
{ |
|
# Controller has returned. |
|
$message_key = "scan_hpacucli_warning_0003"; |
|
} |
|
if (($new_scan_hpacucli_controller_status ne $old_scan_hpacucli_controller_status) && ($new_scan_hpacucli_controller_status =~ /ok/i)) |
|
{ |
|
# Clear the alert, the controller is OK again. |
|
$cleared = 1; |
|
} |
|
} |
|
|
|
my $variables = { |
|
new_serial_number => $scan_hpacucli_controller_serial_number, |
|
old_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
new_model_name => $new_scan_hpacucli_controller_model, |
|
old_model_name => $old_scan_hpacucli_controller_model, |
|
new_status => $new_scan_hpacucli_controller_status, |
|
old_status => $old_scan_hpacucli_controller_status, |
|
new_cache_present => $new_scan_hpacucli_controller_cache_present, |
|
old_cache_present => $old_scan_hpacucli_controller_cache_present, |
|
new_drive_write_cache => $new_scan_hpacucli_controller_drive_write_cache, |
|
old_drive_write_cache => $old_scan_hpacucli_controller_drive_write_cache, |
|
new_firmware_version => $new_scan_hpacucli_controller_firmware_version, |
|
old_firmware_version => $old_scan_hpacucli_controller_firmware_version, |
|
new_unsafe_writeback_cache => $new_scan_hpacucli_controller_unsafe_writeback_cache, |
|
old_unsafe_writeback_cache => $old_scan_hpacucli_controller_unsafe_writeback_cache, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => "warning", |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_controllers |
|
SET |
|
scan_hpacucli_controller_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
scan_hpacucli_controller_serial_number = ".$anvil->Database->quote($scan_hpacucli_controller_serial_number).", |
|
scan_hpacucli_controller_model = ".$anvil->Database->quote($new_scan_hpacucli_controller_model).", |
|
scan_hpacucli_controller_status = ".$anvil->Database->quote($new_scan_hpacucli_controller_status).", |
|
scan_hpacucli_controller_cache_present = ".$anvil->Database->quote($new_scan_hpacucli_controller_cache_present).", |
|
scan_hpacucli_controller_drive_write_cache = ".$anvil->Database->quote($new_scan_hpacucli_controller_drive_write_cache).", |
|
scan_hpacucli_controller_firmware_version = ".$anvil->Database->quote($new_scan_hpacucli_controller_firmware_version).", |
|
scan_hpacucli_controller_unsafe_writeback_cache = ".$anvil->Database->quote($new_scan_hpacucli_controller_unsafe_writeback_cache).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_controller_uuid = ".$anvil->Database->quote($scan_hpacucli_controller_uuid)." |
|
;"; |
|
|
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
|
|
# Now, if we had a cache module on this controller, see if we knew about it already. |
|
my $scan_hpacucli_cache_module_uuid = ""; |
|
my $cache_is_new = 0; |
|
if ($new_scan_hpacucli_cache_module_serial_number) |
|
{ |
|
if ($anvil->data->{'scan-hpacucli'}{cache_modules}{by_serial}{$new_scan_hpacucli_cache_module_serial_number}) |
|
{ |
|
# Yup! |
|
$scan_hpacucli_cache_module_uuid = $anvil->data->{'scan-hpacucli'}{cache_modules}{by_serial}{$new_scan_hpacucli_cache_module_serial_number}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_cache_module_uuid => $scan_hpacucli_cache_module_uuid }}); |
|
} |
|
else |
|
{ |
|
# No, this is a new cache module. Create a new UUID for it. |
|
$scan_hpacucli_cache_module_uuid = $anvil->Get->uuid(); |
|
$cache_is_new = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_cache_module_uuid => $scan_hpacucli_cache_module_uuid, |
|
cache_is_new => $cache_is_new, |
|
}}); |
|
|
|
# Add the keys for looking it up by UUID or serial number. |
|
$anvil->data->{'scan-hpacucli'}{cache_modules}{by_serial}{$new_scan_hpacucli_cache_module_serial_number} = $scan_hpacucli_cache_module_uuid; |
|
$anvil->data->{'scan-hpacucli'}{cache_modules}{by_uuid}{$scan_hpacucli_cache_module_uuid} = $new_scan_hpacucli_cache_module_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::cache_modules::by_serial::$new_scan_hpacucli_cache_module_serial_number" => $anvil->data->{'scan-hpacucli'}{cache_modules}{by_serial}{$new_scan_hpacucli_cache_module_serial_number}, |
|
"scan-hpacucli::cache_modules::by_uuid::$scan_hpacucli_cache_module_uuid" => $anvil->data->{'scan-hpacucli'}{cache_modules}{by_uuid}{$scan_hpacucli_cache_module_uuid}, |
|
}}); |
|
} |
|
|
|
if ($cache_is_new) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_cache_module_uuid => $scan_hpacucli_cache_module_uuid, |
|
new_scan_hpacucli_cache_module_size => $new_scan_hpacucli_cache_module_size." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_cache_module_size}).")", |
|
new_scan_hpacucli_cache_module_serial_number => $new_scan_hpacucli_cache_module_serial_number, |
|
new_scan_hpacucli_cache_module_status => $new_scan_hpacucli_cache_module_status, |
|
new_scan_hpacucli_cache_module_type => $new_scan_hpacucli_cache_module_type, |
|
}}); |
|
|
|
# Send an alert telling the user that we've found a new controller. |
|
my $variables = { |
|
serial_number => $new_scan_hpacucli_cache_module_serial_number, |
|
cache_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_cache_module_size}), |
|
status => $new_scan_hpacucli_cache_module_status, |
|
type => $new_scan_hpacucli_cache_module_type, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0002", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0002", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
### NOTE: The rest of the alerts will be in the format '- Variable: [$value]'. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_note_0003"}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "notice", |
|
message => "scan_hpacucli_note_0003", |
|
variables => {}, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# INSERT |
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_cache_modules |
|
( |
|
scan_hpacucli_cache_module_uuid, |
|
scan_hpacucli_cache_module_host_uuid, |
|
scan_hpacucli_cache_module_controller_uuid, |
|
scan_hpacucli_cache_module_serial_number, |
|
scan_hpacucli_cache_module_status, |
|
scan_hpacucli_cache_module_type, |
|
scan_hpacucli_cache_module_size, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($scan_hpacucli_cache_module_uuid).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
".$anvil->Database->quote($scan_hpacucli_controller_uuid).", |
|
".$anvil->Database->quote($new_scan_hpacucli_cache_module_serial_number).", |
|
".$anvil->Database->quote($new_scan_hpacucli_cache_module_status).", |
|
".$anvil->Database->quote($new_scan_hpacucli_cache_module_type).", |
|
".$anvil->Database->quote($new_scan_hpacucli_cache_module_size).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
else |
|
{ |
|
# Exists already, look for changes. The serial number should never change, |
|
# buuuut... |
|
my $old_scan_hpacucli_cache_module_controller_uuid = $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_controller_uuid}; |
|
my $old_scan_hpacucli_cache_module_serial_number = $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_serial_number}; |
|
my $old_scan_hpacucli_cache_module_status = $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_status}; |
|
my $old_scan_hpacucli_cache_module_type = $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_type}; |
|
my $old_scan_hpacucli_cache_module_size = $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_size}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
old_scan_hpacucli_cache_module_controller_uuid => $old_scan_hpacucli_cache_module_controller_uuid, |
|
old_scan_hpacucli_cache_module_serial_number => $old_scan_hpacucli_cache_module_serial_number, |
|
old_scan_hpacucli_cache_module_status => $old_scan_hpacucli_cache_module_status, |
|
old_scan_hpacucli_cache_module_type => $old_scan_hpacucli_cache_module_type, |
|
old_scan_hpacucli_cache_module_size => $old_scan_hpacucli_cache_module_size, |
|
}}); |
|
|
|
# Delete this so we know we saw it. |
|
delete $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}; |
|
|
|
if (($scan_hpacucli_controller_uuid ne $old_scan_hpacucli_cache_module_controller_uuid) or |
|
($new_scan_hpacucli_cache_module_serial_number ne $old_scan_hpacucli_cache_module_serial_number) or |
|
($new_scan_hpacucli_cache_module_status ne $old_scan_hpacucli_cache_module_status) or |
|
($new_scan_hpacucli_cache_module_type ne $old_scan_hpacucli_cache_module_type) or |
|
($new_scan_hpacucli_cache_module_size ne $old_scan_hpacucli_cache_module_size)) |
|
{ |
|
# Something has changed, but what? Any change is likely bad, so we |
|
# default to 'warning'. |
|
my $cleared = 0; |
|
my $message_key = "scan_hpacucli_warning_0004"; |
|
|
|
# Did the status return to 'ok'? |
|
if (($old_scan_hpacucli_cache_module_status ne $new_scan_hpacucli_cache_module_status) && ($old_scan_hpacucli_cache_module_status eq "VANISHED")) |
|
{ |
|
# The cache module is back |
|
$message_key = "scan_hpacucli_warning_0005"; |
|
} |
|
elsif (($old_scan_hpacucli_cache_module_status ne $new_scan_hpacucli_cache_module_status) && ($new_scan_hpacucli_cache_module_status eq "ok")) |
|
{ |
|
# The status is good now, clear the alert |
|
$cleared = 1; |
|
} |
|
|
|
# Convert the old controller UUID to a serial number. |
|
my $query = "SELECT scan_hpacucli_controller_serial_number FROM scan_hpacucli_controllers WHERE scan_hpacucli_controller_uuid = ".$anvil->Database->quote($old_scan_hpacucli_cache_module_controller_uuid).";"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
my $old_scan_hpacucli_controller_serial_number = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__})->[0]->[0]; |
|
$old_scan_hpacucli_controller_serial_number = "--" if not defined $old_scan_hpacucli_controller_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { old_scan_hpacucli_controller_serial_number => $old_scan_hpacucli_controller_serial_number }}); |
|
|
|
# Send the alert |
|
my $variables = { |
|
old_serial_number => $old_scan_hpacucli_cache_module_serial_number, |
|
new_serial_number => $new_scan_hpacucli_cache_module_serial_number, |
|
old_scan_hpacucli_controller_serial_number => $old_scan_hpacucli_controller_serial_number, |
|
new_controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
old_status => $old_scan_hpacucli_cache_module_status, |
|
new_status => $old_scan_hpacucli_cache_module_status, |
|
old_type => $new_scan_hpacucli_cache_module_type, |
|
new_type => $old_scan_hpacucli_cache_module_type, |
|
say_old_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hpacucli_cache_module_size}), |
|
say_new_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hpacucli_cache_module_size}), |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0002", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => "warning", |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
### NOTE: The rest of the alerts will be in the format '- Variable: [$value]'. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0003"}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0003", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# Update the database. |
|
$query = " |
|
UPDATE |
|
scan_hpacucli_cache_modules |
|
SET |
|
scan_hpacucli_cache_module_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
scan_hpacucli_cache_module_controller_uuid = ".$anvil->Database->quote($scan_hpacucli_controller_uuid).", |
|
scan_hpacucli_cache_module_serial_number = ".$anvil->Database->quote($new_scan_hpacucli_cache_module_serial_number).", |
|
scan_hpacucli_cache_module_status = ".$anvil->Database->quote($new_scan_hpacucli_cache_module_status).", |
|
scan_hpacucli_cache_module_type = ".$anvil->Database->quote($new_scan_hpacucli_cache_module_type).", |
|
scan_hpacucli_cache_module_size = ".$anvil->Database->quote($new_scan_hpacucli_cache_module_size).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_cache_module_uuid = ".$anvil->Database->quote($scan_hpacucli_cache_module_uuid)." |
|
;"; |
|
|
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
} |
|
|
|
# We do this after the cache so that the alerts make since when a new controller is found. |
|
foreach my $type ("detail", "temperature") |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { type => $type }}); |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}}) |
|
{ |
|
my $new_scan_hpacucli_variable_value = delete $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}; |
|
my $temperature = $type eq "temperature" ? "TRUE" : "FALSE"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
variable => $variable, |
|
new_scan_hpacucli_variable_value => $new_scan_hpacucli_variable_value, |
|
temperature => $temperature, |
|
}}); |
|
|
|
# Now, if the variable doesn't exist, INSERT it. If it does exist, see if it |
|
# changed and UPDATE it if so. |
|
if (exists $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}{$scan_hpacucli_controller_uuid}{$type}{$variable}) |
|
{ |
|
# Look for changes |
|
my $old_scan_hpacucli_variable_value = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}{$scan_hpacucli_controller_uuid}{$type}{$variable}{scan_hpacucli_variable_value}; |
|
my $variable_uuid = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}{$scan_hpacucli_controller_uuid}{$type}{$variable}{scan_hpacucli_variable_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
new_scan_hpacucli_variable_value => $new_scan_hpacucli_variable_value, |
|
old_scan_hpacucli_variable_value => $old_scan_hpacucli_variable_value, |
|
variable_uuid => $variable_uuid, |
|
}}); |
|
|
|
# Delete it so that we know it has been processed. |
|
delete $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}{$scan_hpacucli_controller_uuid}{$type}{$variable}; |
|
|
|
# Set defaults |
|
my $high_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{high_critical}; |
|
my $high_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{high_warning}; |
|
my $low_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{low_warning}; |
|
my $low_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{low_critical}; |
|
my $jump = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{jump}; |
|
my $buffer = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{buffer}; |
|
my $clear_high_critical = $high_critical - $buffer; |
|
my $clear_high_warning = $high_warning - $buffer; |
|
my $clear_low_critical = $low_critical - $buffer; |
|
my $clear_low_warning = $low_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
high_critical => $high_critical, |
|
high_warning => $high_warning, |
|
low_warning => $low_warning, |
|
low_critical => $low_critical, |
|
jump => $jump, |
|
buffer => $buffer, |
|
clear_high_critical => $clear_high_critical, |
|
clear_high_warning => $clear_high_warning, |
|
clear_low_critical => $clear_low_critical, |
|
clear_low_warning => $clear_low_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
|
|
# Does this variable have defined limits? |
|
if (exists $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{high_critical}) |
|
{ |
|
$high_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{high_critical}; |
|
$high_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{high_warning}; |
|
$low_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{low_warning}; |
|
$low_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{low_critical}; |
|
$jump = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{jump}; |
|
$buffer = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{buffer}; |
|
$clear_high_critical = $high_critical - $buffer; |
|
$clear_high_warning = $high_warning - $buffer; |
|
$clear_low_critical = $low_critical - $buffer; |
|
$clear_low_warning = $low_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
high_critical => $high_critical, |
|
high_warning => $high_warning, |
|
low_warning => $low_warning, |
|
low_critical => $low_critical, |
|
jump => $jump, |
|
buffer => $buffer, |
|
clear_high_critical => $clear_high_critical, |
|
clear_high_warning => $clear_high_warning, |
|
clear_low_critical => $clear_low_critical, |
|
clear_low_warning => $clear_low_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
} |
|
|
|
# If it's a temperature, we need to analyze it and store it, |
|
# regardless of if it changed this pass. |
|
my $cleared = 0; |
|
my $temperature_state = "ok"; |
|
my $temperature_is = "nominal"; |
|
my $message_key = "scan_hpacucli_note_0009"; |
|
my $alert_level = "notice"; |
|
my $delta = 0; |
|
if ($type eq "temperature") |
|
{ |
|
# Change the log level to info as temperatures change often. |
|
$alert_level = "info"; |
|
|
|
# Now see if the temperature has crossed into a |
|
# warning or critical state. |
|
if ($new_scan_hpacucli_variable_value > $high_critical) |
|
{ |
|
# Crossed the high critical threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_high_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0005"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_variable_value > $high_warning) |
|
{ |
|
# Crossed the high warning threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_high_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0006"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_variable_value < $low_critical) |
|
{ |
|
# Dropped below the low critical threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_low_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0007"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_variable_value < $low_warning) |
|
{ |
|
# Crossed the low warning threshold. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_low_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0008"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
else |
|
{ |
|
# Did it change enough to trigger a jump |
|
# alert? |
|
if ($new_scan_hpacucli_variable_value > $old_scan_hpacucli_variable_value) |
|
{ |
|
# Jumped |
|
$delta = $new_scan_hpacucli_variable_value - $old_scan_hpacucli_variable_value; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { delta => $delta }}); |
|
if ($delta >= $jump) |
|
{ |
|
# Big jump. |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0015"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
else |
|
{ |
|
# Dropped |
|
$delta = $old_scan_hpacucli_variable_value - $new_scan_hpacucli_variable_value; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { delta => $delta }}); |
|
if ($delta >= $jump) |
|
{ |
|
# Big drop. |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0016"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
} |
|
|
|
# Record this for later processing into the 'temperature' |
|
# table. |
|
my $sensor_host_key = "controller:$scan_hpacucli_controller_serial_number"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { sensor_host_key => $sensor_host_key }}); |
|
|
|
$anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_value_c} = $new_scan_hpacucli_variable_value; |
|
$anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_state} = $temperature_state; |
|
$anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_is} = $temperature_is; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new::temperature::${variable}::${sensor_host_key}::temperature_value_c" => $anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_value_c}, |
|
"new::temperature::${variable}::${sensor_host_key}::temperature_state" => $anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_state}, |
|
"new::temperature::${variable}::${sensor_host_key}::temperature_is" => $anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_is}, |
|
}}); |
|
} |
|
|
|
# Did the variable change? |
|
if ($new_scan_hpacucli_variable_value ne $old_scan_hpacucli_variable_value) |
|
{ |
|
# How has it changed? |
|
if ($old_scan_hpacucli_variable_value eq "VANISHED") |
|
{ |
|
$message_key = "scan_hpacucli_note_0010"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { message_key => $message_key }}); |
|
} |
|
elsif ($type eq "temperature") |
|
{ |
|
|
|
# Clear alerts, if needed. The order is important as |
|
# clearing a warning will replace clearing a critical |
|
# when a sensor goes critical -> ok in one scan. Once |
|
# done, we'll check if we've crossed into a warning |
|
# or critical state. If so, those will replace any |
|
# cleared messages. |
|
if ($new_scan_hpacucli_variable_value < $clear_high_critical) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_high_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$cleared = 1; |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0011"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
if ($new_scan_hpacucli_variable_value < $clear_high_warning) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_high_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
# The temperature is no longer |
|
# warning, and it didn't just go |
|
# critical |
|
$cleared = 1; |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0012"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
if ($new_scan_hpacucli_variable_value > $clear_low_critical) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_low_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$cleared = 1; |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0013"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
if ($new_scan_hpacucli_variable_value > $clear_low_warning) |
|
{ |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 1, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_low_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$cleared = 1; |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0014"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
cleared => $cleared, |
|
alert_level => $alert_level, |
|
message_key => $message_key, |
|
}}); |
|
} |
|
} |
|
} |
|
|
|
# Send an alert telling the user that we've found a variable for this |
|
# controller. Note that we add ' C' to the temperatures so that they get |
|
# translated to '°F' if desired by the reader. |
|
my $variables = { |
|
sensor_name => $variable, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
name => $variable, |
|
old_value => $type eq "temperature" ? $old_scan_hpacucli_variable_value." °C" : $old_scan_hpacucli_variable_value, |
|
new_value => $type eq "temperature" ? $new_scan_hpacucli_variable_value." °C" : $new_scan_hpacucli_variable_value, |
|
high_critical_temperature => $high_critical." °C", |
|
high_warning_temperature => $high_warning." °C", |
|
low_critical_temperature => $low_critical." °C", |
|
low_warning_temperature => $low_warning." °C", |
|
delta => $delta, |
|
}; |
|
my $log_level = (($alert_level eq "warning") or ($alert_level eq "critical")) ? 1 : 2; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => $log_level, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => $cleared, |
|
alert_level => $alert_level, |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# UPDATE |
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_variables |
|
SET |
|
scan_hpacucli_variable_value = ".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_variable_uuid = ".$anvil->Database->quote($variable_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
else |
|
{ |
|
# New, record. |
|
my $message_key = "scan_hpacucli_note_0004"; |
|
my $alert_level = "notice"; |
|
|
|
# Set defaults |
|
my $high_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{high_critical}; |
|
my $high_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{high_warning}; |
|
my $low_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{low_warning}; |
|
my $low_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{low_critical}; |
|
my $jump = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{jump}; |
|
my $buffer = $anvil->data->{'scan-hpacucli'}{thresholds}{'default'}{buffer}; |
|
my $clear_high_critical = $high_critical - $buffer; |
|
my $clear_high_warning = $high_warning - $buffer; |
|
my $clear_low_critical = $low_critical - $buffer; |
|
my $clear_low_warning = $low_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"high_critical" => $high_critical, |
|
"high_warning" => $high_warning, |
|
"low_warning" => $low_warning, |
|
"low_critical" => $low_critical, |
|
"jump" => $jump, |
|
"buffer" => $buffer, |
|
"clear_high_critical" => $clear_high_critical, |
|
"clear_high_warning" => $clear_high_warning, |
|
"clear_low_critical" => $clear_low_critical, |
|
"clear_low_warning" => $clear_low_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
|
|
if ($type eq "temperature") |
|
{ |
|
# Does this variable have defined limits? |
|
if (exists $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{high_critical}) |
|
{ |
|
$high_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{high_critical}; |
|
$high_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{high_warning}; |
|
$low_warning = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{low_warning}; |
|
$low_critical = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{low_critical}; |
|
$jump = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{jump}; |
|
$buffer = $anvil->data->{'scan-hpacucli'}{thresholds}{$variable}{buffer}; |
|
$clear_high_critical = $high_critical - $buffer; |
|
$clear_high_warning = $high_warning - $buffer; |
|
$clear_low_critical = $low_critical - $buffer; |
|
$clear_low_warning = $low_warning - $buffer; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
high_critical => $high_critical, |
|
high_warning => $high_warning, |
|
low_warning => $low_warning, |
|
low_critical => $low_critical, |
|
jump => $jump, |
|
buffer => $buffer, |
|
clear_high_critical => $clear_high_critical, |
|
clear_high_warning => $clear_high_warning, |
|
clear_low_critical => $clear_low_critical, |
|
clear_low_warning => $clear_low_warning, |
|
}}); |
|
|
|
# Fine-tune the alert thresholds |
|
if ($clear_high_critical < $high_warning) |
|
{ |
|
$clear_high_critical = $high_warning + 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_high_critical => $clear_high_critical }}); |
|
} |
|
if ($clear_low_critical > $low_warning) |
|
{ |
|
$clear_low_critical = $low_warning - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { clear_low_critical => $clear_low_critical }}); |
|
} |
|
} |
|
|
|
# This is a temperature, so see if the temperature outside of |
|
# the warning or critical thresholds. This is a new sensor, |
|
# so nothing to compare against. |
|
my $temperature_state = "ok"; |
|
my $temperature_is = "nominal"; |
|
if ($new_scan_hpacucli_variable_value > $high_critical) |
|
{ |
|
# Crossed the high critical threshold. This should |
|
# always be unset because it is a new variable, but |
|
# check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_high_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0005"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_variable_value > $high_warning) |
|
{ |
|
# Crossed the high warning threshold. This should |
|
# always be unset because it is a new variable, but |
|
# check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_high_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0006"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "high"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_variable_value < $low_critical) |
|
{ |
|
# Dropped below the low critical threshold. This |
|
# should always be unset because it is a new |
|
# variable, but check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_low_critical", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "critical"; |
|
$message_key = "scan_hpacucli_note_0007"; |
|
} |
|
$temperature_state = "critical"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"temperature_state" => $temperature_state, |
|
"temperature_is" => $temperature_is, |
|
}}); |
|
} |
|
elsif ($new_scan_hpacucli_variable_value < $low_warning) |
|
{ |
|
# Crossed the low warning threshold. This should |
|
# always be unset because it is a new variable, but |
|
# check anyway. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_controller_serial_number.":".$variable."_low_warning", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
$alert_level = "warning"; |
|
$message_key = "scan_hpacucli_note_0008"; |
|
} |
|
$temperature_state = "warning"; |
|
$temperature_is = "low"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
temperature_state => $temperature_state, |
|
temperature_is => $temperature_is, |
|
}}); |
|
} |
|
|
|
# Record this for later processing into the 'temperature' |
|
# table. |
|
my $sensor_host_key = "controller:".$scan_hpacucli_controller_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { sensor_host_key => $sensor_host_key }}); |
|
|
|
$anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_value_c} = $new_scan_hpacucli_variable_value; |
|
$anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_state} = $temperature_state; |
|
$anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_is} = $temperature_is; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"new::temperature::${variable}::${sensor_host_key}::temperature_value_c" => $anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_value_c}, |
|
"new::temperature::${variable}::${sensor_host_key}::temperature_state" => $anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_state}, |
|
"new::temperature::${variable}::${sensor_host_key}::temperature_is" => $anvil->data->{new}{temperature}{$variable}{$sensor_host_key}{temperature_is}, |
|
}}); |
|
} |
|
|
|
# Send an alert telling the user that we've found a variable for this |
|
# controller. |
|
my $variables = { |
|
sensor_name => $variable, |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
name => $variable, |
|
value => $type eq "temperature" ? $new_scan_hpacucli_variable_value." °C" : $new_scan_hpacucli_variable_value, |
|
high_critical_temperature => $high_critical." °C", |
|
high_warning_temperature => $high_warning." °C", |
|
low_critical_temperature => $low_critical." °C", |
|
low_warning_temperature => $low_warning." °C", |
|
}; |
|
my $log_level = (($alert_level eq "warning") or ($alert_level eq "critical")) ? 1 : 2; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => $log_level, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => $alert_level, |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 0, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
# INSERT |
|
my $query = " |
|
INSERT INTO |
|
scan_hpacucli_variables |
|
( |
|
scan_hpacucli_variable_uuid, |
|
scan_hpacucli_variable_host_uuid, |
|
scan_hpacucli_variable_source_table, |
|
scan_hpacucli_variable_source_uuid, |
|
scan_hpacucli_variable_is_temperature, |
|
scan_hpacucli_variable_name, |
|
scan_hpacucli_variable_value, |
|
modified_date |
|
) VALUES ( |
|
".$anvil->Database->quote($anvil->Get->uuid()).", |
|
".$anvil->Database->quote($anvil->Get->host_uuid).", |
|
'scan_hpacucli_controllers', |
|
".$anvil->Database->quote($scan_hpacucli_controller_uuid).", |
|
".$anvil->Database->quote($temperature).", |
|
".$anvil->Database->quote($variable).", |
|
".$anvil->Database->quote($new_scan_hpacucli_variable_value).", |
|
".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
);"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
} |
|
} |
|
|
|
# Look for removed controllers |
|
foreach my $scan_hpacucli_controller_uuid (keys %{$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}}) |
|
{ |
|
# Controller vanished! |
|
my $old_scan_hpacucli_controller_serial_number = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_serial_number}; |
|
my $old_scan_hpacucli_controller_model = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_model}; |
|
my $old_scan_hpacucli_controller_status = $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_status}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan_hpacucli_controller_uuid" => $scan_hpacucli_controller_uuid, |
|
"old_scan_hpacucli_controller_serial_number" => $old_scan_hpacucli_controller_serial_number, |
|
"old_scan_hpacucli_controller_model" => $old_scan_hpacucli_controller_model, |
|
"old_scan_hpacucli_controller_status" => $old_scan_hpacucli_controller_status, |
|
}}); |
|
|
|
# Delete it so that we know it has been processed. |
|
delete $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}; |
|
|
|
# If the old alarm state is already 'VANISHED', ignore it. |
|
next if $old_scan_hpacucli_controller_status eq "VANISHED"; |
|
|
|
# Still here? Alert and UPDATE. |
|
### NOTE: For now, we're going to use warning level because controllers should never vanish |
|
### unless one failed. If that is the case, the admin already knows, but this will let |
|
### other notification targets know that the change has happened. |
|
my $variables = { |
|
model => $old_scan_hpacucli_controller_model, |
|
serial_number => $old_scan_hpacucli_controller_serial_number, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0017", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0017", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_controllers |
|
SET |
|
scan_hpacucli_controller_status = 'VANISHED', |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_controller_uuid = ".$anvil->Database->quote($scan_hpacucli_controller_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
|
|
# Look for removed cache modules |
|
foreach my $scan_hpacucli_cache_module_uuid (keys %{$anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}}) |
|
{ |
|
# Controller vanished! |
|
my $old_scan_hpacucli_cache_module_serial_number = $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_serial_number}; |
|
my $old_scan_hpacucli_cache_module_status = $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_status}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan_hpacucli_cache_module_uuid" => $scan_hpacucli_cache_module_uuid, |
|
"old_scan_hpacucli_cache_module_serial_number" => $old_scan_hpacucli_cache_module_serial_number, |
|
"old_scan_hpacucli_cache_module_status" => $old_scan_hpacucli_cache_module_status, |
|
}}); |
|
|
|
# Delete it so that we know it has been processed. |
|
delete $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}; |
|
|
|
# If the old alarm state is already 'VANISHED', ignore it. |
|
next if $old_scan_hpacucli_cache_module_status eq "VANISHED"; |
|
|
|
# Still here? Alert and UPDATE. |
|
### NOTE: For now, we're going to use warning level because cache_modules should never vanish |
|
### unless one failed. If that is the case, the admin already knows, but this will let |
|
### other notification targets know that the change has happened. |
|
my $variables = { |
|
serial_number => $old_scan_hpacucli_cache_module_serial_number, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_note_0018", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_note_0018", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_cache_modules |
|
SET |
|
scan_hpacucli_cache_module_status = 'VANISHED', |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_cache_module_uuid = ".$anvil->Database->quote($scan_hpacucli_cache_module_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
|
|
# Look for removed controller variables. |
|
foreach my $scan_hpacucli_controller_uuid (keys %{$anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}}) |
|
{ |
|
# Get the serial numbre for this contrller |
|
my $scan_hpacucli_controller_serial_number = $anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$scan_hpacucli_controller_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan_hpacucli_controller_uuid" => $scan_hpacucli_controller_uuid, |
|
"scan_hpacucli_controller_serial_number" => $scan_hpacucli_controller_serial_number, |
|
}}); |
|
foreach my $type ("detail", "temperature") |
|
{ |
|
foreach my $scan_hpacucli_variable_name (sort {$a cmp $b} keys %{$anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}{$scan_hpacucli_controller_uuid}{$type}}) |
|
{ |
|
my $old_scan_hpacucli_variable_value = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}{$scan_hpacucli_controller_uuid}{$type}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_value}; |
|
my $old_scan_hpacucli_variable_uuid = $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{scan_hpacucli_controllers}{source_uuid}{$scan_hpacucli_controller_uuid}{$type}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"type" => $type, |
|
"scan_hpacucli_variable_name" => $scan_hpacucli_variable_name, |
|
"old_scan_hpacucli_variable_value" => $old_scan_hpacucli_variable_value, |
|
"old_scan_hpacucli_variable_uuid" => $old_scan_hpacucli_variable_uuid, |
|
}}); |
|
|
|
# If the old alarm state is already 'VANISHED', ignore it. |
|
next if $old_scan_hpacucli_variable_value eq "VANISHED"; |
|
|
|
# Still here? Alert and UPDATE. |
|
### NOTE: For now, we're going to use warning level because cache_modules |
|
### should never vanish unless one failed. If that is the case, the |
|
### admin already knows, but this will let other notification targets |
|
### know that the change has happened. |
|
my $message_key = $type eq "temperature" ? "scan_hpacucli_note_0019" : "scan_hpacucli_note_0020"; |
|
my $variables = { |
|
serial_number => $scan_hpacucli_controller_serial_number, |
|
name => $scan_hpacucli_variable_name, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => $message_key, variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => $message_key, |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-ipmitool'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
|
|
my $query = " |
|
UPDATE |
|
scan_hpacucli_variables |
|
SET |
|
scan_hpacucli_variable_value = 'VANISHED', |
|
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)." |
|
WHERE |
|
scan_hpacucli_variable_uuid = ".$anvil->Database->quote($old_scan_hpacucli_variable_uuid)." |
|
;"; |
|
# Now record the query in the array |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
push @{$anvil->data->{'scan-hpacucli'}{queries}}, $query; |
|
} |
|
} |
|
} |
|
|
|
# Now commit the changes. |
|
$anvil->Database->write({query => $anvil->data->{'scan-hpacucli'}{queries}, source => $THIS_FILE, line => __LINE__}); |
|
$anvil->data->{'scan-hpacucli'}{queries} = []; |
|
|
|
return(0); |
|
} |
|
|
|
# This reads in the last scan's data. |
|
sub read_last_scan |
|
{ |
|
my ($anvil) = @_; |
|
|
|
# Read in the controller(s) |
|
my $query = " |
|
SELECT |
|
scan_hpacucli_controller_uuid, |
|
scan_hpacucli_controller_serial_number, |
|
scan_hpacucli_controller_model, |
|
scan_hpacucli_controller_status, |
|
scan_hpacucli_controller_last_diagnostics, |
|
scan_hpacucli_controller_cache_present, |
|
scan_hpacucli_controller_drive_write_cache, |
|
scan_hpacucli_controller_firmware_version, |
|
scan_hpacucli_controller_unsafe_writeback_cache |
|
FROM |
|
scan_hpacucli_controllers |
|
WHERE |
|
scan_hpacucli_controller_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
my $results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
my $count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
foreach my $row (@{$results}) |
|
{ |
|
my $scan_hpacucli_controller_uuid = $row->[0]; |
|
my $scan_hpacucli_controller_serial_number = $row->[1]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_controller_uuid => $scan_hpacucli_controller_uuid, |
|
scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number, |
|
}}); |
|
|
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_serial_number} = $scan_hpacucli_controller_serial_number; |
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_model} = $row->[2]; |
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_status} = $row->[3]; |
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_last_diagnostics} = $row->[4]; |
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_cache_present} = $row->[5]; |
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_drive_write_cache} = $row->[6]; |
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_firmware_version} = $row->[7]; |
|
$anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_unsafe_writeback_cache} = $row->[8]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_serial_number" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_serial_number}, |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_model" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_model}, |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_status" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_status}, |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_last_diagnostics" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_last_diagnostics}, |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_cache_present" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_cache_present}, |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_drive_write_cache" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_drive_write_cache}, |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_firmware_version" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_firmware_version}, |
|
"sql::scan_hpacucli_controllers::scan_hpacucli_controller_uuid::${scan_hpacucli_controller_uuid}::scan_hpacucli_controller_unsafe_writeback_cache" => $anvil->data->{sql}{scan_hpacucli_controllers}{scan_hpacucli_controller_uuid}{$scan_hpacucli_controller_uuid}{scan_hpacucli_controller_unsafe_writeback_cache}, |
|
}}); |
|
|
|
# Store the information about this controllers |
|
$anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number} = $scan_hpacucli_controller_uuid; |
|
$anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$scan_hpacucli_controller_uuid} = $scan_hpacucli_controller_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::controllers::by_serial::${scan_hpacucli_controller_serial_number}" => $anvil->data->{'scan-hpacucli'}{controllers}{by_serial}{$scan_hpacucli_controller_serial_number}, |
|
"scan-hpacucli::controllers::by_uuid::${scan_hpacucli_controller_uuid}" => $anvil->data->{'scan-hpacucli'}{controllers}{by_uuid}{$scan_hpacucli_controller_uuid}, |
|
}}); |
|
} |
|
undef $results; |
|
undef $count; |
|
|
|
# Now load the cache data |
|
$query = " |
|
SELECT |
|
scan_hpacucli_cache_module_uuid, |
|
scan_hpacucli_cache_module_serial_number, |
|
scan_hpacucli_cache_module_controller_uuid, |
|
scan_hpacucli_cache_module_status, |
|
scan_hpacucli_cache_module_type, |
|
scan_hpacucli_cache_module_size |
|
FROM |
|
scan_hpacucli_cache_modules |
|
WHERE |
|
scan_hpacucli_cache_module_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
$results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
$count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
foreach my $row (@{$results}) |
|
{ |
|
my $scan_hpacucli_cache_module_uuid = $row->[0]; |
|
my $scan_hpacucli_cache_module_serial_number = $row->[1]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_cache_module_uuid => $scan_hpacucli_cache_module_uuid, |
|
scan_hpacucli_cache_module_serial_number => $scan_hpacucli_cache_module_serial_number, |
|
}}); |
|
|
|
# Store the information about this cache_module |
|
$anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_controller_uuid} = $row->[2]; |
|
$anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_serial_number} = $scan_hpacucli_cache_module_serial_number; |
|
$anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_status} = $row->[3]; |
|
$anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_type} = $row->[4]; |
|
$anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_size} = $row->[5]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_cache_modules::scan_hpacucli_cache_module_uuid::${scan_hpacucli_cache_module_uuid}::scan_hpacucli_cache_module_controller_uuid" => $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_controller_uuid}, |
|
"sql::scan_hpacucli_cache_modules::scan_hpacucli_cache_module_uuid::${scan_hpacucli_cache_module_uuid}::scan_hpacucli_cache_module_serial_number" => $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_serial_number}, |
|
"sql::scan_hpacucli_cache_modules::scan_hpacucli_cache_module_uuid::${scan_hpacucli_cache_module_uuid}::scan_hpacucli_cache_module_status" => $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_status}, |
|
"sql::scan_hpacucli_cache_modules::scan_hpacucli_cache_module_uuid::${scan_hpacucli_cache_module_uuid}::scan_hpacucli_cache_module_type" => $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_type}, |
|
"sql::scan_hpacucli_cache_modules::scan_hpacucli_cache_module_uuid::${scan_hpacucli_cache_module_uuid}::scan_hpacucli_cache_module_size" => $anvil->data->{sql}{scan_hpacucli_cache_modules}{scan_hpacucli_cache_module_uuid}{$scan_hpacucli_cache_module_uuid}{scan_hpacucli_cache_module_size}, |
|
}}); |
|
|
|
$anvil->data->{'scan-hpacucli'}{cache_modules}{by_serial}{$scan_hpacucli_cache_module_serial_number} = $scan_hpacucli_cache_module_uuid; |
|
$anvil->data->{'scan-hpacucli'}{cache_modules}{by_uuid}{$scan_hpacucli_cache_module_uuid} = $scan_hpacucli_cache_module_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::cache_modules::by_serial::${scan_hpacucli_cache_module_serial_number}" => $anvil->data->{'scan-hpacucli'}{cache_modules}{by_serial}{$scan_hpacucli_cache_module_serial_number}, |
|
"scan-hpacucli::cache_modules::by_uuid::${scan_hpacucli_cache_module_uuid}" => $anvil->data->{'scan-hpacucli'}{cache_modules}{by_uuid}{$scan_hpacucli_cache_module_uuid}, |
|
}}); |
|
} |
|
undef $results; |
|
undef $count; |
|
|
|
# The array data... |
|
$query = " |
|
SELECT |
|
scan_hpacucli_array_uuid, |
|
scan_hpacucli_array_name, |
|
scan_hpacucli_array_controller_uuid, |
|
scan_hpacucli_array_type, |
|
scan_hpacucli_array_status, |
|
scan_hpacucli_array_error_message |
|
FROM |
|
scan_hpacucli_arrays |
|
WHERE |
|
scan_hpacucli_array_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
$results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
$count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
foreach my $row (@{$results}) |
|
{ |
|
my $scan_hpacucli_array_uuid = $row->[0]; |
|
my $scan_hpacucli_array_name = $row->[1]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_array_uuid => $scan_hpacucli_array_uuid, |
|
scan_hpacucli_array_name => $scan_hpacucli_array_name, |
|
}}); |
|
|
|
# Store the drive group data. (Drive groups have no SN) |
|
$anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_controller_uuid} = $row->[2]; |
|
$anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_name} = $scan_hpacucli_array_name; |
|
$anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_type} = $row->[3]; |
|
$anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_status} = $row->[4]; |
|
$anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_error_message} = $row->[5]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_arrays::scan_hpacucli_array_uuid::${scan_hpacucli_array_uuid}::scan_hpacucli_array_controller_uuid" => $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_controller_uuid}, |
|
"sql::scan_hpacucli_arrays::scan_hpacucli_array_uuid::${scan_hpacucli_array_uuid}::scan_hpacucli_array_name" => $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_name}, |
|
"sql::scan_hpacucli_arrays::scan_hpacucli_array_uuid::${scan_hpacucli_array_uuid}::scan_hpacucli_array_type" => $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_type}, |
|
"sql::scan_hpacucli_arrays::scan_hpacucli_array_uuid::${scan_hpacucli_array_uuid}::scan_hpacucli_array_status" => $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_status}, |
|
"sql::scan_hpacucli_arrays::scan_hpacucli_array_uuid::${scan_hpacucli_array_uuid}::scan_hpacucli_array_error_message" => $anvil->data->{sql}{scan_hpacucli_arrays}{scan_hpacucli_array_uuid}{$scan_hpacucli_array_uuid}{scan_hpacucli_array_error_message}, |
|
}}); |
|
|
|
# Store the information about this virtual drive. |
|
$anvil->data->{'scan-hpacucli'}{virtual_drives}{by_name}{$scan_hpacucli_array_name} = $scan_hpacucli_array_uuid; |
|
$anvil->data->{'scan-hpacucli'}{virtual_drives}{by_uuid}{$scan_hpacucli_array_uuid} = $scan_hpacucli_array_name; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::virtual_drives::by_name::${scan_hpacucli_array_name}" => $anvil->data->{'scan-hpacucli'}{virtual_drives}{by_name}{$scan_hpacucli_array_name}, |
|
"scan-hpacucli::virtual_drives::by_uuid::${scan_hpacucli_array_uuid}" => $anvil->data->{'scan-hpacucli'}{virtual_drives}{by_uuid}{$scan_hpacucli_array_uuid}, |
|
}}); |
|
} |
|
undef $results; |
|
undef $count; |
|
|
|
# The drive group data... |
|
$query = " |
|
SELECT |
|
scan_hpacucli_logical_drive_uuid, |
|
scan_hpacucli_logical_drive_name, |
|
scan_hpacucli_logical_drive_array_uuid, |
|
scan_hpacucli_logical_drive_caching, |
|
scan_hpacucli_logical_drive_os_device_name, |
|
scan_hpacucli_logical_drive_type, |
|
scan_hpacucli_logical_drive_raid_level, |
|
scan_hpacucli_logical_drive_size, |
|
scan_hpacucli_logical_drive_strip_size, |
|
scan_hpacucli_logical_drive_stripe_size, |
|
scan_hpacucli_logical_drive_status |
|
FROM |
|
scan_hpacucli_logical_drives |
|
WHERE |
|
scan_hpacucli_logical_drive_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
$results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
$count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
foreach my $row (@{$results}) |
|
{ |
|
my $scan_hpacucli_logical_drive_uuid = $row->[0]; |
|
my $scan_hpacucli_logical_drive_name = $row->[1]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_logical_drive_uuid => $scan_hpacucli_logical_drive_uuid, |
|
scan_hpacucli_logical_drive_name => $scan_hpacucli_logical_drive_name, |
|
}}); |
|
|
|
# Store the logical drive data. (LDs have no SN) |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_name} = $scan_hpacucli_logical_drive_name; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_array_uuid} = $row->[2]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_caching} = $row->[3]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_os_device_name} = $row->[4]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_type} = $row->[5]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_raid_level} = $row->[6]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_size} = $row->[7]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_strip_size} = $row->[8]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_stripe_size} = $row->[9]; |
|
$anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_status} = $row->[10]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_array_uuid" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_array_uuid}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_name" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_name}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_caching" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_caching}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_os_device_name" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_os_device_name}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_type" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_type}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_raid_level" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_raid_level}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_size" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_size}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_strip_size" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_strip_size}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_stripe_size" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_stripe_size}, |
|
"sql::scan_hpacucli_logical_drives::scan_hpacucli_logical_drive_uuid::${scan_hpacucli_logical_drive_uuid}::scan_hpacucli_logical_drive_status" => $anvil->data->{sql}{scan_hpacucli_logical_drives}{scan_hpacucli_logical_drive_uuid}{$scan_hpacucli_logical_drive_uuid}{scan_hpacucli_logical_drive_status}, |
|
}}); |
|
|
|
# Store the information about this virtual drive. |
|
$anvil->data->{'scan-hpacucli'}{logical_drives}{by_name}{$scan_hpacucli_logical_drive_name} = $scan_hpacucli_logical_drive_uuid; |
|
$anvil->data->{'scan-hpacucli'}{logical_drives}{by_uuid}{$scan_hpacucli_logical_drive_uuid} = $scan_hpacucli_logical_drive_name; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::logical_drives::by_name::${scan_hpacucli_logical_drive_name}" => $anvil->data->{'scan-hpacucli'}{logical_drives}{by_name}{$scan_hpacucli_logical_drive_name}, |
|
"scan-hpacucli::logical_drives::by_uuid::${scan_hpacucli_logical_drive_uuid}" => $anvil->data->{'scan-hpacucli'}{logical_drives}{by_uuid}{$scan_hpacucli_logical_drive_uuid}, |
|
}}); |
|
} |
|
undef $results; |
|
undef $count; |
|
|
|
# And now, the physical drives. |
|
$query = " |
|
SELECT |
|
scan_hpacucli_physical_drive_uuid, |
|
scan_hpacucli_physical_drive_serial_number, |
|
scan_hpacucli_physical_drive_logical_drive_uuid, |
|
scan_hpacucli_physical_drive_model, |
|
scan_hpacucli_physical_drive_interface, |
|
scan_hpacucli_physical_drive_status, |
|
scan_hpacucli_physical_drive_size, |
|
scan_hpacucli_physical_drive_type, |
|
scan_hpacucli_physical_drive_rpm, |
|
scan_hpacucli_physical_drive_temperature, |
|
scan_hpacucli_physical_drive_last_failure_reason, |
|
scan_hpacucli_physical_drive_port, |
|
scan_hpacucli_physical_drive_box, |
|
scan_hpacucli_physical_drive_bay |
|
FROM |
|
scan_hpacucli_physical_drives |
|
WHERE |
|
scan_hpacucli_physical_drive_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
$results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
$count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
foreach my $row (@{$results}) |
|
{ |
|
my $scan_hpacucli_physical_drive_uuid = $row->[0]; |
|
my $scan_hpacucli_physical_drive_serial_number = $row->[1]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_physical_drive_uuid => $scan_hpacucli_physical_drive_uuid, |
|
scan_hpacucli_physical_drive_serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
}}); |
|
|
|
# Store the information about this physical drive |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_logical_drive_uuid} = $row->[2]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_serial_number} = $scan_hpacucli_physical_drive_serial_number; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_model} = $row->[3]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_interface} = $row->[4]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_status} = $row->[5]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_size} = $row->[6]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_type} = $row->[7]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_rpm} = $row->[8]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_temperature} = $row->[9]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_last_failure_reason} = $row->[10]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_port} = $row->[11]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_box} = $row->[12]; |
|
$anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_bay} = $row->[13]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_logical_drive_uuid" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_logical_drive_uuid}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_serial_number" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_serial_number}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_model" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_model}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_interface" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_interface}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_status" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_status}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_size" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_size}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_type" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_type}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_rpm" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_rpm}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_temperature" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_temperature}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_last_failure_reason" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_last_failure_reason}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_port" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_port}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_box" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_box}, |
|
"sql::scan_hpacucli_physical_drives::scan_hpacucli_physical_drive_uuid::${scan_hpacucli_physical_drive_uuid}::scan_hpacucli_physical_drive_bay" => $anvil->data->{sql}{scan_hpacucli_physical_drives}{scan_hpacucli_physical_drive_uuid}{$scan_hpacucli_physical_drive_uuid}{scan_hpacucli_physical_drive_bay}, |
|
}}); |
|
|
|
# Make it so that we can look up the serial number from the drive's UUID and vice versa |
|
$anvil->data->{'scan-hpacucli'}{physical_drives}{by_serial}{$scan_hpacucli_physical_drive_serial_number} = $scan_hpacucli_physical_drive_uuid; |
|
$anvil->data->{'scan-hpacucli'}{physical_drives}{by_uuid}{$scan_hpacucli_physical_drive_uuid} = $scan_hpacucli_physical_drive_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::physical_drives::by_serial::${scan_hpacucli_physical_drive_serial_number}" => $anvil->data->{'scan-hpacucli'}{physical_drives}{by_serial}{$scan_hpacucli_physical_drive_serial_number}, |
|
"scan-hpacucli::physical_drives::by_uuid::${scan_hpacucli_physical_drive_uuid}" => $anvil->data->{'scan-hpacucli'}{physical_drives}{by_uuid}{$scan_hpacucli_physical_drive_uuid}, |
|
}}); |
|
} |
|
undef $results; |
|
undef $count; |
|
|
|
# Lastly, the variables. |
|
$query = " |
|
SELECT |
|
scan_hpacucli_variable_uuid, |
|
scan_hpacucli_variable_source_table, |
|
scan_hpacucli_variable_source_uuid, |
|
scan_hpacucli_variable_is_temperature, |
|
scan_hpacucli_variable_name, |
|
scan_hpacucli_variable_value |
|
FROM |
|
scan_hpacucli_variables |
|
WHERE |
|
scan_hpacucli_variable_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)." |
|
;"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
$results = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__}); |
|
$count = @{$results}; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
results => $results, |
|
count => $count, |
|
}}); |
|
foreach my $row (@{$results}) |
|
{ |
|
my $scan_hpacucli_variable_uuid = $row->[0]; |
|
my $scan_hpacucli_variable_source_table = $row->[1]; |
|
my $scan_hpacucli_variable_source_uuid = $row->[2]; |
|
my $scan_hpacucli_variable_is_temperature = $row->[3]; |
|
my $scan_hpacucli_variable_name = $row->[4]; |
|
my $scan_hpacucli_variable_value = $row->[5]; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_variable_uuid => $scan_hpacucli_variable_uuid, |
|
scan_hpacucli_variable_source_table => $scan_hpacucli_variable_source_table, |
|
scan_hpacucli_variable_source_uuid => $scan_hpacucli_variable_source_uuid, |
|
scan_hpacucli_variable_is_temperature => $scan_hpacucli_variable_is_temperature, |
|
scan_hpacucli_variable_name => $scan_hpacucli_variable_name, |
|
scan_hpacucli_variable_value => $scan_hpacucli_variable_value, |
|
}}); |
|
|
|
# We store these differently for easier reference. Diagnostic data is stored in the special |
|
# 'scan_hpacucli_physical_drive_diagnostics' source. |
|
my $type = "detail"; |
|
if ($scan_hpacucli_variable_source_table eq "scan_hpacucli_physical_drive_diagnostics") |
|
{ |
|
$type = "diagnostics"; |
|
} |
|
if ($scan_hpacucli_variable_is_temperature eq "1") |
|
{ |
|
$type = "temperature"; |
|
} |
|
$anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{$scan_hpacucli_variable_source_table}{source_uuid}{$scan_hpacucli_variable_source_uuid}{$type}{$scan_hpacucli_variable_name} = { |
|
scan_hpacucli_variable_uuid => $scan_hpacucli_variable_uuid, |
|
scan_hpacucli_variable_is_temperature => $scan_hpacucli_variable_is_temperature, |
|
scan_hpacucli_variable_value => $scan_hpacucli_variable_value, |
|
}; |
|
|
|
# Entries are so long that we log the one per variable. |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_variables::scan_hpacucli_variable_uuid::source_table::${scan_hpacucli_variable_source_table}::source_uuid::${scan_hpacucli_variable_source_uuid}::${type}::${scan_hpacucli_variable_name}::scan_hpacucli_variable_uuid" => $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{$scan_hpacucli_variable_source_table}{source_uuid}{$scan_hpacucli_variable_source_uuid}{$type}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_uuid}, |
|
}}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_variables::scan_hpacucli_variable_uuid::source_table::${scan_hpacucli_variable_source_table}::source_uuid::${scan_hpacucli_variable_source_uuid}::${type}::${scan_hpacucli_variable_name}::scan_hpacucli_variable_is_temperature" => $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{$scan_hpacucli_variable_source_table}{source_uuid}{$scan_hpacucli_variable_source_uuid}{$type}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_is_temperature}, |
|
}}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sql::scan_hpacucli_variables::scan_hpacucli_variable_uuid::source_table::${scan_hpacucli_variable_source_table}::source_uuid::${scan_hpacucli_variable_source_uuid}::${type}::${scan_hpacucli_variable_name}::scan_hpacucli_variable_value" => $anvil->data->{sql}{scan_hpacucli_variables}{scan_hpacucli_variable_uuid}{source_table}{$scan_hpacucli_variable_source_table}{source_uuid}{$scan_hpacucli_variable_source_uuid}{$type}{$scan_hpacucli_variable_name}{scan_hpacucli_variable_value}, |
|
}}); |
|
} |
|
undef $results; |
|
undef $count; |
|
|
|
# Return the number |
|
return(0); |
|
} |
|
|
|
# This looks for anything other than temperature sensors that will feed into the health of the node. |
|
sub pre_process_health |
|
{ |
|
my ($anvil) = @_; |
|
|
|
# This is to collected data from every sweep. |
|
foreach my $scan_hpacucli_controller_serial_number (sort {$a cmp $b} keys %{$anvil->data->{controller}}) |
|
{ |
|
# We don't care about metadata |
|
next if $scan_hpacucli_controller_serial_number eq "metadata"; |
|
|
|
# Controller data |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}}) |
|
{ |
|
if (($variable eq "battery_or_capacitor_status") && (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}{$variable}) ne "ok")) |
|
{ |
|
# BBU/FBU problem, score of 2 |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":data:".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 2; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
elsif (($variable eq "cache_status") && (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}{$variable}) ne "ok")) |
|
{ |
|
# Cache isn't OK, score of 2 |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":data:".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 2; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
elsif (($variable eq "controller_status") && (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}{$variable}) ne "ok")) |
|
{ |
|
# The controller isn't OK, this is major, score of 10 |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":data:".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 10; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
} |
|
|
|
# Array |
|
foreach my $scan_hpacucli_array_name (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}}) |
|
{ |
|
# Data |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}}) |
|
{ |
|
if (($variable eq "status") && (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{$variable}) ne "ok")) |
|
{ |
|
# Something is wrong with this array |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":array:".$scan_hpacucli_array_name.":".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 5; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
} |
|
|
|
# Logical Drive |
|
foreach my $logical_drive (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}}) |
|
{ |
|
# Data |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{data}{detail}}) |
|
{ |
|
if (($variable eq "caching") && (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{data}{detail}{$variable}) ne "enabled")) |
|
{ |
|
# Not enabled is going to hurt performance. |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":array:".$scan_hpacucli_array_name.":logical_drive:".$logical_drive.":".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
elsif (($variable eq "status") && (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{data}{detail}{$variable}) ne "ok")) |
|
{ |
|
# If the status isn't OK, it's degraded (or rebuilding, but |
|
# still degraded). |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":array:".$scan_hpacucli_array_name.":logical_drive:".$logical_drive.":".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 2; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
} |
|
|
|
# Physical Disks. |
|
foreach my $port (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}}) |
|
{ |
|
foreach my $box (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}}) |
|
{ |
|
foreach my $bay (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}}) |
|
{ |
|
my $scan_hpacucli_physical_drive_serial_number = $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{serial_number}; |
|
# Data |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}}) |
|
{ |
|
next if $variable eq "serial_number"; |
|
next if $variable eq "port"; |
|
next if $variable eq "box"; |
|
next if $variable eq "bay"; |
|
|
|
if (($variable eq "status") && (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{$variable}) ne "ok")) |
|
{ |
|
# The drive is failed or is rebuilding. This adds 2. |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":physical_drive:".$scan_hpacucli_physical_drive_serial_number.":data:".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = 2; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
} |
|
|
|
# If this was a diagnostics run, check for error |
|
# counters |
|
if ($anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics}) |
|
{ |
|
# If the diagnostics don't exist for the |
|
# drive and the drive is OK, it's likely a |
|
# 3rd party drive. If the status is not OK, |
|
# there may not be diagnostic data. |
|
if (exists $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_hard}) |
|
{ |
|
# We got the data |
|
foreach my $variable (sort {$a cmp $b} keys %{$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}}) |
|
{ |
|
# Store this in the main hash. |
|
if ((($variable eq "hardware_errors") or |
|
($variable eq "predictive_failure_errors") or |
|
($variable eq "read_errors_hard") or |
|
($variable eq "write_errors_hard")) && |
|
($anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{$variable} =~ /^\d+$/) && |
|
($anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{$variable} > 0)) |
|
{ |
|
# How high is the error count? |
|
my $score = 1; |
|
if ($anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{$variable} > 10) |
|
{ |
|
# Eek |
|
$score = 3; |
|
} |
|
elsif ($anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{$variable} > 5) |
|
{ |
|
# Getting a little high |
|
$score = 2; |
|
} |
|
my $health_source_name = "controller:".$scan_hpacucli_controller_serial_number.":physical_drive:".$scan_hpacucli_physical_drive_serial_number.":diagnostics:".$variable; |
|
$anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name} = $score; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"health::new::controller:$health_source_name" => $anvil->data->{'scan-hpacucli'}{health}{new}{$health_source_name}, |
|
}}); |
|
} |
|
|
|
# Record the diagnostic data |
|
# under the drive's hash. |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{'diagnostics'}{$variable} = $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{$variable}; |
|
} |
|
} |
|
elsif (lc($anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{detail}{status}) eq "ok") |
|
{ |
|
# No data for this drive. It might be |
|
# a 3rd party drive. We'll warn the |
|
# user that we can't predict failure. |
|
my $changed = $anvil->Alert->check_alert_sent({clear => 0, record_locator => $scan_hpacucli_physical_drive_serial_number.":no_diagnostics", set_by => $THIS_FILE}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }}); |
|
if ($changed) |
|
{ |
|
# Warn the user that we can't |
|
# predict this drive's death. |
|
my $variables = { |
|
serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hpacucli_warning_0001", variables => $variables}); |
|
$anvil->Alert->register({ |
|
clear_alert => 0, |
|
alert_level => "warning", |
|
message => "scan_hpacucli_warning_0001", |
|
variables => $variables, |
|
show_header => 1, |
|
sort_position => $anvil->data->{'scan-hpacucli'}{alert_sort}++, |
|
set_by => $THIS_FILE, |
|
}); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
# This gets the basic information about the controller. |
|
sub get_controller_info |
|
{ |
|
my ($anvil, $controller) = @_; |
|
|
|
my $model_name = ""; |
|
my $scan_hpacucli_controller_serial_number = ""; |
|
my $cache_serial_number = ""; |
|
my $scan_hpacucli_physical_drive_serial_number = ""; |
|
my $scan_hpacucli_array_name = ""; |
|
my $logical_drive = ""; |
|
my $port = ""; |
|
my $box = ""; |
|
my $bay = ""; |
|
my $in_array = 0; |
|
my $shell_call = $anvil->data->{path}{exe}{hpacucli}." controller slot=".$controller." show config detail"; |
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
output => $output, |
|
return_code => $return_code, |
|
}}); |
|
foreach my $line (split/\n/, $output) |
|
{ |
|
$line = $anvil->Words->clean_spaces({string => $line}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { line => $line }}); |
|
|
|
if ((not $scan_hpacucli_controller_serial_number) && ($line =~ /^(.*?) in Slot $controller /)) |
|
{ |
|
$model_name = $1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { model_name => $model_name }}); |
|
} |
|
|
|
if (($line =~ /^Serial Number: (.*?)$/) && (not $port) && (not $box) && (not $bay)) |
|
{ |
|
$scan_hpacucli_controller_serial_number = $1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number }}); |
|
|
|
# Record the model number |
|
if ($model_name) |
|
{ |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}{model_name} = $model_name; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::data::detail::model_name" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}{model_name}, |
|
}}); |
|
} |
|
|
|
# Make a reference between the slot and SN |
|
$anvil->data->{controller}{metadata}{sn_to_slot}{$scan_hpacucli_controller_serial_number} = $controller; |
|
$anvil->data->{controller}{metadata}{slot_to_sn}{$controller} = $scan_hpacucli_controller_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::metadata::sn_to_slot::${scan_hpacucli_controller_serial_number}" => $anvil->data->{controller}{metadata}{sn_to_slot}{$scan_hpacucli_controller_serial_number}, |
|
"controller::metadata::slot_to_sn::${controller}" => $anvil->data->{controller}{metadata}{slot_to_sn}{$controller}, |
|
}}); |
|
next; |
|
} |
|
next if not $scan_hpacucli_controller_serial_number; |
|
|
|
if ($line =~ /Cache Serial Number: (.*?)$/i) |
|
{ |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}{cache_serial_number} = $1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::data::detail::cache_serial_number" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{detail}{cache_serial_number}, |
|
}}); |
|
next; |
|
} |
|
|
|
if ($line =~ /Array: (.*?)$/i) |
|
{ |
|
$scan_hpacucli_array_name = $1; |
|
$in_array = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_array_name => $scan_hpacucli_array_name, |
|
in_array => $in_array, |
|
}}); |
|
next; |
|
} |
|
|
|
if ($line =~ /Logical Drive: (.*?)$/i) |
|
{ |
|
$logical_drive = $1; |
|
$in_array = 0; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
logical_drive => $logical_drive, |
|
in_array => $in_array, |
|
}}); |
|
next; |
|
} |
|
|
|
if ($line =~ /physicaldrive (.*?):(.*?):(.*)$/) |
|
{ |
|
$port = $1; |
|
$box = $2; |
|
$bay = $3; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}}); |
|
next; |
|
} |
|
elsif (($port) && (($line eq "Drive Type: Data") or ($line =~ /^Mirror Group \d+:$/))) |
|
{ |
|
$port = ""; |
|
$box = ""; |
|
$bay = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}}); |
|
} |
|
|
|
if (lc($line) eq "unassigned") |
|
{ |
|
$scan_hpacucli_array_name = "ZZZZ"; |
|
$logical_drive = "9999"; |
|
$port = ""; |
|
$box = ""; |
|
$bay = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
scan_hpacucli_array_name => $scan_hpacucli_array_name, |
|
logical_drive => $logical_drive, |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}}); |
|
next; |
|
} |
|
|
|
# Lines I don't care about |
|
next if $line =~ /^Slot: $controller$/i; |
|
|
|
my $type = "detail"; |
|
if ($line =~ /^(.*?): (.*)$/) |
|
{ |
|
my $variable = $1; |
|
my $value = $2; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
variable => $variable, |
|
value => $value, |
|
}}); |
|
|
|
# If the variable has units, pull them out. |
|
if ($variable =~ / \(C\)$/i) |
|
{ |
|
$variable =~ s/ \(C\)$//i; |
|
$variable = $anvil->Words->clean_spaces({string => $variable}); |
|
$type = "temperature"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
variable => $variable, |
|
value => $value, |
|
type => $type, |
|
}}); |
|
} |
|
elsif ($variable =~ / \(F\)/i) |
|
{ |
|
# Covert to °C |
|
$variable =~ s/ \(F\)$//i; |
|
$variable = $anvil->Words->clean_spaces({string => $variable}); |
|
$value = $anvil->Convert->fahrenheit_to_celsius({temperature => $value}); |
|
$type = "temperature"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
variable => $variable, |
|
value => $value, |
|
type => $type, |
|
}}); |
|
} |
|
elsif (($value =~ /^\d+ \wB$/) or ($value =~ /^\d+\.\d+ \wB$/)) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
variable => $variable, |
|
">> value" => $value, |
|
}}); |
|
if (($variable eq "Total Cache Size") or |
|
($variable eq "Total Cache Memory Available") or |
|
($variable eq "Strip Size") or |
|
($variable eq "Size") or |
|
($variable eq "Full Stripe Size")) |
|
{ |
|
# HP reports in MB, etc, but means MiB. |
|
$value = $anvil->Convert->human_readable_to_bytes({size => $value, base2 => 1}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
variable => $variable, |
|
"<< value" => $value, |
|
}}); |
|
} |
|
} |
|
|
|
# Save it. |
|
if (exists $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{$type}{$variable}) |
|
{ |
|
# Conflict! This is a dirty way to keep them separate |
|
$variable .= " 2"; |
|
} |
|
|
|
$variable = process_variable_name($anvil, $variable); |
|
|
|
# What am I saving? |
|
if (($port) && ($box) && ($bay)) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"line" => $line, |
|
}}); |
|
|
|
# Physical drive info |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{$type}{$variable} = $value; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::array::${scan_hpacucli_array_name}::logical_drive::${logical_drive}::physical_drive::port::${port}::box::${box}::bay::${bay}::${type}::$variable" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{physical_drive}{port}{$port}{box}{$box}{bay}{$bay}{$type}{$variable}, |
|
}}); |
|
|
|
# Map the SN to it's current location. |
|
if ($line =~ /Serial Number: (.*?)$/) |
|
{ |
|
$scan_hpacucli_physical_drive_serial_number = $1; |
|
my $location = $port.":".$box.":".$bay; |
|
$anvil->data->{physical_drive}{by_serial_number}{$scan_hpacucli_physical_drive_serial_number} = { |
|
array => $scan_hpacucli_array_name, |
|
logical_drive => $logical_drive, |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}; |
|
$anvil->data->{physical_drive}{by_location}{$location} = $scan_hpacucli_physical_drive_serial_number; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"physical_drive::by_serial_number::${scan_hpacucli_physical_drive_serial_number}::array" => $anvil->data->{physical_drive}{by_serial_number}{$scan_hpacucli_physical_drive_serial_number}{array}, |
|
"physical_drive::by_serial_number::${scan_hpacucli_physical_drive_serial_number}::logical_drive" => $anvil->data->{physical_drive}{by_serial_number}{$scan_hpacucli_physical_drive_serial_number}{logical_drive}, |
|
"physical_drive::by_serial_number::${scan_hpacucli_physical_drive_serial_number}::port" => $anvil->data->{physical_drive}{by_serial_number}{$scan_hpacucli_physical_drive_serial_number}{port}, |
|
"physical_drive::by_serial_number::${scan_hpacucli_physical_drive_serial_number}::box" => $anvil->data->{physical_drive}{by_serial_number}{$scan_hpacucli_physical_drive_serial_number}{box}, |
|
"physical_drive::by_serial_number::${scan_hpacucli_physical_drive_serial_number}::bay" => $anvil->data->{physical_drive}{by_serial_number}{$scan_hpacucli_physical_drive_serial_number}{bay}, |
|
"physical_drive::by_location::$location" => $anvil->data->{physical_drive}{by_location}{$location}, |
|
}}); |
|
} |
|
} |
|
elsif ($logical_drive) |
|
{ |
|
# Logical drive |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{data}{$type}{$variable} = $value; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::array::${scan_hpacucli_array_name}::logical_drive::${logical_drive}::data::${type}::$variable" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{logical_drive}{$logical_drive}{data}{$type}{$variable}, |
|
}}); |
|
} |
|
elsif ($scan_hpacucli_array_name) |
|
{ |
|
# Array |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{$type}{$variable} = $value; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::array::${scan_hpacucli_array_name}::data::${type}::$variable" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{$type}{$variable}, |
|
}}); |
|
} |
|
else |
|
{ |
|
# Controller data |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable} = $value; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::data::${type}::$variable" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{data}{$type}{$variable}, |
|
}}); |
|
} |
|
} |
|
elsif ($in_array) |
|
{ |
|
# Messages about a degraded array can be here. |
|
# ie: "One of the drives on this array have failed or has been removed." |
|
if ($line =~ /this array have failed/) |
|
{ |
|
# We'll concatonate in case there are multiple errors. |
|
if (not exists $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{error_message}) |
|
{ |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{error_message} = ""; |
|
} |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{error_message} .= $line."\n"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::array::${scan_hpacucli_array_name}::data::detail::error_message" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{array}{$scan_hpacucli_array_name}{data}{detail}{error_message}, |
|
}}); |
|
} |
|
} |
|
|
|
} |
|
|
|
# If I didn't find a serial number, something went wrong. |
|
if (not $scan_hpacucli_controller_serial_number) |
|
{ |
|
# Error out. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 0, key => "scan_hpacucli_error_0004", variables => { controller => $controller }}); |
|
$anvil->nice_exit({exit_code => 6}); |
|
} |
|
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number }}); |
|
return($scan_hpacucli_controller_serial_number); |
|
} |
|
|
|
# This will do a details diagnostics check, if enough time has passed. |
|
sub get_diagnostics |
|
{ |
|
my ($anvil, $controller) = @_; |
|
|
|
# Every 'scan-hpacucli::diagnostics_interval' seconds, run a full diagnostics to check for drives in |
|
# pre-failure. |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "sys::process_diagnostics" => $anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics} }}); |
|
if (not $anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics}) |
|
{ |
|
# Is it time? |
|
my $query = "SELECT scan_hpacucli_controller_last_diagnostics FROM scan_hpacucli_controllers WHERE scan_hpacucli_controller_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid).";"; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }}); |
|
|
|
# The actual query -----------------. .------- Row 0 |
|
# Query this DB --. | | .-- Columns 0 |
|
my $last_diagnostics = $anvil->Database->query({query => $query, source => $THIS_FILE, line => __LINE__})->[0]->[0]; |
|
$last_diagnostics = 0 if not defined $last_diagnostics; |
|
my $current_time = time; |
|
my $last_scan_was = $current_time - $last_diagnostics; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
last_diagnostics => $last_diagnostics, |
|
current_time => $current_time, |
|
last_scan_was => $last_scan_was, |
|
"scan-hpacucli::diagnostics_interval" => $anvil->data->{'scan-hpacucli'}{diagnostics_interval}, |
|
}}); |
|
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::diagnostics_interval" => $last_diagnostics, |
|
}}); |
|
if ($anvil->data->{'scan-hpacucli'}{diagnostics_interval} !~ /^\d+$/) |
|
{ |
|
# Invalid value, override. |
|
$anvil->data->{'scan-hpacucli'}{diagnostics_interval} = 1800; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"scan-hpacucli::diagnostics_interval" => $anvil->data->{'scan-hpacucli'}{diagnostics_interval}, |
|
}}); |
|
} |
|
if ($last_scan_was > $anvil->data->{'scan-hpacucli'}{diagnostics_interval}) |
|
{ |
|
$anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics} = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sys::process_diagnostics" => $anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics}, |
|
}}); |
|
} |
|
} |
|
|
|
# Well, is it? |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"sys::process_diagnostics" => $anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics}, |
|
}}); |
|
if ($anvil->data->{'scan-hpacucli'}{sys}{process_diagnostics}) |
|
{ |
|
# Yup! We use hpacucli's diagnostics to gather all data. |
|
my $shell_call = " |
|
cd /tmp/ |
|
".$anvil->data->{path}{exe}{hpacucli}." controller slot=".$controller." diag file=/tmp/ADUReport.zip |
|
".$anvil->data->{path}{exe}{'unzip'}." -o /tmp/ADUReport.zip -d /tmp/ |
|
if [ -e '/tmp/ADUReport.xml' ]; |
|
then |
|
".$anvil->data->{path}{exe}{rm}." -f /tmp/ADUReport.zip |
|
".$anvil->data->{path}{exe}{rm}." -f /tmp/ADUReport.htm |
|
".$anvil->data->{path}{exe}{rm}." -f /tmp/ADUReport.xml |
|
".$anvil->data->{path}{exe}{rm}." -f /tmp/report.checksum |
|
fi |
|
"; |
|
# Write a log message to warn the user that we're starting a long process. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hpacucli_log_0003", variables => { shell_call => $shell_call }}); |
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
output => $output, |
|
return_code => $return_code, |
|
}}); |
|
foreach my $line (split/\n/, $output) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { line => $line }}); |
|
} |
|
undef $output; |
|
undef $return_code; |
|
|
|
# Did it work? |
|
if (not -r "/tmp/ADUReport.txt") |
|
{ |
|
# Something went wrong. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 0, key => "scan_hpacucli_error_0005", variables => { path => "/tmp/ADUReport.txt" }}); |
|
$anvil->nice_exit({exit_code => 4}); |
|
} |
|
|
|
# Get this controller's serial number |
|
my $scan_hpacucli_controller_serial_number = $anvil->data->{controller}{metadata}{slot_to_sn}{$controller}; |
|
|
|
# Parse! |
|
my $in_cache_config_status = 0; |
|
my $in_physical_drive = 0; |
|
my $scan_hpacucli_physical_drive_serial_number = ""; |
|
my $port = ""; |
|
my $box = ""; |
|
my $bay = ""; |
|
my $skip_blank_line = 0; |
|
$shell_call = "/tmp/ADUReport.txt"; |
|
($output, $return_code) = $anvil->System->call({shell_call => $shell_call}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
output => $output, |
|
return_code => $return_code, |
|
}}); |
|
foreach my $line (split/\n/, $output) |
|
{ |
|
$line = $anvil->Words->clean_spaces({string => $line}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { line => $line }}); |
|
|
|
if (not $line) |
|
{ |
|
if ($skip_blank_line) |
|
{ |
|
next; |
|
} |
|
$in_cache_config_status = 0; |
|
$in_physical_drive = 0; |
|
$scan_hpacucli_physical_drive_serial_number = ""; |
|
$port = ""; |
|
$box = ""; |
|
$bay = ""; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
in_cache_config_status => $in_cache_config_status, |
|
in_physical_drive => $in_physical_drive, |
|
scan_hpacucli_physical_drive_serial_number => $scan_hpacucli_physical_drive_serial_number, |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}}); |
|
next; |
|
} |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { line => $line }}); |
|
|
|
$skip_blank_line = 0; |
|
|
|
if ($line =~ /: Cache Config Status$/i) |
|
{ |
|
$in_cache_config_status = 1; |
|
$skip_blank_line = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { in_cache_config_status => $in_cache_config_status }}); |
|
next; |
|
} |
|
|
|
if ($line =~ /: Physical Drive \(.*?\) (.*?):(.*?):(.*?) : Monitor and Performance Statistics \(Since Factory\)/) |
|
{ |
|
$port = $1; |
|
$box = $2; |
|
$bay = $3; |
|
$skip_blank_line = 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
port => $port, |
|
box => $box, |
|
bay => $bay, |
|
}}); |
|
} |
|
|
|
if ($in_cache_config_status) |
|
{ |
|
if ($line =~ /Parity Read Errors (\d+) \(/) |
|
{ |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{'diagnostics'}{cache}{parity_read_errors} = $1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::diagnostics::cache::parity_read_errors" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{'diagnostics'}{cache}{parity_read_errors}, |
|
}}); |
|
} |
|
if ($line =~ /Parity Write Errors (\d+) \(/) |
|
{ |
|
$anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{'diagnostics'}{cache}{parity_write_errors} = $1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"controller::${scan_hpacucli_controller_serial_number}::diagnostics::cache::parity_write_errors" => $anvil->data->{controller}{$scan_hpacucli_controller_serial_number}{'diagnostics'}{cache}{parity_write_errors}, |
|
}}); |
|
} |
|
} |
|
|
|
if (($port) && ($box) && ($bay)) |
|
{ |
|
my $location = $port.":".$box.":".$bay; |
|
$scan_hpacucli_physical_drive_serial_number = $anvil->data->{physical_drive}{by_location}{$location}; |
|
|
|
if ($line =~ /Read Errors Hard (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_hard} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::read_errors_hard" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_hard}, |
|
}}); |
|
} |
|
if ($line =~ /Read Errors Retry Recovered (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_retry_recovered} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::read_errors_retry_recovered" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_retry_recovered}, |
|
}}); |
|
} |
|
if ($line =~ /Read Errors ECC Corrected (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_ecc_corrected} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::read_errors_ecc_corrected" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{read_errors_ecc_corrected}, |
|
}}); |
|
} |
|
if ($line =~ /Write Errors Hard (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{write_errors_hard} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::write_errors_hard" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{write_errors_hard}, |
|
}}); |
|
} |
|
if ($line =~ /Write Errors Retry Recovered (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{write_errors_retry_recovered} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::write_errors_retry_recovered" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{write_errors_retry_recovered}, |
|
}}); |
|
} |
|
if ($line =~ /Format Errors (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{format_errors} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::format_errors" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{format_errors}, |
|
}}); |
|
} |
|
if ($line =~ /Write Errors After Remap (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{write_errors_after_remap} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::write_errors_after_remap" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{write_errors_after_remap}, |
|
}}); |
|
} |
|
if ($line =~ /Hardware Errors (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{hardware_errors} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::hardware_errors" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{hardware_errors}, |
|
}}); |
|
} |
|
if ($line =~ /Predictive Failure Errors (0x.*?)$/) |
|
{ |
|
my $hex = $1; |
|
$anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{predictive_failure_errors} = hex($hex); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
"hex" => $hex, |
|
"physical_drive::${scan_hpacucli_physical_drive_serial_number}::diagnostics::predictive_failure_errors" => $anvil->data->{physical_drive}{$scan_hpacucli_physical_drive_serial_number}{'diagnostics'}{predictive_failure_errors}, |
|
}}); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
# This gathers the various data from the controller(s). |
|
sub gather_data |
|
{ |
|
my ($anvil) = @_; |
|
|
|
### TODO: This assumes the controllers go 0, 1, ... n. If this is wrong, we'll need to call |
|
### 'hpacucli controller all show' and parse the output as our outer loop. |
|
# Loops through reach found controller. |
|
foreach my $count (1..$anvil->data->{'scan-hpacucli'}{sys}{controller_count}) |
|
{ |
|
my $controller = $count - 1; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { controller => $controller }}); |
|
|
|
# Read in controller data. |
|
my $scan_hpacucli_controller_serial_number = get_controller_info($anvil, $controller); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hpacucli_controller_serial_number => $scan_hpacucli_controller_serial_number }}); |
|
|
|
get_diagnostics($anvil, $controller); |
|
} |
|
|
|
return(0); |
|
} |
|
|
|
# This processes variable names to flatten them and remove spaces and special characters. |
|
sub process_variable_name |
|
{ |
|
my ($anvil, $variable) = @_; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "<< variable" => $variable }}); |
|
|
|
$variable = lc($variable); |
|
$variable =~ s/ /_/g; |
|
$variable =~ s/-/_/g; |
|
$variable =~ s/&/and/g; |
|
$variable =~ s/\//_or_/g; |
|
$variable =~ s/_%/_percent/g; |
|
$variable =~ s/{_}+/_/g; |
|
$variable =~ s/^_+//g; |
|
$variable =~ s/_+$//g; |
|
$variable =~ s/(\w)\(/$1_\(/; |
|
$variable =~ s/\((.*?)\)/-_$1/g; |
|
$variable =~ s/_+/_/g; |
|
|
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { ">> variable" => $variable }}); |
|
return($variable); |
|
} |
|
|
|
# This does two things; It checks to see if hpacucli is installed (exits '1' if not, exits '2' if not |
|
# executable) and then checks to see if any controllers are found in the system (exits '3' if not). |
|
sub find_hp_controllers |
|
{ |
|
my ($anvil) = @_; |
|
|
|
|
|
# This will keep track of how many controllers we find. |
|
my $controller_count = 0; |
|
|
|
# First, do we have hpacucli installed? |
|
if (not -e $anvil->data->{path}{exe}{hpacucli}) |
|
{ |
|
# Nope, exit. |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 2, key => "scan_hpacucli_error_0001", variables => { path => $anvil->data->{path}{exe}{hpacucli} }}); |
|
$anvil->nice_exit({exit_code => 1}); |
|
} |
|
|
|
# Make sure it is executable |
|
if (not -x $anvil->data->{path}{exe}{hpacucli}) |
|
{ |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 0, key => "scan_hpacucli_error_0002", variables => { path => $anvil->data->{path}{exe}{hpacucli} }}); |
|
$anvil->nice_exit({exit_code => 2}); |
|
} |
|
|
|
# Still alive? Good! Look for controllers now. |
|
my $shell_call = $anvil->data->{path}{exe}{hpacucli}." controller all show"; |
|
my ($output, $return_code) = $anvil->System->call({shell_call => $shell_call}); |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
output => $output, |
|
return_code => $return_code, |
|
}}); |
|
foreach my $line (split/\n/, $output) |
|
{ |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { line => $line }}); |
|
|
|
if ($line =~ /.*? Slot (\d+) .*?\(sn: (.*?)\)/i) |
|
{ |
|
my $controller_number = $1; |
|
my $controller_serial_number = $2; |
|
$controller_count++; |
|
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
controller_number => $controller_number, |
|
controller_serial_number => $controller_serial_number, |
|
controller_count => $controller_count, |
|
}}); |
|
} |
|
} |
|
|
|
# Have we any controllers? |
|
if ($controller_count > 0) |
|
{ |
|
$anvil->data->{'scan-hpacucli'}{sys}{controller_count} = $controller_count; |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 3, key => "scan_hpacucli_log_0001", variables => { count => $anvil->data->{'scan-hpacucli'}{sys}{controller_count} }}); |
|
} |
|
else |
|
{ |
|
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 1, level => 0, key => "scan_hpacucli_error_0003", variables => { path => $anvil->data->{path}{exe}{hpacucli} }}); |
|
$anvil->nice_exit({exit_code => 3}); |
|
} |
|
|
|
return(0); |
|
}
|
|
|