#!/usr/bin/perl
use strict;
use warnings;
use File::Slurp;
use File::Path qw(make_path);
use Fcntl qw(:flock);
use Data::Dumper;
$Data::Dumper::Sortkeys = 1;
use Directory::Queue::Normal;
use Proc::Daemon;
use FindBin qw($Bin);
use lib "$Bin/../lib";
use BackupServer;

my $obj_backup_queue_schema = { "userstring" => "string", "userdata" => "table?" };

# some default config entries
my $conf = {
  max_supervisors => 32,
  min_supervisors => 2,
  supervisor_pid_dir => "/var/run/obj-backups",
  supervisor_stop_file => "/dev/shm/objsupervisorstop",
  backup_queue_dir => "/var/spool/obj-backups/queue",
  backup_worker => "/opt/eig_linux/bin/obj-backup-worker",
  gcp_is_down_file => '/root/.config/gcp_endpoint_is_down',
  gcp_is_up_file => '/root/.config/gcp_endpoint_is_up',
};

my $args = {@ARGV};

# go into to the background
if(! defined($args->{foreground})){
  Proc::Daemon::Init();
  $Data::Dumper::Indent = 0;
}
# create backupserver object
my $bs_args = {};
$bs_args->{debug_stdout} = 1 if defined($args->{foreground});
my $bk = BackupServer->new($bs_args);

foreach my $k (keys %$conf){
  my $val = $bk->get_config_value("obj_${k}");
  # if we have a config entry, use that instead
  if(defined($val)){
    $conf->{$k} = $val;
  }
}

if(! -e $conf->{supervisor_pid_dir}){ make_path($conf->{supervisor_pid_dir}) }

my $exitflag = 0;
$SIG{INT} = sub {
  $bk->logger('LOG_NOTICE','SIG-INT RECIEVED, WILL QUIT AFTER THIS JOB!');
  $exitflag = 1;
};
$SIG{TERM} = sub {
  $bk->logger('LOG_NOTICE','SIG-TERM RECIEVED, WILL QUIT AFTER THIS JOB!');
  $exitflag = 1;
};

$bk->logger('LOG_INFO','reporting to work') if defined($args->{debug_pid});

open(my $my_pid_fd , '>', "$conf->{supervisor_pid_dir}/$$") or die "unable to open my own pidfile $!";
flock($my_pid_fd, LOCK_EX) or die "Unable to lock my own pidfile $!";

my $obj_dir_queue = Directory::Queue::Normal->new( path => $conf->{backup_queue_dir}, schema => $obj_backup_queue_schema );

if(-e $conf->{supervisor_stop_file}){
  $bk->logger('LOG_INFO',"Quitting: stopfile ".$conf->{supervisor_stop_file}." exists!");
  $exitflag = 1;
}

# the main loop
while(! $exitflag){

  # gather information to see if we should do work
  my $num_workers = count_workers();
  my $loadavg = read_file("/proc/loadavg");
  my @la = split('\s+',$loadavg);
  $bk->logger('LOG_DEBUG', sprintf("load reported at %s",int($la[0]))) if defined($args->{debug_progress});
  #my $calculated_max_supervisors = (16 - int($la[0])) * 2;
  my $calculated_max_supervisors = 32 - int($la[0]);
  $calculated_max_supervisors = $conf->{min_supervisors} if $calculated_max_supervisors < $conf->{min_supervisors};

  $bk->logger('LOG_DEBUG', "we have $num_workers of $calculated_max_supervisors $0 running");
  $bk->logger('LOG_DEBUG', "calculated_max_supervisors = $calculated_max_supervisors") if defined($args->{debug_progress});

  # do the work
  if($num_workers <= $calculated_max_supervisors){
    do_work($obj_dir_queue);
  }else{
    $bk->logger('LOG_INFO',"Quitting: $num_workers > $calculated_max_supervisors");
    $exitflag = 1;
  }
  if(-e $conf->{supervisor_stop_file}){
    $bk->logger('LOG_INFO',"Quitting: stopfile ".$conf->{supervisor_stop_file}." exists!");
    $exitflag = 1;
  }
  if( -e $conf->{gcp_is_down_file} or ! -e $conf->{gcp_is_up_file}){
    $bk->logger('LOG_INFO',"Quitting: GCP is DOWN or NOT UP!");
    $exitflag = 1;
  }
}

close($my_pid_fd);
unlink("$conf->{supervisor_pid_dir}/$$") if -e "$conf->{supervisor_pid_dir}/$$";

####################################
# Only Sub Routines below this line
####################################

sub do_work {
  my $dirq = shift;
  #find something in the queue
  for (my $name = $dirq->first(); $name; $name = $dirq->next()) {
    next if ! $dirq->lock($name);
    $bk->logger('LOG_NOTICE',sprintf("reading element %s\n", $name)) if defined($args->{debug_queue});
    my $data = $dirq->get($name);
    $bk->logger('LOG_NOTICE', "userdata: ".Dumper($data->{userdata})) if defined($args->{debug_queue});
    if(defined($data->{userdata}->{time})){
      my $time = time();
      my $min_delay = ($time - $data->{userdata}->{time}) / 60;
      $bk->logger('LOG_NOTICE',sprintf("starting work on %s %s after %.2f minutes",$data->{userdata}->{host}, $data->{userdata}->{user},$min_delay));
    }
    my $cmd = sprintf("%s host %s partition_number %s user %s",$conf->{backup_worker}, $data->{userdata}->{host}, $data->{userdata}->{partition_number}, $data->{userdata}->{user});
    $bk->logger('LOG_NOTICE', $cmd);
    system($cmd);
    $dirq->remove($name);
    return;
  }
  my $sleep_period = int(rand(30)) + 45;
  $bk->logger('LOG_NOTICE', "nothing in the queue, sleeping $sleep_period");
  sleep $sleep_period;
}

sub count_workers {
  # count supervisors that are running
  my @pid_files = read_dir($conf->{supervisor_pid_dir});
  my $count = 0;
  foreach my $pidfile(sort @pid_files){
    if($pidfile eq $$){
      $count++; #do count our own pidfile
      next;
    }
    open my $file, '>', "$conf->{supervisor_pid_dir}/$pidfile" or die "unable to open pid file $!\n";
    my $pidstatus = flock $file, LOCK_EX|LOCK_NB;
    close($file);
    if($pidstatus == 0){
      $count++;
      $bk->logger('LOG_DEBUG',"$pidfile is locked") if defined($args->{debug_pid});
    }else{
      $bk->logger('LOG_DEBUG',"$pidfile is not locked") if defined($args->{debug_pid});
      if(-M "$conf->{supervisor_pid_dir}/$pidfile" > .125){ # delete old, unlocked pids after 3 hours
        $bk->logger('LOG_WARNING',"unlinking old pidfile $pidfile that didn't get cleaned up");
        unlink "$conf->{supervisor_pid_dir}/$pidfile";
      }
    }
  }
  return $count;
}

