seasharp
/
anvil
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Local modifications to ClusterLabs/Anvil by Alteeve
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1914 Commits
2 Branches
0 Tags
21 MiB
 
 
 
 
 
 
Tag: Branch: Tree: c1a3f8099d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c1a3f8099d'
${ noResults }
anvil/scancore-agents/scan-hardware/scan-hardware

1602 lines
84 KiB
Raw Blame History

#!/usr/bin/perl
#
# This scans the scan_hardware, like RAM modules, CSS LED status, CPU information, etc.
#
# Examples;
#
# Exit codes;
# 0 = Normal exit.
# 1 = Startup failure (not running as root, no DB, bad file read, etc)
#
# TODO:
# - Finish System->parse_lwhw(), lots of good stuff in there.
# - We can figure out what is using swap with:
# - for file in /proc/*/status ; do awk '/VmSwap|Name/{printf $2 " " $3}END{ print ""}' $file; done | grep kB
#
use strict;
use warnings;
use Anvil::Tools;
use Data::Dumper;
# 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});
}
# These are the threasholds for when to alert when swap is running out.
$anvil->data->{scancore}{'scan-hardware'}{disable} = 0;
$anvil->data->{scancore}{'scan-hardware'}{ram}{clear_threshold} = 134217728; # 128 MiB
$anvil->data->{scancore}{'scan-hardware'}{ram}{high_threshold} = 1073741824; # 1 GiB
$anvil->data->{scancore}{'scan-hardware'}{score}{less_ram} = 5;
$anvil->data->{scancore}{'scan-hardware'}{swap}{clear_threshold} = 25;
$anvil->data->{scancore}{'scan-hardware'}{swap}{high_threshold} = 75;
$anvil->data->{switches}{force} = 0;
$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->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});
}
# Read the data.
collect_data($anvil);
# Load stored data.
read_last_scan($anvil);
# Look for changes.
find_changes($anvil);
# Finally, process health weights.
process_health($anvil);
# Shut down.
$anvil->ScanCore->agent_shutdown({agent => $THIS_FILE});
#############################################################################################################
# Functions #
#############################################################################################################
# This reads in data about the CPU
sub collect_cpu_data
{
my ($anvil) = @_;
my $total_cores = 0;
my $total_threads = 0;
my $cores = 0;
my $threads = 0;
my $sockets = 0;
my $in_cpu = "";
my ($output, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{dmidecode}." --type processor", source => $THIS_FILE, line => __LINE__});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { output => $output, return_code => $return_code }});
foreach my $line (split/\n/, $output)
{
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { line => $line }});
if ($line =~ /Socket Designation: (.*+)$/)
{
$in_cpu = $1;
$sockets++;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
in_cpu => $in_cpu,
sockets => $sockets,
}});
}
elsif (not $line)
{
$in_cpu = "";
$cores = 0;
$threads = 0;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
in_cpu => $in_cpu,
cores => $cores,
threads => $threads,
}});
}
next if $in_cpu eq "";
if ($line =~ /Core Count: (\d+)$/)
{
$cores = $1;
$total_cores += $cores;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
cores => $cores,
total_cores => $total_cores,
}});
}
if ($line =~ /Thread Count: (\d+)$/)
{
$threads = $1;
$total_threads += $threads;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
threads => $threads,
total_threads => $total_threads,
}});
}
}
# Read in /proc/cpuinfo.
my $flags = "";
my $flags_mismatch = 0;
my $bugs = "";
my $bugs_mismatch = 0;
my $model = "";
my $model_mismatch = 0;
my $cpu_info = $anvil->Storage->read_file({debug => 3, file => $anvil->data->{path}{proc}{cpuinfo}});
foreach my $line (split/\n/, $cpu_info)
{
$line = $anvil->Words->clean_spaces({string => $line});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { line => $line }});
if ($line =~ /^flags\s*: (.*?)$/)
{
my $these_flags = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { these_flags => $these_flags }});
if (not $flags)
{
$flags = $these_flags;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { flags => $flags }});
}
elsif ($flags ne $these_flags)
{
# This should never happen.
$flags_mismatch = 1;
my $changed = $anvil->Alert->check_alert_sent({
debug => 2,
record_locator => "scan_hardware::cpu_flags_mismatch",
set_by => $THIS_FILE,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }});
if ($changed)
{
# Register an alert.
my $variables = {
these_flags => $these_flags,
flags => $flags,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0001", variables => $variables});
$anvil->Alert->register({
alert_level => "notice",
message => "scan_hardware_alert_0001",
variables => $variables,
set_by => $THIS_FILE,
});
}
}
}
if ($line =~ /^bugs\s*: (.*?)$/)
{
my $these_bugs = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { these_bugs => $these_bugs }});
if (not $bugs)
{
$bugs = $these_bugs;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { bugs => $bugs }});
}
elsif ($bugs ne $these_bugs)
{
# This should never happen...
$bugs_mismatch = 1;
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::cpu_bugs_mismatch",
set_by => $THIS_FILE,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }});
if ($changed)
{
# Register an alert.
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0003", variables => {
these_bugs => $these_bugs,
bugs => $bugs,
}});
$anvil->Alert->register({
alert_level => "notice",
message => "scan_hardware_alert_0003,!!these_bugs!".$these_bugs."!!,!!bugs!".$bugs."!!",
set_by => $THIS_FILE,
});
}
}
}
if ($line =~ /^model name\s*: (.*?)$/)
{
my $this_model = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { this_model => $this_model }});
if (not $model)
{
$model = $this_model;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { model => $model }});
}
elsif ($model ne $this_model)
{
# This should never happen...
$model_mismatch = 1;
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::cpu_model_mismatch",
set_by => $THIS_FILE,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }});
if ($changed)
{
# Register an alert.
my $variables = {
this_model => $this_model,
model => $model,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0005", variables => $variables});
$anvil->Alert->register({
alert_level => "notice",
message => "scan_hardware_alert_0005",
variables => $variables,
set_by => $THIS_FILE,
});
}
}
}
}
# In the off chance that there was a flags, bugs or name mismatch before, clear it now if the issue is resolved.
if (not $flags_mismatch)
{
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::cpu_flags_mismatch",
set_by => $THIS_FILE,
clear => 1,
});
if ($changed)
{
# Register an alert-cleared event.
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0002"});
$anvil->Alert->register({
alert_level => "notice",
clear => 1,
message => "scan_hardware_alert_0002",
set_by => $THIS_FILE,
});
}
}
if (not $bugs_mismatch)
{
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::cpu_bugs_mismatch",
set_by => $THIS_FILE,
clear => 1,
});
if ($changed)
{
# Register an alert-cleared event.
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0004"});
$anvil->Alert->register({
alert_level => "notice",
clear => 1,
message => "scan_hardware_alert_0004",
set_by => $THIS_FILE,
});
}
}
if (not $model_mismatch)
{
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::cpu_model_mismatch",
set_by => $THIS_FILE,
clear => 1,
});
if ($changed)
{
# Register an alert-cleared event.
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0006"});
$anvil->Alert->register({
alert_level => "notice",
clear => 1,
message => "scan_hardware_alert_0006",
set_by => $THIS_FILE,
});
}
}
# Record what we found.
$anvil->data->{summary}{cpu}{model} = $model;
$anvil->data->{summary}{cpu}{sockets} = $sockets;
$anvil->data->{summary}{cpu}{cores} = $total_cores;
$anvil->data->{summary}{cpu}{threads} = $total_threads;
$anvil->data->{summary}{cpu}{bugs} = $bugs;
$anvil->data->{summary}{cpu}{flags} = $flags;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"summary::cpu::model" => $anvil->data->{summary}{cpu}{model},
"summary::cpu::sockets" => $anvil->data->{summary}{cpu}{sockets},
"summary::cpu::cores" => $anvil->data->{summary}{cpu}{cores},
"summary::cpu::threads" => $anvil->data->{summary}{cpu}{threads},
"summary::cpu::bugs" => $anvil->data->{summary}{cpu}{bugs},
"summary::cpu::flags" => $anvil->data->{summary}{cpu}{flags},
}});
return(0);
}
# This reads in all the data we can find on the local system
sub collect_data
{
my ($anvil) = @_;
# Collect CPU info.
collect_cpu_data($anvil);
# Collect RAM data.
collect_ram_data($anvil);
# If this is a machine with IPMI, see if we can gather more info.
collect_led_states($anvil);
return(0);
}
# If this is a machine with IPMI, see if we can gather more info.
sub collect_led_states
{
my ($anvil) = @_;
# I need to know what kind of machine I am.
my $manufacturer = "";
my $id_led = "unknown";
my $css_led = "unknown";
my $error_led = "unknown";
my ($output, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{dmidecode}." --string system-manufacturer", source => $THIS_FILE, line => __LINE__});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { output => $output, return_code => $return_code }});
foreach my $line (split/\n/, $output)
{
$manufacturer = lc($line);
# Dell can report as 'Dell Inc.'.
if ($manufacturer =~ /dell/)
{
$manufacturer = "dell";
}
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { manufacturer => $manufacturer }});
}
if ($manufacturer eq "fujitsu")
{
my ($output, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{'ipmi-oem'}." Fujitsu get-system-status", source => $THIS_FILE, line => __LINE__});
$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 ($line =~ /Identify LED: (.*)$/)
{
$id_led = lc($1);
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { id_led => $id_led }});
}
if ($line =~ /CSS LED: (.*)$/)
{
$css_led = lc($1);
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { css_led => $css_led }});
}
if ($line =~ /Global Error LED: (.*)$/)
{
$error_led = lc($1);
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { error_led => $error_led }});
}
}
}
elsif ($manufacturer eq "dell")
{
### TODO: When we get a dell, figure this out...
### TODO: There are a lot of useful bits here, including power load/headroom. Excellent data for the UI later.
#my ($output, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{'ipmi-oem'}." Dell get-system-status", source => $THIS_FILE, line => __LINE__});
#$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 }});
#}
}
# Record.
$anvil->data->{summary}{led}{id_led} = $id_led;
$anvil->data->{summary}{led}{css_led} = $css_led;
$anvil->data->{summary}{led}{error_led} = $error_led;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"summary::led::id_led" => $anvil->data->{summary}{led}{id_led},
"summary::led::css_led" => $anvil->data->{summary}{led}{css_led},
"summary::led::error_led" => $anvil->data->{summary}{led}{error_led},
}});
return(0);
}
# This reads in data about the RAM
sub collect_ram_data
{
my ($anvil) = @_;
my $total_size = 0;
my $size = "";
my $locator = "";
my $manufacturer = "";
my $part_number = "";
my $serial_number = "";
my ($output, $return_code) = $anvil->System->call({shell_call => $anvil->data->{path}{exe}{dmidecode}." --type memory", source => $THIS_FILE, line => __LINE__});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, 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 => 3, list => { line => $line }});
if ($line =~ /^Locator: (.*?)$/)
{
$locator = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { locator => $locator }});
}
if ($line =~ /^Size: (.*?)$/)
{
$size = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { size => $size }});
# If the "size" is "no module installed", we're done here.
if ($size !~ /^\d/)
{
$locator = "";
$size = "";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
locator => $locator,
size => $size,
}});
next;
}
# THis reports in 'MB' but it's really 'MiB'.
$size = $anvil->Convert->human_readable_to_bytes({
base2 => 1,
size => $size,
});
$total_size += $size;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
locator => $locator,
total_size => $total_size,
}});
}
if ($line =~ /^Manufacturer: (.*)$/)
{
$manufacturer = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { manufacturer => $manufacturer }});
}
if ($line =~ /^Part Number: (.*)$/)
{
$part_number = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { part_number => $part_number }});
}
if ($line =~ /^Serial Number: (.*)$/)
{
$serial_number = $1;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { serial_number => $serial_number }});
}
next if not $locator;
if (not $line)
{
if ($size)
{
$anvil->data->{ram}{dmi}{locator}{$locator}{size} = $size;
$anvil->data->{ram}{dmi}{locator}{$locator}{manufacturer} = $manufacturer;
$anvil->data->{ram}{dmi}{locator}{$locator}{part_number} = $part_number;
$anvil->data->{ram}{dmi}{locator}{$locator}{serial_number} = $serial_number;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"ram::dmi::locator::${locator}::size" => $anvil->Convert->add_commas({number => $anvil->data->{ram}{dmi}{locator}{$locator}{size}})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{ram}{dmi}{locator}{$locator}{size}}).")",
"ram::dmi::locator::${locator}::manufacturer" => $anvil->data->{ram}{dmi}{locator}{$locator}{manufacturer},
"ram::dmi::locator::${locator}::part_number" => $anvil->data->{ram}{dmi}{locator}{$locator}{part_number},
"ram::dmi::locator::${locator}::serial_number" => $anvil->data->{ram}{dmi}{locator}{$locator}{serial_number},
}});
}
$size = "";
$locator = "";
$manufacturer = "";
$part_number = "";
$serial_number = "";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => {
"size" => $size,
"locator" => $locator,
"manufacturer" => $manufacturer,
"part_number" => $part_number,
"serial_number" => $serial_number,
}});
}
}
my $cpu_info = $anvil->Storage->read_file({debug => 3, file => $anvil->data->{path}{proc}{meminfo}});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { cpu_info => $cpu_info }});
foreach my $line (split/\n/, $cpu_info)
{
$line = $anvil->Words->clean_spaces({string => $line});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { line => $line }});
if ($line =~ /^(.*?):\s+(\d+.*?)$/)
{
my $variable = $1;
my $size = $2;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => {
variable => $variable,
size => $size,
}});
# We care about a few variables only.
my $say_variable = "";
if ($variable eq "MemTotal")
{
$say_variable = "memory_total";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { say_variable => $say_variable }});
}
if ($variable eq "MemFree")
{
$say_variable = "memory_free";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { say_variable => $say_variable }});
}
if ($variable eq "SwapTotal")
{
$say_variable = "swap_total";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { say_variable => $say_variable }});
}
if ($variable eq "SwapFree")
{
$say_variable = "swap_free";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { say_variable => $say_variable }});
}
next if not $say_variable;
# This reports sizes as 'kB', but it's really base2.
$size = $anvil->Convert->human_readable_to_bytes({
base2 => 1,
size => $size,
});
$anvil->data->{summary}{ram}{proc}{$say_variable} = $size;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"summary::ram::proc::${say_variable}" => $anvil->Convert->add_commas({number => $anvil->data->{summary}{ram}{proc}{$say_variable}})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{summary}{ram}{proc}{$say_variable}}).")",
}});
}
}
$anvil->data->{summary}{ram}{size} = $total_size;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"summary::ram::size" => $anvil->Convert->add_commas({number => $anvil->data->{summary}{ram}{size}})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $anvil->data->{summary}{ram}{size}}).")",
}});
return(0);
}
# 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) = @_;
# Walk through what I know. First the main info, then the RAM modules below.
my $new_scan_hardware_cpu_model = $anvil->data->{summary}{cpu}{model};
my $new_scan_hardware_cpu_cores = $anvil->data->{summary}{cpu}{cores};
my $new_scan_hardware_cpu_threads = $anvil->data->{summary}{cpu}{threads};
my $new_scan_hardware_cpu_bugs = $anvil->data->{summary}{cpu}{bugs};
my $new_scan_hardware_cpu_flags = $anvil->data->{summary}{cpu}{flags};
my $new_scan_hardware_led_id = $anvil->data->{summary}{led}{id_led};
my $new_scan_hardware_led_css = $anvil->data->{summary}{led}{css_led};
my $new_scan_hardware_led_error = $anvil->data->{summary}{led}{error_led};
my $new_scan_hardware_ram_total = $anvil->data->{summary}{ram}{size}; # This is from counting the actual module capacity
my $new_scan_hardware_memory_total = $anvil->data->{summary}{ram}{proc}{memory_total}; # This is from /proc/meminfo and subtracts RAM used by shared video, etc.
my $new_scan_hardware_memory_free = $anvil->data->{summary}{ram}{proc}{memory_free};
my $new_scan_hardware_swap_total = $anvil->data->{summary}{ram}{proc}{swap_total};
my $new_scan_hardware_swap_free = $anvil->data->{summary}{ram}{proc}{swap_free};
my $new_scan_hardware_swap_used = $new_scan_hardware_swap_total - $new_scan_hardware_swap_free;
my $new_swap_used_percentage = $anvil->Convert->round({
number => (($new_scan_hardware_swap_used / $new_scan_hardware_swap_total) * 100),
places => 0,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"new_scan_hardware_cpu_model" => $new_scan_hardware_cpu_model,
"new_scan_hardware_cpu_cores" => $new_scan_hardware_cpu_cores,
"new_scan_hardware_cpu_threads" => $new_scan_hardware_cpu_threads,
"new_scan_hardware_cpu_bugs" => $new_scan_hardware_cpu_bugs,
"new_scan_hardware_cpu_flags" => $new_scan_hardware_cpu_flags,
"new_scan_hardware_led_id" => $new_scan_hardware_led_id,
"new_scan_hardware_led_css" => $new_scan_hardware_led_css,
"new_scan_hardware_ram_total" => $new_scan_hardware_ram_total,
"new_scan_hardware_led_error" => $new_scan_hardware_led_error,
"new_scan_hardware_memory_total" => $anvil->Convert->add_commas({number => $new_scan_hardware_memory_total})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_memory_total}).")",
"new_scan_hardware_memory_free" => $anvil->Convert->add_commas({number => $new_scan_hardware_memory_free})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_memory_free}).")",
"new_scan_hardware_swap_total" => $anvil->Convert->add_commas({number => $new_scan_hardware_swap_total})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_total}).")",
"new_scan_hardware_swap_free" => $anvil->Convert->add_commas({number => $new_scan_hardware_swap_free})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_free}).")",
"new_scan_hardware_swap_used" => $anvil->Convert->add_commas({number => $new_scan_hardware_swap_used})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_used}).")",
"new_swap_used_percentage" => $new_swap_used_percentage."%",
}});
# The LED status needs to be translated.
my $say_new_scan_hardware_led_id = "#!string!scan_hardware_message_0001!#";
if ($new_scan_hardware_led_id eq "on")
{
$say_new_scan_hardware_led_id = "#!string!scan_hardware_message_0002!#";
}
elsif ($new_scan_hardware_led_id eq "off")
{
$say_new_scan_hardware_led_id = "#!string!scan_hardware_message_0003!#";
}
my $say_new_scan_hardware_led_css = "#!string!scan_hardware_message_0001!#";
if ($new_scan_hardware_led_css eq "on")
{
$say_new_scan_hardware_led_css = "#!string!scan_hardware_message_0002!#";
}
elsif ($new_scan_hardware_led_css eq "off")
{
$say_new_scan_hardware_led_css = "#!string!scan_hardware_message_0003!#";
}
my $say_new_scan_hardware_led_error = "#!string!scan_hardware_message_0001!#";
if ($new_scan_hardware_led_error eq "on")
{
$say_new_scan_hardware_led_error = "#!string!scan_hardware_message_0002!#";
}
elsif ($new_scan_hardware_led_error eq "off")
{
$say_new_scan_hardware_led_error = "#!string!scan_hardware_message_0003!#";
}
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
say_new_scan_hardware_led_id => $say_new_scan_hardware_led_id,
say_new_scan_hardware_led_css => $say_new_scan_hardware_led_css,
say_new_scan_hardware_led_error => $say_new_scan_hardware_led_error,
}});
# INSERT or UPDATE?
if ((exists $anvil->data->{sql}{scan_hardware_uuid}) && ($anvil->data->{sql}{scan_hardware_uuid}))
{
# Look for changed.
my $scan_hardware_uuid = $anvil->data->{sql}{scan_hardware_uuid};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { scan_hardware_uuid => $scan_hardware_uuid }});
my $old_scan_hardware_cpu_model = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_model};
my $old_scan_hardware_cpu_cores = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_cores};
my $old_scan_hardware_cpu_threads = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_threads};
my $old_scan_hardware_cpu_bugs = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_bugs};
my $old_scan_hardware_cpu_flags = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_flags};
my $old_scan_hardware_ram_total = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_ram_total};
my $old_scan_hardware_memory_total = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_memory_total};
my $old_scan_hardware_memory_free = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_memory_free};
my $old_scan_hardware_swap_total = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_swap_total};
my $old_scan_hardware_swap_free = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_swap_free};
my $old_scan_hardware_led_id = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_led_id};
my $old_scan_hardware_led_css = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_led_css};
my $old_scan_hardware_led_error = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_led_error};
my $old_scan_hardware_modified_date = $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_modified_date};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
old_scan_hardware_cpu_model => $old_scan_hardware_cpu_model,
old_scan_hardware_cpu_cores => $old_scan_hardware_cpu_cores,
old_scan_hardware_cpu_threads => $old_scan_hardware_cpu_threads,
old_scan_hardware_cpu_bugs => $old_scan_hardware_cpu_bugs,
old_scan_hardware_cpu_flags => $old_scan_hardware_cpu_flags,
old_scan_hardware_ram_total => $old_scan_hardware_ram_total,
old_scan_hardware_memory_total => $old_scan_hardware_memory_total,
old_scan_hardware_memory_free => $old_scan_hardware_memory_free,
old_scan_hardware_swap_total => $old_scan_hardware_swap_total,
old_scan_hardware_swap_free => $old_scan_hardware_swap_free,
old_scan_hardware_led_id => $old_scan_hardware_led_id,
old_scan_hardware_led_css => $old_scan_hardware_led_css,
old_scan_hardware_led_error => $old_scan_hardware_led_error,
old_scan_hardware_modified_date => $old_scan_hardware_modified_date,
}});
my $update = 0;
if ($new_scan_hardware_cpu_model ne $old_scan_hardware_cpu_model)
{
# CPU model changed, probably from a CPU upgrade or firmware flash, so just a notice level alert.
$update = 1;
my $variables = {
new => $new_scan_hardware_cpu_model,
old => $old_scan_hardware_cpu_model,
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "notice", message => "scan_hardware_alert_0007", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0007", variables => $variables});
}
if ($new_scan_hardware_cpu_bugs ne $old_scan_hardware_cpu_bugs)
{
# This is probably from a CPU upgrade or firward flash
$update = 1;
my $variables = {
new => $new_scan_hardware_cpu_bugs,
old => $old_scan_hardware_cpu_bugs,
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "notice", message => "scan_hardware_alert_0008", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0008", variables => $variables});
}
if ($new_scan_hardware_cpu_flags ne $old_scan_hardware_cpu_flags)
{
# This is probably from a CPU upgrade or firward flash
$update = 1;
my $variables = {
new => $new_scan_hardware_cpu_flags,
old => $old_scan_hardware_cpu_flags,
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "notice", message => "scan_hardware_alert_0009", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0009", variables => $variables});
}
if ($new_scan_hardware_cpu_cores ne $old_scan_hardware_cpu_cores)
{
# This is probably from a CPU upgrade
$update = 1;
my $variables = {
new => $new_scan_hardware_cpu_cores,
old => $old_scan_hardware_cpu_cores,
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "notice", message => "scan_hardware_alert_0010", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0010", variables => $variables});
}
if ($new_scan_hardware_cpu_threads ne $old_scan_hardware_cpu_threads)
{
# This is probably from a CPU upgrade
$update = 1;
my $variables = {
new => $new_scan_hardware_cpu_threads,
old => $old_scan_hardware_cpu_threads,
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "notice", message => "scan_hardware_alert_0011", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0011", variables => $variables});
}
if ($new_scan_hardware_ram_total ne $old_scan_hardware_ram_total)
{
# If the RAM (from dmidecode) has increased, it's a safe upgrade. If it's a decrease,
# it's likely a failure.
if ($old_scan_hardware_ram_total > $new_scan_hardware_ram_total)
{
# It dropped, alarm
$update = 1;
my $difference = $old_scan_hardware_ram_total - $new_scan_hardware_ram_total;
my $variables = {
new => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_ram_total})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_ram_total})." #!string!scan_hardware_unit_0001!#)",
old => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_ram_total})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_ram_total})." #!string!scan_hardware_unit_0001!#)",
difference => $anvil->Convert->bytes_to_human_readable({'bytes' => $difference})." (".$anvil->Convert->add_commas({number => $difference})." #!string!scan_hardware_unit_0001!#)",
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "warning", message => "scan_hardware_alert_0012", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0012", variables => $variables});
}
else
{
# Increased, probably an upgrade
$update = 1;
my $difference = $new_scan_hardware_ram_total - $old_scan_hardware_ram_total;
my $variables = {
new => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_ram_total})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_ram_total})." #!string!scan_hardware_unit_0001!#)",
old => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_ram_total})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_ram_total})." #!string!scan_hardware_unit_0001!#)",
difference => $anvil->Convert->bytes_to_human_readable({'bytes' => $difference})." (".$anvil->Convert->add_commas({number => $difference})." #!string!scan_hardware_unit_0001!#)",
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "notice", message => "scan_hardware_alert_0029", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0029", variables => $variables});
}
}
if ($new_scan_hardware_memory_total ne $old_scan_hardware_memory_total)
{
# If the difference is less than 1 GiB, or the amount has grown, ignore it.
if ($old_scan_hardware_memory_total > $new_scan_hardware_memory_total)
{
my $difference = $old_scan_hardware_memory_total - $new_scan_hardware_memory_total;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { difference => $anvil->Convert->bytes_to_human_readable({'bytes' => $difference}) }});
if ($difference > 1073741824)
{
# Memory (/proc/meminfo) changed could be a hardware upgrade, or it
# could be from a failed modules. As such, we set this to 'warning'.
$update = 1;
my $variables = {
new => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_memory_total})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_memory_total})." #!string!scan_hardware_unit_0001!#)",
old => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_memory_total})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_memory_total})." #!string!scan_hardware_unit_0001!#)",
difference => $anvil->Convert->bytes_to_human_readable({'bytes' => $difference})." (".$anvil->Convert->add_commas({number => $difference})." #!string!scan_hardware_unit_0001!#)",
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "warning", message => "scan_hardware_alert_0013", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0013", variables => $variables});
}
}
}
if ($new_scan_hardware_swap_total ne $old_scan_hardware_swap_total)
{
# If the difference is less than 1 GiB, or the amount has grown, ignore it.
if ($old_scan_hardware_swap_total > $new_scan_hardware_swap_total)
{
my $difference = $old_scan_hardware_swap_total - $new_scan_hardware_swap_total;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { difference => $anvil->Convert->bytes_to_human_readable({'bytes' => $difference}) }});
if ($difference > 1073741824)
{
# Memory (/proc/meminfo) changed could be a hardware upgrade, or it
# could be from a failed modules. As such, we set this to 'warning'.
$update = 1;
my $variables = {
new => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_total})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_swap_total})." #!string!scan_hardware_unit_0001!#)",
old => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_swap_total})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_swap_total})." #!string!scan_hardware_unit_0001!#)",
difference => $anvil->Convert->bytes_to_human_readable({'bytes' => $difference})." (".$anvil->Convert->add_commas({number => $difference})." #!string!scan_hardware_unit_0001!#)",
};
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "warning", message => "scan_hardware_alert_0014", variables => $variables});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0014", variables => $variables});
}
}
}
if ($new_scan_hardware_led_id ne $old_scan_hardware_led_id)
{
$update = 1;
my $say_old_scan_hardware_led_id = "#!string!scan_hardware_message_0001!#";
if ($old_scan_hardware_led_id eq "on")
{
$say_old_scan_hardware_led_id = "#!string!scan_hardware_message_0002!#";
}
elsif ($old_scan_hardware_led_id eq "off")
{
$say_old_scan_hardware_led_id = "#!string!scan_hardware_message_0003!#";
}
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "notice", message => "scan_hardware_alert_0015,!!new!".$say_new_scan_hardware_led_id."!!,!!old!".$say_old_scan_hardware_led_id."!!"});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0015", variables => { new => $say_new_scan_hardware_led_id, old => $say_old_scan_hardware_led_id}});
}
if ($new_scan_hardware_led_css ne $old_scan_hardware_led_css)
{
# The CSS LED is an error LED, so it changing deserves to be a 'warning' level alert.
$update = 1;
my $say_old_scan_hardware_led_css = "#!string!scan_hardware_message_0001!#";
if ($old_scan_hardware_led_css eq "on")
{
$say_old_scan_hardware_led_css = "#!string!scan_hardware_message_0002!#";
}
elsif ($old_scan_hardware_led_css eq "off")
{
$say_old_scan_hardware_led_css = "#!string!scan_hardware_message_0003!#";
}
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "warning", message => "scan_hardware_alert_0016,!!new!".$say_new_scan_hardware_led_css."!!,!!old!".$say_old_scan_hardware_led_css."!!"});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0016", variables => { new => $say_new_scan_hardware_led_css, old => $say_old_scan_hardware_led_css}});
}
if ($new_scan_hardware_led_error ne $old_scan_hardware_led_error)
{
# The Hardware Error LED deserves to be a 'warning' level alert.
$update = 1;
my $say_old_scan_hardware_led_error = "#!string!scan_hardware_message_0001!#";
if ($old_scan_hardware_led_error eq "on")
{
$say_old_scan_hardware_led_error = "#!string!scan_hardware_message_0002!#";
}
elsif ($old_scan_hardware_led_error eq "off")
{
$say_old_scan_hardware_led_error = "#!string!scan_hardware_message_0003!#";
}
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "warning", message => "scan_hardware_alert_0017,!!new!".$say_new_scan_hardware_led_error."!!,!!old!".$say_old_scan_hardware_led_error."!!"});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0017", variables => { new => $say_new_scan_hardware_led_error, old => $say_old_scan_hardware_led_error}});
}
if ($new_scan_hardware_memory_free ne $old_scan_hardware_memory_free)
{
# This always changes, so it's an info-level alert
$update = 1;
my $say_new_scan_hardware_memory_free = $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_memory_free})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_memory_free})." #!string!scan_hardware_unit_0001!#)";
my $say_old_scan_hardware_memory_free = $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_memory_free})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_memory_free})." #!string!scan_hardware_unit_0001!#)";
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "info", message => "scan_hardware_alert_0018,!!new!".$say_new_scan_hardware_memory_free."!!,!!old!".$say_old_scan_hardware_memory_free."!!"});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hardware_alert_0018", variables => { new => $say_new_scan_hardware_memory_free, old => $say_old_scan_hardware_memory_free}});
}
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
new_scan_hardware_swap_free => $new_scan_hardware_swap_free,
old_scan_hardware_swap_free => $old_scan_hardware_swap_free,
}});
if ($new_scan_hardware_swap_free ne $old_scan_hardware_swap_free)
{
$update = 1;
my $say_new_scan_hardware_swap_free = $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_free})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_swap_free})." #!string!scan_hardware_unit_0001!#)";
my $say_old_scan_hardware_swap_free = $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_swap_free})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_swap_free})." #!string!scan_hardware_unit_0001!#)";
$anvil->Alert->register({set_by => $THIS_FILE, alert_level => "info", message => "scan_hardware_alert_0019,!!new!".$say_new_scan_hardware_swap_free."!!,!!old!".$say_old_scan_hardware_swap_free."!!"});
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 2, key => "scan_hardware_alert_0019", variables => { new => $say_new_scan_hardware_swap_free, old => $say_old_scan_hardware_swap_free}});
my $new_swap_bytes_used = $new_scan_hardware_swap_total - $new_scan_hardware_swap_free;
my $old_swap_bytes_used = $old_scan_hardware_swap_total - $old_scan_hardware_swap_free;
my $new_swap_percent_used = $anvil->Convert->round({number => (($new_swap_bytes_used / $new_scan_hardware_swap_total) * 100)});
my $old_swap_percent_used = $anvil->Convert->round({number => (($old_swap_bytes_used / $old_scan_hardware_swap_total) * 100)});
my $swap_percent_high = $anvil->data->{scancore}{'scan-hardware'}{swap}{high_threshold} =~ /^\d+/ ? $anvil->data->{scancore}{'scan-hardware'}{swap}{high_threshold} : 75;
my $swap_percent_low = $anvil->data->{scancore}{'scan-hardware'}{swap}{clear_threshold} =~ /^\d+/ ? $anvil->data->{scancore}{'scan-hardware'}{swap}{clear_threshold} : 25;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
's1:new_swap_bytes_used' => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_swap_bytes_used})." (".$anvil->Convert->add_commas({number => $new_swap_bytes_used})." #!string!scan_hardware_unit_0001!#)",
's2:old_swap_bytes_used' => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_swap_bytes_used})." (".$anvil->Convert->add_commas({number => $old_swap_bytes_used})." #!string!scan_hardware_unit_0001!#)",
's3:new_swap_percent_used' => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_swap_percent_used})." (".$anvil->Convert->add_commas({number => $new_swap_percent_used})." #!string!scan_hardware_unit_0001!#)",
's4:old_swap_percent_used' => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_swap_percent_used})." (".$anvil->Convert->add_commas({number => $old_swap_percent_used})." #!string!scan_hardware_unit_0001!#)",
's5:swap_percent_high' => $anvil->Convert->bytes_to_human_readable({'bytes' => $swap_percent_high})." (".$anvil->Convert->add_commas({number => $swap_percent_high})." #!string!scan_hardware_unit_0001!#)",
's6:swap_percent_low' => $anvil->Convert->bytes_to_human_readable({'bytes' => $swap_percent_low})." (".$anvil->Convert->add_commas({number => $swap_percent_low})." #!string!scan_hardware_unit_0001!#)",
}});
# Check if swap has gone over the high threshold or dropped below the clear
# threashold.
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
new_scan_hardware_swap_free => $new_scan_hardware_swap_free,
"scancore::scan-hardware::swap::high_threshold" => $anvil->data->{scancore}{'scan-hardware'}{swap}{high_threshold},
}});
if ($new_swap_used_percentage > $anvil->data->{scancore}{'scan-hardware'}{swap}{high_threshold})
{
# It's high
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::high_swap",
set_by => $THIS_FILE,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }});
if ($changed)
{
# Log and register an alert.
my $say_used = $anvil->Convert->bytes_to_human_readable({'bytes' => $new_swap_bytes_used});
my $say_swap = $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_total});
my $variables = {
say_used => $say_used,
say_swap => $say_swap,
swap_percent => $new_swap_percent_used,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 0, level => 1, key => "scan_hardware_alert_0020", variables => $variables});
$anvil->Alert->register({alert_level => "notice", message => "scan_hardware_alert_0020", variables => $variables, set_by => $THIS_FILE });
}
}
elsif ($new_swap_used_percentage < $anvil->data->{scancore}{'scan-hardware'}{swap}{clear_threshold})
{
# It's low
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::high_swap",
set_by => $THIS_FILE,
clear => 1,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }});
if ($changed)
{
# Log and register that the alert has cleared.
my $say_used = $anvil->Convert->bytes_to_human_readable({'bytes' => $new_swap_bytes_used});
my $say_swap = $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_total});
my $variables = {
say_used => $say_used,
say_swap => $say_swap,
swap_percent => $new_swap_percent_used,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 0, level => 1, key => "scan_hardware_alert_0021", variables => $variables});
$anvil->Alert->register({alert_level => "notice", message => "scan_hardware_alert_0021", variables => $variables, set_by => $THIS_FILE });
}
}
}
# Update?
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { update => $update }});
if ($update)
{
# Yup!
my $query = "
UPDATE
scan_hardware
SET
scan_hardware_cpu_model = ".$anvil->Database->quote($new_scan_hardware_cpu_model).",
scan_hardware_cpu_cores = ".$anvil->Database->quote($new_scan_hardware_cpu_cores).",
scan_hardware_cpu_threads = ".$anvil->Database->quote($new_scan_hardware_cpu_threads).",
scan_hardware_cpu_bugs = ".$anvil->Database->quote($new_scan_hardware_cpu_bugs).",
scan_hardware_cpu_flags = ".$anvil->Database->quote($new_scan_hardware_cpu_flags).",
scan_hardware_ram_total = ".$anvil->Database->quote($new_scan_hardware_ram_total).",
scan_hardware_memory_total = ".$anvil->Database->quote($new_scan_hardware_memory_total).",
scan_hardware_memory_free = ".$anvil->Database->quote($new_scan_hardware_memory_free).",
scan_hardware_swap_total = ".$anvil->Database->quote($new_scan_hardware_swap_total).",
scan_hardware_swap_free = ".$anvil->Database->quote($new_scan_hardware_swap_free).",
scan_hardware_led_id = ".$anvil->Database->quote($new_scan_hardware_led_id).",
scan_hardware_led_css = ".$anvil->Database->quote($new_scan_hardware_led_css).",
scan_hardware_led_error = ".$anvil->Database->quote($new_scan_hardware_led_error).",
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)."
WHERE
scan_hardware_uuid = ".$anvil->Database->quote($scan_hardware_uuid)."
;";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }});
$anvil->Database->write({query => $query, source => $THIS_FILE, line => __LINE__});
}
}
else
{
# New record, send an alert telling that we've found data.
my $variables = {
total_cores => $new_scan_hardware_cpu_cores,
total_threads => $new_scan_hardware_cpu_threads,
cpu_bugs => $new_scan_hardware_cpu_bugs,
cpu_flags => $new_scan_hardware_cpu_flags,
id_led => $say_new_scan_hardware_led_id,
css_led => $say_new_scan_hardware_led_css,
error_led => $say_new_scan_hardware_led_error,
ram_total_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_ram_total})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_ram_total})." #!string!scan_hardware_unit_0001!#)",
ram_memory_total => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_memory_total})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_memory_total})." #!string!scan_hardware_unit_0001!#)",
ram_memory_free => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_memory_free})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_memory_free})." #!string!scan_hardware_unit_0001!#)",
ram_swap_total => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_total})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_swap_total})." #!string!scan_hardware_unit_0001!#)",
ram_swap_free => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_swap_free})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_swap_free})." #!string!scan_hardware_unit_0001!#)",
};
$anvil->Alert->register({alert_level => "notice", message => "scan_hardware_alert_0022", variables => $variables, set_by => $THIS_FILE });
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0022", variables => $variables});
# INSERT
my $scan_hardware_uuid = $anvil->Get->uuid();
my $query = "
INSERT INTO
scan_hardware
(
scan_hardware_uuid,
scan_hardware_host_uuid,
scan_hardware_cpu_model,
scan_hardware_cpu_cores,
scan_hardware_cpu_threads,
scan_hardware_cpu_bugs,
scan_hardware_cpu_flags,
scan_hardware_ram_total,
scan_hardware_memory_total,
scan_hardware_memory_free,
scan_hardware_swap_total,
scan_hardware_swap_free,
scan_hardware_led_id,
scan_hardware_led_css,
scan_hardware_led_error,
modified_date
) VALUES (
".$anvil->Database->quote($scan_hardware_uuid).",
".$anvil->Database->quote($anvil->Get->host_uuid).",
".$anvil->Database->quote($new_scan_hardware_cpu_model).",
".$anvil->Database->quote($new_scan_hardware_cpu_cores).",
".$anvil->Database->quote($new_scan_hardware_cpu_threads).",
".$anvil->Database->quote($new_scan_hardware_cpu_bugs).",
".$anvil->Database->quote($new_scan_hardware_cpu_flags).",
".$anvil->Database->quote($new_scan_hardware_ram_total).",
".$anvil->Database->quote($new_scan_hardware_memory_total).",
".$anvil->Database->quote($new_scan_hardware_memory_free).",
".$anvil->Database->quote($new_scan_hardware_swap_total).",
".$anvil->Database->quote($new_scan_hardware_swap_free).",
".$anvil->Database->quote($new_scan_hardware_led_id).",
".$anvil->Database->quote($new_scan_hardware_led_css).",
".$anvil->Database->quote($new_scan_hardware_led_css).",
".$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 }});
$anvil->Database->write({query => $query, source => $THIS_FILE, line => __LINE__});
}
# Now the RAM modules.
foreach my $hardware_ram_module_locator (sort {$a cmp $b} keys %{$anvil->data->{ram}{dmi}{locator}})
{
my $new_scan_hardware_ram_module_size = $anvil->data->{ram}{dmi}{locator}{$hardware_ram_module_locator}{size};
my $new_scan_hardware_ram_module_manufacturer = $anvil->data->{ram}{dmi}{locator}{$hardware_ram_module_locator}{manufacturer};
my $new_scan_hardware_ram_module_model = $anvil->data->{ram}{dmi}{locator}{$hardware_ram_module_locator}{part_number};
my $new_scan_hardware_ram_module_serial_number = $anvil->data->{ram}{dmi}{locator}{$hardware_ram_module_locator}{serial_number};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
hardware_ram_module_locator => $hardware_ram_module_locator,
new_scan_hardware_ram_module_size => $anvil->Convert->add_commas({number => $new_scan_hardware_ram_module_size})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_ram_module_size}).")",
new_scan_hardware_ram_module_manufacturer => $new_scan_hardware_ram_module_manufacturer,
new_scan_hardware_ram_module_model => $new_scan_hardware_ram_module_model,
new_scan_hardware_ram_module_serial_number => $new_scan_hardware_ram_module_serial_number,
}});
if ((exists $anvil->data->{sql}{ram_module_locator_to_uuid}{$hardware_ram_module_locator}) && ($anvil->data->{sql}{ram_module_locator_to_uuid}{$hardware_ram_module_locator}))
{
# We've seen this module before, look for changes.
my $scan_hardware_ram_module_uuid = $anvil->data->{sql}{ram_module_locator_to_uuid}{$hardware_ram_module_locator};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
scan_hardware_ram_module_locator => $hardware_ram_module_locator,
scan_hardware_ram_module_uuid => $scan_hardware_ram_module_uuid,
}});
my $old_scan_hardware_ram_module_size = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_size};
my $old_scan_hardware_ram_module_manufacturer = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_manufacturer};
my $old_scan_hardware_ram_module_model = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_model};
my $old_scan_hardware_ram_module_serial_number = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_serial_number};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
old_scan_hardware_ram_module_size => $anvil->Convert->add_commas({number => $old_scan_hardware_ram_module_size})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_ram_module_size}).")",
old_scan_hardware_ram_module_manufacturer => $old_scan_hardware_ram_module_manufacturer,
old_scan_hardware_ram_module_model => $old_scan_hardware_ram_module_model,
old_scan_hardware_ram_module_serial_number => $old_scan_hardware_ram_module_serial_number,
}});
# Delete the entry so we know we've processed this existing module.
delete $anvil->data->{sql}{ram_module_locator_to_uuid}{$hardware_ram_module_locator};
delete $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid};
### We check all at once for a single alert as it's easy to see what has changed.
# Looks for changes.
if (($new_scan_hardware_ram_module_size ne $old_scan_hardware_ram_module_size) or
($new_scan_hardware_ram_module_manufacturer ne $old_scan_hardware_ram_module_manufacturer) or
($old_scan_hardware_ram_module_model ne $old_scan_hardware_ram_module_model) or
($new_scan_hardware_ram_module_serial_number ne $old_scan_hardware_ram_module_serial_number))
{
# This shouldn't change, but maybe the RAM was replaced or upgraded? It could
# be that a vanished module has returned?
if (($old_scan_hardware_ram_module_manufacturer eq "VANISHED") && ($new_scan_hardware_ram_module_manufacturer ne "VANISHED"))
{
# A vanished module has returned.
my $variables = {
locator => $hardware_ram_module_locator,
old_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_ram_module_size})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_ram_module_size})." #!string!scan_hardware_unit_0001!#)",
old_manufacturer => $old_scan_hardware_ram_module_manufacturer,
old_model => $old_scan_hardware_ram_module_model,
old_serial_number => $old_scan_hardware_ram_module_serial_number,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 0, level => 1, key => "scan_hardware_alert_0023", variables => $variables});
$anvil->Alert->register({alert_level => "warning", message => "scan_hardware_alert_0023", variables => $variables, set_by => $THIS_FILE});
}
else
{
# Something else changed.
my $variables = {
locator => $hardware_ram_module_locator,
new_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_ram_module_size})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_ram_module_size})." #!string!scan_hardware_unit_0001!#)",
new_manufacturer => $new_scan_hardware_ram_module_manufacturer,
new_model => $new_scan_hardware_ram_module_model,
new_serial_number => $new_scan_hardware_ram_module_serial_number,
old_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_ram_module_size})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_ram_module_size})." #!string!scan_hardware_unit_0001!#)",
old_manufacturer => $old_scan_hardware_ram_module_manufacturer,
old_model => $old_scan_hardware_ram_module_model,
old_serial_number => $old_scan_hardware_ram_module_serial_number,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 0, level => 1, key => "scan_hardware_alert_0024", variables => $variables});
$anvil->Alert->register({alert_level => "warning", message => "scan_hardware_alert_0024", variables => $variables, set_by => $THIS_FILE});
}
my $query = "
UPDATE
scan_hardware_ram_modules
SET
scan_hardware_ram_module_locator = ".$anvil->Database->quote($hardware_ram_module_locator).",
scan_hardware_ram_module_size = ".$anvil->Database->quote($new_scan_hardware_ram_module_size).",
scan_hardware_ram_module_manufacturer = ".$anvil->Database->quote($new_scan_hardware_ram_module_manufacturer).",
scan_hardware_ram_module_model = ".$anvil->Database->quote($new_scan_hardware_ram_module_model).",
scan_hardware_ram_module_serial_number = ".$anvil->Database->quote($new_scan_hardware_ram_module_serial_number).",
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)."
WHERE
scan_hardware_ram_module_uuid = ".$anvil->Database->quote($scan_hardware_ram_module_uuid)."
;";
# Now record the query in the array
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }});
$anvil->Database->write({query => $query, source => $THIS_FILE, line => __LINE__});
}
}
else
{
# Send an alert telling the user that we've found a new module.
my $variables = {
locator => $hardware_ram_module_locator,
size => $anvil->Convert->bytes_to_human_readable({'bytes' => $new_scan_hardware_ram_module_size})." (".$anvil->Convert->add_commas({number => $new_scan_hardware_ram_module_size})." #!string!scan_hardware_unit_0001!#)",
manufacturer => $new_scan_hardware_ram_module_manufacturer,
model => $new_scan_hardware_ram_module_model,
serial_number => $new_scan_hardware_ram_module_serial_number,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 0, level => 2, key => "scan_hardware_alert_0025", variables => $variables});
$anvil->Alert->register({alert_level => "notice", message => "scan_hardware_alert_0025", variables => $variables, set_by => $THIS_FILE});
# INSERT
my $scan_hardware_ram_module_uuid = $anvil->Get->uuid();
my $query = "
INSERT INTO
scan_hardware_ram_modules
(
scan_hardware_ram_module_host_uuid,
scan_hardware_ram_module_uuid,
scan_hardware_ram_module_locator,
scan_hardware_ram_module_size,
scan_hardware_ram_module_manufacturer,
scan_hardware_ram_module_model,
scan_hardware_ram_module_serial_number,
modified_date
) VALUES (
".$anvil->Database->quote($anvil->Get->host_uuid).",
".$anvil->Database->quote($scan_hardware_ram_module_uuid).",
".$anvil->Database->quote($hardware_ram_module_locator).",
".$anvil->Database->quote($new_scan_hardware_ram_module_size).",
".$anvil->Database->quote($new_scan_hardware_ram_module_manufacturer).",
".$anvil->Database->quote($new_scan_hardware_ram_module_model).",
".$anvil->Database->quote($new_scan_hardware_ram_module_serial_number).",
".$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 }});
$anvil->Database->write({query => $query, source => $THIS_FILE, line => __LINE__});
}
}
# Now look for left over modules we found in the database but not on the local system.
foreach my $hardware_ram_module_locator (keys %{$anvil->data->{sql}{scan_hardware_ram_module_uuid}})
{
# Module vanished!
my $scan_hardware_ram_module_uuid = $anvil->data->{sql}{ram_module_locator_to_uuid}{$hardware_ram_module_locator};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
scan_hardware_ram_module_locator => $hardware_ram_module_locator,
scan_hardware_ram_module_uuid => $scan_hardware_ram_module_uuid,
}});
my $old_scan_hardware_ram_module_size = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_size};
my $old_scan_hardware_ram_module_manufacturer = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_manufacturer};
my $old_scan_hardware_ram_module_model = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_model};
my $old_scan_hardware_ram_module_serial_number = $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_serial_number};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
old_scan_hardware_ram_module_size => $old_scan_hardware_ram_module_size,
old_scan_hardware_ram_module_manufacturer => $old_scan_hardware_ram_module_manufacturer,
old_scan_hardware_ram_module_model => $old_scan_hardware_ram_module_model,
old_scan_hardware_ram_module_serial_number => $old_scan_hardware_ram_module_serial_number,
}});
# Delete the entry so we know we've processed this existing module.
delete $anvil->data->{sql}{ram_module_locator_to_uuid}{$hardware_ram_module_locator};
delete $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid};
my $variables = {
locator => $hardware_ram_module_locator,
old_size => $anvil->Convert->bytes_to_human_readable({'bytes' => $old_scan_hardware_ram_module_size})." (".$anvil->Convert->add_commas({number => $old_scan_hardware_ram_module_size})." #!string!scan_hardware_unit_0001!#)",
old_manufacturer => $old_scan_hardware_ram_module_manufacturer,
old_model => $old_scan_hardware_ram_module_model,
old_serial_number => $old_scan_hardware_ram_module_serial_number,
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, 'print' => 0, level => 2, key => "scan_hardware_alert_0026", variables => $variables});
$anvil->Alert->register({alert_level => "warning", message => "scan_hardware_alert_0026", variables => $variables, set_by => $THIS_FILE});
my $query = "
UPDATE
scan_hardware_ram_modules
SET
scan_hardware_ram_module_manufacturer = 'VANISHED',
modified_date = ".$anvil->Database->quote($anvil->Database->refresh_timestamp)."
WHERE
scan_hardware_ram_module_uuid = ".$anvil->Database->quote($scan_hardware_ram_module_uuid)."
;";
# Now record the query in the array
$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);
}
# Here we see if our peer has more or less RAM. If we have less, we'll mark our health as degraded.
sub process_health
{
my ($anvil) = @_;
# Only do this on nodes.
my $host_type = $anvil->Get->host_type();
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { host_type => $host_type }});
return(0) if $host_type ne "node";
# Find the host_uuid for the peer's host name and UUID.
$anvil->Cluster->get_peers({debug => 2});
my $peer_is = $anvil->data->{sys}{anvil}{peer_is};
my $peer_host_name = $anvil->data->{sys}{anvil}{$peer_is}{host_name};
my $peer_host_uuid = $anvil->data->{sys}{anvil}{$peer_is}{host_uuid};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
peer_host_name => $peer_host_name,
peer_host_uuid => $peer_host_uuid,
}});
# How much RAM is on the other node?
my $query = "SELECT scan_hardware_ram_total FROM scan_hardware WHERE scan_hardware_host_uuid = ".$anvil->Database->quote($peer_host_uuid).";";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { query => $query }});
my $peer_ram_total = $anvil->Database->query({level => 2, query => $query, source => $THIS_FILE, line => __LINE__})->[0]->[0];
$peer_ram_total = 0 if not defined $peer_ram_total;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { peer_ram_total => $peer_ram_total }});
# Do we know the peer's RAM?
my $clear_alerts = 1;
if ($peer_ram_total)
{
# We don't want to freak out unless the difference is at least 1GiB
my $hardware_ram_total = $anvil->data->{summary}{ram}{size};
my $difference = $peer_ram_total - $hardware_ram_total;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
hardware_ram_total => $anvil->Convert->add_commas({number => $hardware_ram_total})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $hardware_ram_total}).")",
difference => $anvil->Convert->add_commas({number => $difference})." (".$anvil->Convert->bytes_to_human_readable({'bytes' => $difference}).")",
}});
# greater than 1 GiB (default) or less than 128 MiB (default)
if (($peer_ram_total > $hardware_ram_total) && ($difference > $anvil->data->{scancore}{'scan-hardware'}{ram}{high_threshold}))
{
# Mark us as having a fairly major health issue if this has been the case for more
# than five minutes.
my $age = $anvil->Alert->check_condition_age({
debug => 2,
name => "scan-hardware::less_ram_than_peer",
host_uuid => $anvil->Get->host_uuid,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { age => $age }});
if ($age > 300)
{
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::less_ram_than_peer",
set_by => $THIS_FILE,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }});
if ($changed)
{
# Register an alert.
my $variables = {
local_ram => $anvil->Convert->bytes_to_human_readable({'bytes' => $hardware_ram_total})." (".$anvil->Convert->add_commas({number => $hardware_ram_total})." #!string!suffix_0009!#)",
peer_ram => $anvil->Convert->bytes_to_human_readable({'bytes' => $peer_ram_total})." (".$anvil->Convert->add_commas({number => $peer_ram_total})." #!string!suffix_0009!#)",
difference => $anvil->Convert->bytes_to_human_readable({'bytes' => $difference})." (".$anvil->Convert->add_commas({number => $difference})." #!string!suffix_0009!#)",
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0027", variables => $variables});
$anvil->Alert->register({alert_level => "warning", message => "scan_hardware_alert_0027", variables => $variables, set_by => $THIS_FILE});
}
}
my ($health_uuid) = $anvil->Database->insert_or_update_health({
debug => 2,
health_agent_name => $THIS_FILE,
health_source_name => "less_ram_than_peer",
health_source_weight => $anvil->data->{scancore}{'scan-hardware'}{score}{less_ram},
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { health_uuid => $health_uuid }});
}
elsif ((not $difference) or ($difference < $anvil->data->{scancore}{'scan-hardware'}{ram}{clear_threshold}))
{
my $age = $anvil->Alert->check_condition_age({
debug => 2,
clear => 1,
name => "scan-hardware::less_ram_than_peer",
host_uuid => $anvil->Get->host_uuid,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { age => $age }});
my $changed = $anvil->Alert->check_alert_sent({
debug => 3,
record_locator => "scan_hardware::less_ram_than_peer",
set_by => $THIS_FILE,
clear => 1,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { changed => $changed }});
if ($changed)
{
# Clear the alert.
my $variables = {
ram => $anvil->Convert->bytes_to_human_readable({'bytes' => $hardware_ram_total})." (".$anvil->Convert->add_commas({number => $hardware_ram_total})." #!string!suffix_0009!#)",
};
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, key => "scan_hardware_alert_0028", variables => $variables});
$anvil->Alert->register({alert_level => "warning", message => "scan_hardware_alert_0028", variables => $variables, set_by => $THIS_FILE});
}
my ($health_uuid) = $anvil->Database->insert_or_update_health({
debug => 2,
health_agent_name => $THIS_FILE,
health_source_name => "less_ram_than_peer",
'delete' => 1,
});
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { health_uuid => $health_uuid }});
}
}
else
{
# We don't know how much RAM our peer has yet, so do nothing.
}
return(0);
}
# This reads in the last scan's data.
sub read_last_scan
{
my ($anvil) = @_;
# This calls up the entry for this host. There will only be one.
my $query = "
SELECT
scan_hardware_uuid,
scan_hardware_cpu_model,
scan_hardware_cpu_cores,
scan_hardware_cpu_threads,
scan_hardware_cpu_bugs,
scan_hardware_cpu_flags,
scan_hardware_ram_total,
scan_hardware_memory_total,
scan_hardware_memory_free,
scan_hardware_swap_total,
scan_hardware_swap_free,
scan_hardware_led_id,
scan_hardware_led_css,
scan_hardware_led_error,
floor(extract(epoch from modified_date))
FROM
scan_hardware
WHERE
scan_hardware_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,
}});
# If there are 2, then we've hit a bug where, somehow, we got listed twice.
if ($count > 1)
{
# Delete all and exit.
$anvil->Log->entry({source => $THIS_FILE, line => __LINE__, level => 1, 'print' => 1, key => "scan_hardware_log_0002", variables => { count => $count }});
my $queries = [];
push @{$queries}, "DELETE FROM history.scan_hardware_ram_modules WHERE scan_hardware_ram_module_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid).";";
push @{$queries}, "DELETE FROM scan_hardware_ram_modules WHERE scan_hardware_ram_module_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid).";";
push @{$queries}, "DELETE FROM history.scan_hardware WHERE scan_hardware_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid).";";
push @{$queries}, "DELETE FROM scan_hardware WHERE scan_hardware_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid).";";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 1, list => { query => $query }});
$anvil->Database->write({query => $queries, source => $THIS_FILE, line => __LINE__});
}
foreach my $row (@{$results})
{
# We've got an entry in the 'scan_hardware' table, so now we'll look for data in the node and
# services tables.
my $scan_hardware_uuid = $row->[0];
my $scan_hardware_cpu_model = $row->[1];
my $scan_hardware_cpu_cores = $row->[2];
my $scan_hardware_cpu_threads = $row->[3];
my $scan_hardware_cpu_bugs = $row->[4];
my $scan_hardware_cpu_flags = $row->[5];
my $scan_hardware_ram_total = $row->[6];
my $scan_hardware_memory_total = $row->[7];
my $scan_hardware_memory_free = $row->[8];
my $scan_hardware_swap_total = $row->[9];
my $scan_hardware_swap_free = $row->[10];
my $scan_hardware_led_id = $row->[11];
my $scan_hardware_led_css = $row->[12];
my $scan_hardware_led_error = $row->[13];
my $scan_hardware_modified_date = $row->[14];
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"scan_hardware_uuid" => $scan_hardware_uuid,
"scan_hardware_cpu_model" => $scan_hardware_cpu_model,
"scan_hardware_cpu_cores" => $scan_hardware_cpu_cores,
"scan_hardware_cpu_threads" => $scan_hardware_cpu_threads,
"scan_hardware_cpu_bugs" => $scan_hardware_cpu_bugs,
"scan_hardware_cpu_flags" => $scan_hardware_cpu_flags,
"scan_hardware_ram_total" => $scan_hardware_ram_total,
"scan_hardware_memory_total" => $scan_hardware_memory_total,
"scan_hardware_memory_free" => $scan_hardware_memory_free,
"scan_hardware_swap_total" => $scan_hardware_swap_total,
"scan_hardware_swap_free" => $scan_hardware_swap_free,
"scan_hardware_led_id" => $scan_hardware_led_id,
"scan_hardware_led_css" => $scan_hardware_led_css,
"scan_hardware_led_error" => $scan_hardware_led_error,
"scan_hardware_modified_date" => $scan_hardware_modified_date,
}});
# Record the hardware_uuid in an easy to find place for later when looking for changes.
$anvil->data->{sql}{scan_hardware_uuid} = $scan_hardware_uuid;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { "sql::scan_hardware_uuid" => $anvil->data->{sql}{scan_hardware_uuid} }});
# Store the old data now.
$anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid} = {
scan_hardware_cpu_model => $scan_hardware_cpu_model,
scan_hardware_cpu_cores => $scan_hardware_cpu_cores,
scan_hardware_cpu_threads => $scan_hardware_cpu_threads,
scan_hardware_cpu_bugs => $scan_hardware_cpu_bugs,
scan_hardware_cpu_flags => $scan_hardware_cpu_flags,
scan_hardware_ram_total => $scan_hardware_ram_total,
scan_hardware_memory_total => $scan_hardware_memory_total,
scan_hardware_memory_free => $scan_hardware_memory_free,
scan_hardware_swap_total => $scan_hardware_swap_total,
scan_hardware_swap_free => $scan_hardware_swap_free,
scan_hardware_led_id => $scan_hardware_led_id,
scan_hardware_led_css => $scan_hardware_led_css,
scan_hardware_led_error => $scan_hardware_led_error,
scan_hardware_modified_date => $scan_hardware_modified_date,
};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_cpu_model" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_model},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_cpu_cores" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_cores},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_cpu_threads" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_threads},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_cpu_bugs" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_bugs},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_cpu_flags" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_cpu_flags},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_ram_total" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_ram_total},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_memory_total" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_memory_total},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_memory_free" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_memory_free},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_swap_total" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_swap_total},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_swap_free" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_swap_free},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_led_id" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_led_id},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_led_css" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_led_css},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_led_error" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_led_error},
"sql::scan_hardware::scan_hardware_uuid::${scan_hardware_uuid}::scan_hardware_modified_date" => $anvil->data->{sql}{scan_hardware}{scan_hardware_uuid}{$scan_hardware_uuid}{scan_hardware_modified_date},
}});
}
undef $count;
undef $results;
# Read in the RAM module data.
$query = "
SELECT
scan_hardware_ram_module_uuid,
scan_hardware_ram_module_locator,
scan_hardware_ram_module_size,
scan_hardware_ram_module_manufacturer,
scan_hardware_ram_module_model,
scan_hardware_ram_module_serial_number
FROM
scan_hardware_ram_modules
WHERE
scan_hardware_ram_module_host_uuid = ".$anvil->Database->quote($anvil->Get->host_uuid)."
;";
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, 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})
{
# We've got an entry in the 'scan_hardware_ram_modules' table, so now we'll look for data in the node and
# services tables.
my $scan_hardware_ram_module_uuid = $row->[0];
my $scan_hardware_ram_module_locator = $row->[1];
my $scan_hardware_ram_module_size = $row->[2];
my $scan_hardware_ram_module_manufacturer = $row->[3];
my $scan_hardware_ram_module_model = $row->[4];
my $scan_hardware_ram_module_serial_number = $row->[5];
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => {
"scan_hardware_ram_module_uuid" => $scan_hardware_ram_module_uuid,
"scan_hardware_ram_module_locator" => $scan_hardware_ram_module_locator,
"scan_hardware_ram_module_size" => $scan_hardware_ram_module_size,
"scan_hardware_ram_module_manufacturer" => $scan_hardware_ram_module_manufacturer,
"scan_hardware_ram_module_model" => $scan_hardware_ram_module_model,
"scan_hardware_ram_module_serial_number" => $scan_hardware_ram_module_serial_number,
}});
# Record the scan_hardware_ram_module_uuid in an easy to find place for later when looking for changes.
$anvil->data->{sql}{ram_module_locator_to_uuid}{$scan_hardware_ram_module_locator} = $scan_hardware_ram_module_uuid;
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"sql::ram_module_locator_to_uuid::${scan_hardware_ram_module_locator}" => $anvil->data->{sql}{ram_module_locator_to_uuid}{$scan_hardware_ram_module_locator},
}});
# Store the old data now.
$anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid} = {
scan_hardware_ram_module_locator => $scan_hardware_ram_module_locator,
scan_hardware_ram_module_size => $scan_hardware_ram_module_size,
scan_hardware_ram_module_manufacturer => $scan_hardware_ram_module_manufacturer,
scan_hardware_ram_module_model => $scan_hardware_ram_module_model,
scan_hardware_ram_module_serial_number => $scan_hardware_ram_module_serial_number,
};
$anvil->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => {
"sql::scan_hardware_ram_module::scan_hardware_ram_module_uuid::${scan_hardware_ram_module_uuid}::scan_hardware_ram_module_locator" => $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_locator},
"sql::scan_hardware_ram_module::scan_hardware_ram_module_uuid::${scan_hardware_ram_module_uuid}::scan_hardware_ram_module_size" => $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_size},
"sql::scan_hardware_ram_module::scan_hardware_ram_module_uuid::${scan_hardware_ram_module_uuid}::scan_hardware_ram_module_manufacturer" => $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_manufacturer},
"sql::scan_hardware_ram_module::scan_hardware_ram_module_uuid::${scan_hardware_ram_module_uuid}::scan_hardware_ram_module_model" => $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_model},
"sql::scan_hardware_ram_module::scan_hardware_ram_module_uuid::${scan_hardware_ram_module_uuid}::scan_hardware_ram_module_serial_number" => $anvil->data->{sql}{scan_hardware_ram_module}{scan_hardware_ram_module_uuid}{$scan_hardware_ram_module_uuid}{scan_hardware_ram_module_serial_number},
}});
}
return(0);
}