8abb5b46e0
* Moved the check for an agent being disabled into ScanCore->agent_startup() Signed-off-by: Digimer <digimer@alteeve.ca>
5241 lines
294 KiB
Perl
Executable File
5241 lines
294 KiB
Perl
Executable File
#!/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);
|
|
}
|