#!/usr/bin/perl
use CGI;

use YAML 'LoadFile';
my $config_settings = LoadFile("/var/www/conf/backup_master_config.yaml") || die "Failed to load config: $!\n";

my $validated = 0;
foreach my $regex ( @{ $config_settings->{"valid_ips"} } ) {
        $validated = 1 if ( $ENV{REMOTE_ADDR} =~ m/^$regex/ );
}
exit if ( !$validated );

#use Data::Dumper;
my @suffix = qw{ B M G T P };
my $cgi = new CGI;
print $cgi->header("Content-Type: text/html");

use DBI;
use strict;
my $dbh = DBI->connect("DBI:mysql:database=".$config_settings->{backup_db}.";host=localhost",$config_settings->{backup_user}, $config_settings->{backup_pass}) or die("couldnt connect to db $!"); 

my $query = "SELECT * FROM backupstatepartitions";
my $sth = $dbh->prepare($query);
$sth->execute or warn $sth->errstr;

my $data = {};
my $mustgrow = {};
while (my $ref = $sth->fetchrow_hashref()) {
  $ref->{backupsize} = 1 unless $ref->{backupsize};


  if($ref->{backupsize} < $ref->{homeused} and $ref->{backupsize} != 1){
    my $key = $ref->{hostname}."-".$ref->{pnum};
    $mustgrow->{$key}->{homeused} = $ref->{homeused};
    $mustgrow->{$key}->{backupsize} = $ref->{backupsize};
    $mustgrow->{$key}->{overage} = $ref->{homeused} - $ref->{backupsize};
  }

  my $fullness = $ref->{backupused} / $ref->{backupsize};
  if($fullness > .9){
    $data->{$ref->{hostname}}->{"p".$ref->{pnum}}->{fullness} = $fullness;
    $data->{$ref->{hostname}}->{"p".$ref->{pnum}}->{backupsize} = $ref->{backupsize};
    $data->{$ref->{hostname}}->{"p".$ref->{pnum}}->{backupused} = $ref->{backupused};
    $data->{$ref->{hostname}}->{"p".$ref->{pnum}}->{backupfree} = $ref->{backupsize} - $ref->{backupused};
    if($data->{$ref->{hostname}}->{worst}){
      $data->{$ref->{hostname}}->{worst} = $fullness if($fullness > $data->{$ref->{hostname}}->{worst});
    }else{
      $data->{$ref->{hostname}}->{worst} = $fullness;
    }
  }

}

print "<html><body>\n";

print "<table>\n";
print "<tr><th>hostname</th><th>homeused</th><th>backupsize</th><th>overage</th></tr>\n";
foreach my $key (sort { $mustgrow->{$b}->{overage} <=> $mustgrow->{$a}->{overage} } keys %$mustgrow){
  printf("<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td><tr>\n",$key,mesize($mustgrow->{$key}->{homeused}),mesize($mustgrow->{$key}->{backupsize}) ,mesize($mustgrow->{$key}->{overage}));
}
print "</table>\n";


print "<table>\n";
print "<tr><th>hostname</th><th>partition</th><th>backupsize</th><th>backupused</th><th>backupfree</th><th>% full</th></tr>\n";
foreach my $server( sort { $data->{$b}->{worst} <=> $data->{$a}->{worst} } keys %$data){
  foreach my $part ( sort keys %{$data->{$server}}){
     next if $part eq "worst";
     printf("<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%d %%</td><tr>\n",
                $server,
                $part,
                mesize($data->{$server}->{$part}->{backupsize}), 
                mesize($data->{$server}->{$part}->{backupused}),
                mesize($data->{$server}->{$part}->{backupfree}),
                int(($data->{$server}->{$part}->{fullness})*100 )
           );
  }
}
print "</table>\n";

print "</body></html>\n";

sub mesize {
  my $size = shift;
  my $iterations = 0;
  while($size > 1024){
    $size = sprintf("%.2f", ( $size / 1024));
    $iterations++;
  }
  return $size." ".$suffix[$iterations];
}


