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.
956 lines
28 KiB
956 lines
28 KiB
package AN::Tools::Convert; |
|
# |
|
# This module contains methods used to convert data between types |
|
# |
|
|
|
use strict; |
|
use warnings; |
|
use Data::Dumper; |
|
use Math::BigInt; |
|
|
|
our $VERSION = "3.0.0"; |
|
my $THIS_FILE = "Convert.pm"; |
|
|
|
### Methods; |
|
# add_commas |
|
# bytes_to_human_readable |
|
# cidr |
|
# hostname_to_ip |
|
# human_readable_to_bytes |
|
# round |
|
|
|
|
|
=pod |
|
|
|
=encoding utf8 |
|
|
|
=head1 NAME |
|
|
|
AN::Tools::Convert |
|
|
|
Provides all methods related to converting data. |
|
|
|
=head1 SYNOPSIS |
|
|
|
use AN::Tools; |
|
|
|
# Get a common object handle on all AN::Tools modules. |
|
my $an = AN::Tools->new(); |
|
|
|
# Access to methods using '$an->Convert->X'. |
|
# |
|
# Example using 'cidr()'; |
|
my $subnet = $an->Convert->codr({cidr => "24"}); |
|
|
|
=head1 METHODS |
|
|
|
Methods in this module; |
|
|
|
=cut |
|
sub new |
|
{ |
|
my $class = shift; |
|
my $self = {}; |
|
|
|
bless $self, $class; |
|
|
|
return ($self); |
|
} |
|
|
|
# Get a handle on the AN::Tools object. I know that technically that is a sibling module, but it makes more |
|
# sense in this case to think of it as a parent. |
|
sub parent |
|
{ |
|
my $self = shift; |
|
my $parent = shift; |
|
|
|
$self->{HANDLE}{TOOLS} = $parent if $parent; |
|
|
|
return ($self->{HANDLE}{TOOLS}); |
|
} |
|
|
|
|
|
############################################################################################################# |
|
# Public methods # |
|
############################################################################################################# |
|
|
|
=head2 add_commas |
|
|
|
This takes an integer and inserts commas to make it more readable by people. |
|
|
|
If the input string isn't a string of digits, it is simply returned as-is. |
|
|
|
Parameters; |
|
|
|
=head3 number (required) |
|
|
|
This is the number to add commas to. |
|
|
|
=cut |
|
sub add_commas |
|
{ |
|
my $self = shift; |
|
my $parameter = shift; |
|
my $an = $self->parent; |
|
|
|
# Now see if the user passed the values in a hash reference or directly. |
|
my $number = defined $parameter->{number} ? $parameter->{number} : ""; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { number => $number }}); |
|
|
|
# Remove any existing commands or leading '+' signs. |
|
$number =~ s/,//g; |
|
$number =~ s/^\+//g; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { number => $number }}); |
|
|
|
# Split on the left-most period. |
|
my ($whole, $decimal) = split/\./, $number, 2; |
|
$whole = "" if not defined $whole; |
|
$decimal = "" if not defined $decimal; |
|
|
|
# Now die if either number has a non-digit character in it. |
|
if (($whole =~ /\D/) or ($decimal =~ /\D/)) |
|
{ |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { number => $number }}); |
|
return ($number); |
|
} |
|
|
|
local($_) = $whole ? $whole : ""; |
|
|
|
1 while s/^(-?\d+)(\d{3})/$1,$2/; |
|
$whole = $_; |
|
|
|
# Put it together |
|
$number = $decimal ? "$whole.$decimal" : $whole; |
|
|
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { number => $number }}); |
|
return ($number); |
|
} |
|
|
|
=head2 bytes_to_human_readable |
|
|
|
This takes a number of bytes and converts it to a a human-readable format. Optionally, you can request the human readable size be returned using specific units. |
|
|
|
If anything goes wrong, C<< !!error!! >> is returned. |
|
|
|
* Base2 Notation; |
|
B<Term> B<Factor> C<Bytes> |
|
Yobiabyte (YiB) 2^80 1,208,925,819,614,629,174,706,176 |
|
Zebiabyte (ZiB) 2^70 1,180,591,620,717,411,303,424 |
|
Exbibyte (EiB) 2^60 1,152,921,504,606,846,976 |
|
Pebibyte (PiB) 2^50 1,125,899,906,842,624 |
|
Tebibyte (TiB) 2^40 1,099,511,627,776 |
|
Gibibyte (GiB) 2^30 1,073,741,824 |
|
Mebibyte (MiB) 2^20 1,048,576 |
|
Kibibyte (KiB) 2^10 1,024 |
|
Byte (B) 2^1 1 |
|
|
|
* Base10 Notation; |
|
B<Term> B<Factor> C<Bytes> |
|
Yottabyte (YB) 10^24 1,000,000,000,000,000,000,000,000 |
|
Zettabyte (ZB) 10^21 1,000,000,000,000,000,000,000 |
|
Exabyte (EB) 10^18 1,000,000,000,000,000,000 |
|
Petabyte (PB) 10^15 1,000,000,000,000,000 |
|
Terabyte (TB) 10^12 1,000,000,000,000 |
|
Gigabyte (GB) 10^9 1,000,000,000 |
|
Megabyte (MB) 10^6 1,000,000 |
|
Kilobyte (KB) 10^3 1,000 |
|
Byte (B) 1 1 |
|
|
|
Parameters; |
|
|
|
=head3 base2 (optional) |
|
|
|
This can be set to C<< 1 >> to return the units in base2 notation, or set to C<< 0 >> to return in base10 notation. The default is controlled by c<< sys::use_base2 >>, which is set to C<< 1 >> by default. |
|
|
|
The suffix will use C<< XiB >> when base2 notation is used and C<< XB >> will be returned for base10. |
|
|
|
=head3 bytes (required) |
|
|
|
This is the number of bytes that will be converted. This can be a signed integer. |
|
|
|
=head3 unit (optional) |
|
|
|
This is a letter |
|
|
|
=cut |
|
sub bytes_to_human_readable |
|
{ |
|
my $self = shift; |
|
my $parameter = shift; |
|
my $an = $self->parent; |
|
|
|
# Now see if the user passed the values in a hash reference or directly. |
|
my $size = defined $parameter->{'bytes'} ? $parameter->{'bytes'} : 0; |
|
my $unit = defined $parameter->{unit} ? uc($parameter->{unit}) : ""; |
|
my $base2 = defined $parameter->{base2} ? $parameter->{base2} : $an->data->{sys}{use_base2}; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
size => $size, |
|
unit => $unit, |
|
}}); |
|
|
|
# Expand exponential numbers. |
|
if ($size =~ /(\d+)e\+(\d+)/) |
|
{ |
|
my $base = $1; |
|
my $exp = $2; |
|
$size = $base; |
|
for (1..$exp) |
|
{ |
|
$size .= "0"; |
|
} |
|
} |
|
|
|
# Setup my variables. |
|
my $suffix = ""; |
|
my $human_readable_size = $size; |
|
|
|
# Store and strip the sign |
|
my $sign = ""; |
|
if ($human_readable_size =~ /^-/) |
|
{ |
|
$sign = "-"; |
|
$human_readable_size =~ s/^-//; |
|
} |
|
$human_readable_size =~ s/,//g; |
|
$human_readable_size =~ s/^\+//g; |
|
|
|
# Die if either the 'time' or 'float' has a non-digit character in it. |
|
if ($human_readable_size =~ /\D/) |
|
{ |
|
$an->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, priority => "err", key => "log_0116", variables => { |
|
method => "Convert->bytes_to_human_readable()", |
|
parameter => "hostnmae", |
|
value => $human_readable_size, |
|
}}); |
|
return ("!!error!!"); |
|
} |
|
|
|
# Do the math. |
|
if ($an->data->{sys}{use_base2}) |
|
{ |
|
# Has the user requested a certain unit to use? |
|
if ($unit) |
|
{ |
|
# Yup |
|
if ($unit =~ /Y/i) |
|
{ |
|
# Yebibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 80))); |
|
$suffix = "YiB"; |
|
} |
|
elsif ($unit =~ /Z/i) |
|
{ |
|
# Zebibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 70))); |
|
$suffix = "ZiB"; |
|
} |
|
elsif ($unit =~ /E/i) |
|
{ |
|
# Exbibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 60))); |
|
$suffix = "EiB"; |
|
} |
|
elsif ($unit =~ /P/i) |
|
{ |
|
# Pebibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 50))); |
|
$suffix = "PiB"; |
|
} |
|
elsif ($unit =~ /T/i) |
|
{ |
|
# Tebibyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (2 ** 40))); |
|
$suffix = "TiB"; |
|
} |
|
elsif ($unit =~ /G/i) |
|
{ |
|
# Gibibyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (2 ** 30))); |
|
$suffix = "GiB"; |
|
} |
|
elsif ($unit =~ /M/i) |
|
{ |
|
# Mebibyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (2 ** 20))); |
|
$suffix = "MiB"; |
|
} |
|
elsif ($unit =~ /K/i) |
|
{ |
|
# Kibibyte |
|
$human_readable_size = sprintf("%.1f", ($human_readable_size /= (2 ** 10))); |
|
$suffix = "KiB"; |
|
} |
|
else |
|
{ |
|
$suffix = "B"; |
|
} |
|
} |
|
else |
|
{ |
|
# Nope, use the most efficient. |
|
if ($human_readable_size >= (2 ** 80)) |
|
{ |
|
# Yebibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 80))); |
|
$suffix = "YiB"; |
|
} |
|
elsif ($human_readable_size >= (2 ** 70)) |
|
{ |
|
# Zebibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 70))); |
|
$suffix = "ZiB"; |
|
} |
|
elsif ($human_readable_size >= (2 ** 60)) |
|
{ |
|
# Exbibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 60))); |
|
$suffix = "EiB"; |
|
} |
|
elsif ($human_readable_size >= (2 ** 50)) |
|
{ |
|
# Pebibyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (2 ** 50))); |
|
$suffix = "PiB"; |
|
} |
|
elsif ($human_readable_size >= (2 ** 40)) |
|
{ |
|
# Tebibyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (2 ** 40))); |
|
$suffix = "TiB"; |
|
} |
|
elsif ($human_readable_size >= (2 ** 30)) |
|
{ |
|
# Gibibyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (2 ** 30))); |
|
$suffix = "GiB"; |
|
} |
|
elsif ($human_readable_size >= (2 ** 20)) |
|
{ |
|
# Mebibyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (2 ** 20))); |
|
$suffix = "MiB"; |
|
} |
|
elsif ($human_readable_size >= (2 ** 10)) |
|
{ |
|
# Kibibyte |
|
$human_readable_size = sprintf("%.1f", ($human_readable_size /= (2 ** 10))); |
|
$suffix = "KiB"; |
|
} |
|
else |
|
{ |
|
$suffix = "B"; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
# Has the user requested a certain unit to use? |
|
if ($unit) |
|
{ |
|
# Yup |
|
if ($unit =~ /Y/i) |
|
{ |
|
# Yottabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 24))); |
|
$suffix = "YB"; |
|
} |
|
elsif ($unit =~ /Z/i) |
|
{ |
|
# Zettabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 21))); |
|
$suffix = "ZB"; |
|
} |
|
elsif ($unit =~ /E/i) |
|
{ |
|
# Exabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 18))); |
|
$suffix = "EB"; |
|
} |
|
elsif ($unit =~ /P/i) |
|
{ |
|
# Petabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 15))); |
|
$suffix = "PB"; |
|
} |
|
elsif ($unit =~ /T/i) |
|
{ |
|
# Terabyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (10 ** 12))); |
|
$suffix = "TB"; |
|
} |
|
elsif ($unit =~ /G/i) |
|
{ |
|
# Gigabyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (10 ** 9))); |
|
$suffix = "GB"; |
|
} |
|
elsif ($unit =~ /M/i) |
|
{ |
|
# Megabyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (10 ** 6))); |
|
$suffix = "MB"; |
|
} |
|
elsif ($unit =~ /K/i) |
|
{ |
|
# Kilobyte |
|
$human_readable_size = sprintf("%.1f", ($human_readable_size /= (10 ** 3))); |
|
$suffix = "KB"; |
|
} |
|
else |
|
{ |
|
$suffix = "b"; |
|
} |
|
} |
|
else |
|
{ |
|
# Nope, use the most efficient. |
|
if ($human_readable_size >= (10 ** 24)) |
|
{ |
|
# Yottabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 24))); |
|
$suffix = "YB"; |
|
} |
|
elsif ($human_readable_size >= (10 ** 21)) |
|
{ |
|
# Zettabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 21))); |
|
$suffix = "ZB"; |
|
} |
|
elsif ($human_readable_size >= (10 ** 18)) |
|
{ |
|
# Exabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 18))); |
|
$suffix = "EB"; |
|
} |
|
elsif ($human_readable_size >= (10 ** 15)) |
|
{ |
|
# Petabyte |
|
$human_readable_size = sprintf("%.3f", ($human_readable_size /= (10 ** 15))); |
|
$suffix = "PB"; |
|
} |
|
elsif ($human_readable_size >= (10 ** 12)) |
|
{ |
|
# Terabyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (10 ** 12))); |
|
$suffix = "TB"; |
|
} |
|
elsif ($human_readable_size >= (10 ** 9)) |
|
{ |
|
# Gigabyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (10 ** 9))); |
|
$suffix = "GB"; |
|
} |
|
elsif ($human_readable_size >= (10 ** 6)) |
|
{ |
|
# Megabyte |
|
$human_readable_size = sprintf("%.2f", ($human_readable_size /= (10 ** 6))); |
|
$suffix = "MB"; |
|
} |
|
elsif ($human_readable_size >= (10 ** 3)) |
|
{ |
|
# Kilobyte |
|
$human_readable_size = sprintf("%.1f", ($human_readable_size /= (10 ** 3))); |
|
$suffix = "KB"; |
|
} |
|
else |
|
{ |
|
$suffix = "b"; |
|
} |
|
} |
|
} |
|
|
|
# If needed, insert commas |
|
$human_readable_size = $an->Convert->add_commas({number => $human_readable_size}); |
|
|
|
# Restore the sign. |
|
if ($sign) |
|
{ |
|
$human_readable_size = $sign.$human_readable_size; |
|
} |
|
$human_readable_size .= " ".$suffix; |
|
|
|
return($human_readable_size); |
|
} |
|
|
|
=head2 cidr |
|
|
|
This takes an IPv4 CIDR notation and returns the dotted-decimal subnet, or the reverse. |
|
|
|
# Convert a CIDR notation to a subnet. |
|
my $subnet = $an->Convert->cidr({cidr => "24"}); |
|
|
|
In the other direction; |
|
|
|
# Convert a subnet to a CIDR notation. |
|
my $cidr = $an->Convert->cidr({subnet => "255.255.255.0"}); |
|
|
|
If the input data is invalid, an empty string will be returned. |
|
|
|
=head2 Parameters; |
|
|
|
There are two parameters, each of which is optional, but one of them is required. |
|
|
|
=head3 cidr (optional) |
|
|
|
This is a CIDR notation (between 0 and 24) to convert to a dotted-decimal address. |
|
|
|
=head3 subnet (optional) |
|
|
|
This is a dotted-decimal subnet to convert to a CIDR notation. |
|
|
|
=cut |
|
sub cidr |
|
{ |
|
my $self = shift; |
|
my $parameter = shift; |
|
my $an = $self->parent; |
|
|
|
my $cidr = defined $parameter->{cidr} ? $parameter->{cidr} : ""; |
|
my $subnet = defined $parameter->{subnet} ? $parameter->{subnet} : ""; |
|
my $output = ""; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { |
|
cidr => $cidr, |
|
subnet => $subnet, |
|
}}); |
|
|
|
if ($cidr =~ /^\d{1,2}$/) |
|
{ |
|
# Convert a cidr to a subnet |
|
if ($cidr eq "0") { $output = "0.0.0.0"; } |
|
elsif ($cidr eq "1") { $output = "128.0.0.0"; } |
|
elsif ($cidr eq "2") { $output = "192.0.0.0"; } |
|
elsif ($cidr eq "3") { $output = "224.0.0.0"; } |
|
elsif ($cidr eq "4") { $output = "240.0.0.0"; } |
|
elsif ($cidr eq "5") { $output = "248.0.0.0"; } |
|
elsif ($cidr eq "6") { $output = "252.0.0.0"; } |
|
elsif ($cidr eq "7") { $output = "254.0.0.0"; } |
|
elsif ($cidr eq "8") { $output = "255.0.0.0"; } |
|
elsif ($cidr eq "9") { $output = "255.128.0.0"; } |
|
elsif ($cidr eq "10") { $output = "255.192.0.0"; } |
|
elsif ($cidr eq "11") { $output = "255.224.0.0"; } |
|
elsif ($cidr eq "12") { $output = "255.240.0.0"; } |
|
elsif ($cidr eq "13") { $output = "255.248.0.0"; } |
|
elsif ($cidr eq "14") { $output = "255.252.0.0"; } |
|
elsif ($cidr eq "15") { $output = "255.254.0.0"; } |
|
elsif ($cidr eq "16") { $output = "255.255.0.0"; } |
|
elsif ($cidr eq "17") { $output = "255.255.128.0"; } |
|
elsif ($cidr eq "18") { $output = "255.255.192.0"; } |
|
elsif ($cidr eq "19") { $output = "255.255.224.0"; } |
|
elsif ($cidr eq "20") { $output = "255.255.240.0"; } |
|
elsif ($cidr eq "21") { $output = "255.255.248.0"; } |
|
elsif ($cidr eq "22") { $output = "255.255.252.0"; } |
|
elsif ($cidr eq "23") { $output = "255.255.254.0"; } |
|
elsif ($cidr eq "24") { $output = "255.255.255.0"; } |
|
elsif ($cidr eq "25") { $output = "255.255.255.128"; } |
|
elsif ($cidr eq "26") { $output = "255.255.255.192"; } |
|
elsif ($cidr eq "27") { $output = "255.255.255.224"; } |
|
elsif ($cidr eq "28") { $output = "255.255.255.240"; } |
|
elsif ($cidr eq "29") { $output = "255.255.255.248"; } |
|
elsif ($cidr eq "30") { $output = "255.255.255.252"; } |
|
elsif ($cidr eq "31") { $output = "255.255.255.254"; } |
|
elsif ($cidr eq "32") { $output = "255.255.255.255"; } |
|
} |
|
elsif ($an->Validate->is_ipv4({ip => $subnet})) |
|
{ |
|
if ($subnet eq "0.0.0.0" ) { $output = "0"; } |
|
elsif ($subnet eq "128.0.0.0" ) { $output = "1"; } |
|
elsif ($subnet eq "192.0.0.0" ) { $output = "2"; } |
|
elsif ($subnet eq "224.0.0.0" ) { $output = "3"; } |
|
elsif ($subnet eq "240.0.0.0" ) { $output = "4"; } |
|
elsif ($subnet eq "248.0.0.0" ) { $output = "5"; } |
|
elsif ($subnet eq "252.0.0.0" ) { $output = "6"; } |
|
elsif ($subnet eq "254.0.0.0" ) { $output = "7"; } |
|
elsif ($subnet eq "255.0.0.0" ) { $output = "8"; } |
|
elsif ($subnet eq "255.128.0.0" ) { $output = "9"; } |
|
elsif ($subnet eq "255.192.0.0" ) { $output = "10"; } |
|
elsif ($subnet eq "255.224.0.0" ) { $output = "11"; } |
|
elsif ($subnet eq "255.240.0.0" ) { $output = "12"; } |
|
elsif ($subnet eq "255.248.0.0" ) { $output = "13"; } |
|
elsif ($subnet eq "255.252.0.0" ) { $output = "14"; } |
|
elsif ($subnet eq "255.254.0.0" ) { $output = "15"; } |
|
elsif ($subnet eq "255.255.0.0" ) { $output = "16"; } |
|
elsif ($subnet eq "255.255.128.0" ) { $output = "17"; } |
|
elsif ($subnet eq "255.255.192.0" ) { $output = "18"; } |
|
elsif ($subnet eq "255.255.224.0" ) { $output = "19"; } |
|
elsif ($subnet eq "255.255.240.0" ) { $output = "20"; } |
|
elsif ($subnet eq "255.255.248.0" ) { $output = "21"; } |
|
elsif ($subnet eq "255.255.252.0" ) { $output = "22"; } |
|
elsif ($subnet eq "255.255.254.0" ) { $output = "23"; } |
|
elsif ($subnet eq "255.255.255.0" ) { $output = "24"; } |
|
elsif ($subnet eq "255.255.255.128" ) { $output = "25"; } |
|
elsif ($subnet eq "255.255.255.192" ) { $output = "26"; } |
|
elsif ($subnet eq "255.255.255.224" ) { $output = "27"; } |
|
elsif ($subnet eq "255.255.255.240" ) { $output = "28"; } |
|
elsif ($subnet eq "255.255.255.248" ) { $output = "29"; } |
|
elsif ($subnet eq "255.255.255.252" ) { $output = "30"; } |
|
elsif ($subnet eq "255.255.255.254" ) { $output = "31"; } |
|
elsif ($subnet eq "255.255.255.255" ) { $output = "32"; } |
|
} |
|
|
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { output => $output }}); |
|
return($output); |
|
} |
|
|
|
=head2 hostname_to_ip |
|
|
|
This method takes a hostname and tries to convert it to an IP address. If it fails, it will return C<< 0 >>. |
|
|
|
Parameters; |
|
|
|
=head3 hostname |
|
|
|
This is the host name (or domain name) to try and convert to an IP address. |
|
|
|
=cut |
|
sub hostname_to_ip |
|
{ |
|
my $self = shift; |
|
my $parameter = shift; |
|
my $an = $self->parent; |
|
|
|
my $hostname = defined $parameter->{hostname} ? $parameter->{hostname} : ""; |
|
my $ip = 0; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { hostname => $hostname }}); |
|
|
|
if (not $hostname) |
|
{ |
|
$an->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, priority => "err", key => "log_0020", variables => { method => "Convert->hostname_to_ip()", parameter => "hostnmae" }}); |
|
return($ip); |
|
} |
|
|
|
### TODO: Check local cached information later. |
|
|
|
# Try to resolve it using 'gethostip'. |
|
my $output = $an->System->call({shell_call => $an->data->{path}{exe}{gethostip}." -d $hostname"}); |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 3, list => { output => $output }}); |
|
foreach my $line (split/\n/, $output) |
|
{ |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { line => $line }}); |
|
if ($an->Validate->is_ipv4({ip => $line})) |
|
{ |
|
$ip = $line; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { ip => $ip }}); |
|
} |
|
} |
|
|
|
return($ip); |
|
} |
|
|
|
=head2 human_readable_to_bytes |
|
|
|
This takes a "human readable" size with an ISO suffix and converts it back to a base byte size as accurately as possible. |
|
|
|
It looks for the C<< i >> in the suffix to determine if the size is base2 or base10. This can be overridden with the optional C<< base2 >> or C<< base10 >> parameters. |
|
|
|
If there is a problem, C<< !!error!! >> is returned. |
|
|
|
Parameters; |
|
|
|
=head3 base2 (optional) |
|
|
|
This tells the method to interpret the human-readable suffix as base2 notation, even if it is in the format C<< XB >> instead of C<< XiB >>. |
|
|
|
=head3 base10 (optional) |
|
|
|
This tells the method to interpret the human-readable suffix as base10 notation, even if it is in the format C<< XiB >> instead of C<< XB >>. |
|
|
|
=head3 size (required) |
|
|
|
This is the size being converted. It can be a signed integer or real number (with a decimal). If this parameter includes the size suffix, you can skip setting the c<< type >> parameter and this method will break it off automatically. |
|
|
|
=head3 type (optional) |
|
|
|
This is the unit type that represents the C<< size >> value. This does not need to be used if the C<< size >> parameter already has the suffix. |
|
|
|
This value is examined for C<< XiB >> or C<< XB >> notation to determine if the size should be interpreted as a base2 or base10 value when neither C<< base2 >> or C<< base10 >> parameters are set. |
|
|
|
=cut |
|
sub human_readable_to_bytes |
|
{ |
|
my $self = shift; |
|
my $parameter = shift; |
|
my $an = $self->parent; |
|
|
|
my $base2 = defined $parameter->{base2} ? $parameter->{base2} : 0; |
|
my $base10 = defined $parameter->{base10} ? $parameter->{base10} : 0; |
|
my $size = defined $parameter->{size} ? $parameter->{size} : 0; |
|
my $type = defined $parameter->{type} ? $parameter->{type} : 0; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
base2 => $base2, |
|
base10 => $base10, |
|
size => $size, |
|
type => $type, |
|
}}); |
|
|
|
# Start cleaning up the variables. |
|
my $value = $size; |
|
$size =~ s/ //g; |
|
$type =~ s/ //g; |
|
|
|
# Store and strip the sign, if passed |
|
my $sign = ""; |
|
if ($size =~ /^-/) |
|
{ |
|
$sign = "-"; |
|
$size =~ s/^-//; |
|
} |
|
elsif ($size =~ /^\+/) |
|
{ |
|
$sign = "+"; |
|
$size =~ s/^\+//; |
|
} |
|
|
|
# Strip any commas |
|
$size =~ s/,//g; |
|
|
|
# If I don't have a passed type, see if there is a letter or letters after the size to hack off. |
|
if ((not $type) && ($size =~ /[a-zA-Z]$/)) |
|
{ |
|
# There was |
|
($size, $type) = ($size =~ /^(.*\d)(\D+)/); |
|
} |
|
# Make the type lower close for simplicity. |
|
$type = lc($type); |
|
|
|
# Make sure that 'size' is now an integer or float. |
|
if ($size !~ /\d+[\.\d+]?/) |
|
{ |
|
# Something illegal was passed. |
|
$an->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, priority => "err", key => "log_0117", variables => { |
|
size => $size, |
|
sign => $sign, |
|
type => $type, |
|
}}); |
|
return("!!error!!"); |
|
} |
|
|
|
# If 'type' is still blank, set it to 'b'. |
|
$type = "b" if not $type; |
|
|
|
# If the type is already bytes, make sure the size is an integer and return. |
|
if ($type eq "b") |
|
{ |
|
# Something illegal was passed. |
|
if ($size =~ /\D/) |
|
{ |
|
$an->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, priority => "err", key => "log_0118", variables => { |
|
size => $size, |
|
sign => $sign, |
|
type => $type, |
|
}}); |
|
return("!!error!!"); |
|
} |
|
return ($sign.$size); |
|
} |
|
|
|
# If the "type" is "Xib" or if '$base2' is set, make sure we're running in Base2 notation. Conversly, |
|
# if the type is "Xb" or if '$base10' is set, make sure that we're running in Base10 notation. In |
|
# either case, shorten the 'type' to just the first letter to make the next sanity check simpler. |
|
if ((not $base2) && (not $base10)) |
|
{ |
|
if ($type =~ /^(\w)ib$/) |
|
{ |
|
# Make sure we're running in Base2. |
|
$type = $1; |
|
$base2 = 1; |
|
$base10 = 0; |
|
} |
|
elsif ($type =~ /^(\w)b$/) |
|
{ |
|
# Make sure we're running in Base2. |
|
$type = $1; |
|
$base2 = 0; |
|
$base10 = 1; |
|
} |
|
} |
|
|
|
# Check if we have a valid type. |
|
if (($type ne "p") && |
|
($type ne "e") && |
|
($type ne "z") && |
|
($type eq "y") && |
|
($type ne "t") && |
|
($type ne "g") && |
|
($type ne "m") && |
|
($type ne "k")) |
|
{ |
|
# Poop |
|
$an->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, priority => "err", key => "log_0119", variables => { |
|
value => $value, |
|
size => $size, |
|
type => $type, |
|
}}); |
|
return("!!error!!"); |
|
} |
|
|
|
# Now the magic... lame magic, true, but still. |
|
my $bytes = 0; |
|
if ($base10) |
|
{ |
|
if ($type eq "y") { $bytes = Math::BigInt->new('10')->bpow('24')->bmul($size); } # Yottabyte |
|
elsif ($type eq "z") { $bytes = Math::BigInt->new('10')->bpow('21')->bmul($size); } # Zettabyte |
|
elsif ($type eq "e") { $bytes = Math::BigInt->new('10')->bpow('18')->bmul($size); } # Exabyte |
|
elsif ($type eq "p") { $bytes = Math::BigInt->new('10')->bpow('15')->bmul($size); } # Petabyte |
|
elsif ($type eq "t") { $bytes = ($size * (10 ** 12)) } # Terabyte |
|
elsif ($type eq "g") { $bytes = ($size * (10 ** 9)) } # Gigabyte |
|
elsif ($type eq "m") { $bytes = ($size * (10 ** 6)) } # Megabyte |
|
elsif ($type eq "k") { $bytes = ($size * (10 ** 3)) } # Kilobyte |
|
} |
|
else |
|
{ |
|
if ($type eq "y") { $bytes = Math::BigInt->new('2')->bpow('80')->bmul($size); } # Yobibyte |
|
elsif ($type eq "z") { $bytes = Math::BigInt->new('2')->bpow('70')->bmul($size); } # Zibibyte |
|
elsif ($type eq "e") { $bytes = Math::BigInt->new('2')->bpow('60')->bmul($size); } # Exbibyte |
|
elsif ($type eq "p") { $bytes = Math::BigInt->new('2')->bpow('50')->bmul($size); } # Pebibyte |
|
elsif ($type eq "t") { $bytes = ($size * (2 ** 40)) } # Tebibyte |
|
elsif ($type eq "g") { $bytes = ($size * (2 ** 30)) } # Gibibyte |
|
elsif ($type eq "m") { $bytes = ($size * (2 ** 20)) } # Mebibyte |
|
elsif ($type eq "k") { $bytes = ($size * (2 ** 10)) } # Kibibyte |
|
} |
|
|
|
# Last, round off the byte size if it is a float. |
|
if ($bytes =~ /\./) |
|
{ |
|
$bytes = $an->Convert->round({ |
|
number => $bytes, |
|
places => 0 |
|
}); |
|
} |
|
|
|
if ($sign) |
|
{ |
|
$bytes = $sign.$bytes; |
|
} |
|
|
|
return ($bytes); |
|
} |
|
|
|
=head2 round |
|
|
|
This takes a number and rounds it to a given number of places after the decimal (defaulting to an even integer). This does financial-type rounding. |
|
|
|
If C<< -- >> is passed in, the same is returned. Any other problems will cause C<< !!error!! >> to be returned. |
|
|
|
Parameters; |
|
|
|
=head3 number (required) |
|
|
|
This is the number being rounded. |
|
|
|
=head3 places (optional) |
|
|
|
This is an integer representing how many places to round the number to. The default is C<< 0 >>, rounding the number to the closest integer. |
|
|
|
=cut |
|
sub round |
|
{ |
|
my $self = shift; |
|
my $parameter = shift; |
|
my $an = $self->parent; |
|
|
|
# Setup my numbers. |
|
my $number = $parameter->{number} ? $parameter->{number} : 0; |
|
my $places = $parameter->{places} ? $parameter->{places} : 0; |
|
$an->Log->variables({source => $THIS_FILE, line => __LINE__, level => 2, list => { |
|
number => $number, |
|
places => $places, |
|
}}); |
|
|
|
# Return if the user passed a double-dash. |
|
return('--') if $number eq "--"; |
|
|
|
# Make a copy of the passed number that I can manipulate. |
|
my $rounded_number = $number; |
|
|
|
# Take out any commas. |
|
$rounded_number =~ s/,//g; |
|
|
|
# If there is a decimal place in the number, do the smart math. Otherwise, just pad the number with |
|
# the requested number of zeros after the decimal place. |
|
if ( $rounded_number =~ /\./ ) |
|
{ |
|
# Split up the number. |
|
my ($real, $decimal) = split/\./, $rounded_number, 2; |
|
|
|
# If there is anything other than one ',' and digits, error. |
|
if (($real =~ /\D/) or ($decimal =~ /\D/)) |
|
{ |
|
$an->Log->entry({source => $THIS_FILE, line => __LINE__, level => 0, priority => "err", key => "log_0120", variables => { number => $number }}); |
|
return ("!!error!!"); |
|
} |
|
|
|
# If the number is already equal to the requested number of places after the decimal, just |
|
# return. If it is less, pad the needed number of zeros. Otherwise, start rounding. |
|
if ( length($decimal) == $places ) |
|
{ |
|
# Equal, return. |
|
return $rounded_number; |
|
} |
|
elsif ( length($decimal) < $places ) |
|
{ |
|
# Less, pad. |
|
$rounded_number = sprintf("%.${places}f", $rounded_number); |
|
} |
|
else |
|
{ |
|
# Greater than; I need to round the number. Start by getting the number of places I |
|
# need to round. |
|
my $round_diff = length($decimal) - $places; |
|
|
|
# This keeps track of whether the next (left) digit needs to be incremented. |
|
my $increase = 0; |
|
|
|
# Now loop the number of times needed to round to the requested number of places. |
|
for (1..$round_diff) |
|
{ |
|
# Reset 'increase'. |
|
$increase = 0; |
|
|
|
# Make sure I am dealing with a digit. |
|
if ($decimal =~ /(\d)$/) |
|
{ |
|
my $last_digit = $1; |
|
$decimal =~ s/$last_digit$//; |
|
if ($last_digit > 4) |
|
{ |
|
$increase = 1; |
|
if ($decimal eq "") |
|
{ |
|
$real++; |
|
} |
|
else |
|
{ |
|
$decimal++; |
|
} |
|
} |
|
} |
|
} |
|
if ($places == 0 ) |
|
{ |
|
$rounded_number = $real; |
|
} |
|
else |
|
{ |
|
$rounded_number = $real.".".$decimal; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
# This is a whole number so just pad 0s as needed. |
|
$rounded_number = sprintf("%.${places}f", $rounded_number); |
|
} |
|
|
|
# Return the number. |
|
return ($rounded_number); |
|
} |
|
|
|
# =head3 |
|
# |
|
# Private Functions; |
|
# |
|
# =cut |
|
|
|
############################################################################################################# |
|
# Private functions # |
|
#############################################################################################################
|
|
|