#!/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);
}
