#!/usr/bin/perl -w

use strict;
use Getopt::Long;
use YAML qw( LoadFile );
use JSON qw( decode_json );

my $DEBUG   = 0;
my $retries = 10;

my %devbymnt;
my %mntbydev;
my $fstabmnts = {};                   #values 1 = is in fstab, 2 = our-style commented out in fstab
my $hostname  = `hostname --short`;
chomp($hostname);
my $longhostname = `hostname`;
chomp($longhostname);
my $eig_backup_dir = "/opt/eig_linux";
my $eig_backup_config = '/opt/eig_linux/etc/eig_backup.conf';
my $backup_server_config = '/opt/eig_linux/etc/backup_server_info.conf';
my $usage_log = "/var/log/eig_backup/backuphelper_history.log";
my $usage_last_log = "/var/log/eig_backup/backuphelper_last_command";
my $spool_dir = '/var/spool/eig_backup';

my $ext4options   = "defaults,noatime,nodiratime,nobarrier,data=writeback,commit=30,noexec,nosuid,_netdev   1 0";
my $xfsoptions    = "defaults,noexec,nosuid,noatime,nobarrier,nodiratime,logbufs=8,logbsize=256k   1 0";
my $nfsrooptions  = "defaults,noexec,nosuid,nodev,_netdev,noatime,intr,rsize=32768,wsize=32768,nolock,sync,tcp,soft,timeo=20,ro    0 0";
if (system("rpm -q centos-release-5 >/dev/null") == 0){
    $nfsrooptions  = "defaults,noexec,nosuid,nodev,_netdev,noatime,intr,rsize=32768,wsize=32768,sync,soft,timeo=20,ro    0 0";
}


my %eig_backup_config;
load_config();

updatemnthash(\%devbymnt, \%mntbydev, \$fstabmnts);

my $NEWVLAN = 0;

unless ($ARGV[0]) {
  usage();
}
my $mode = $ARGV[0];
my $realuser = $ENV{RUSER} || $ENV{REALUSER} || 'external_user';
open(USAGE_LOG, ">>$usage_log");
print USAGE_LOG "$realuser:$mode:" . localtime(time) . "\n";
close USAGE_LOG;
open(USAGE_LAST_LOG, ">$usage_last_log");
print USAGE_LAST_LOG "$realuser:$mode:" . localtime(time) . "\n";
close USAGE_LAST_LOG;

if ($ARGV[0] eq "incremental") {
  runincremental();
} elsif ($ARGV[0] eq "reseed") {
  runreseed($ARGV[1]);
} elsif ($ARGV[0] eq "skipuser") {
  skipuser($ARGV[1]);
} elsif ($ARGV[0] eq "setupnrbip") {
  setupnrbip();
} elsif ($ARGV[0] eq "setup") {
  setup();
} elsif ($ARGV[0] eq "update_mounts") {
  update_mounts();
} elsif ($ARGV[0] eq "unmount" or $ARGV[0] eq "umount") {
  unmount();
} elsif ($ARGV[0] eq "mount") {
  mount();
} elsif ($ARGV[0] eq "genbackupkey") {
  genbackupkey();
} elsif ($ARGV[0] eq "disable") {
  disable();
} elsif ($ARGV[0] eq "enable") {
  enable();
} elsif ($ARGV[0] eq "maint") {
  maint();
} elsif ($ARGV[0] eq "reset_queue") {
  reset_queue();
} elsif ($ARGV[0] eq "status") {
  status();
} else {
  usage();
}
quitter("success");


#subs only below this line

sub usage {

  print "
    Usage: $0 <command>

      Command               Description
      -----------------------------------------------------------------------------
      setup                 Sets up all things required for backups
      update_mounts         Update fstab mount options and remount 
      incremental           Populate queue with all users and start queuer.pl
      reseed                Populate queue with all users and start queuer.pl --reseed
      reseed <username>     Reseed backups for a single user
      skipuser <username>   Pauses backup for a single user for 7 days
      mount                 Mount backup partitions
      unmount               Unmount backup partitions and comment out of /etc/fstab
      genbackupkey          Generate SSH key pair and publish to Backup Master
      enable                Enable all backup functions
      disable               Disable all backup functons
      maint                 Go into maintenance mode.  Disable backups and unmount
      reset_queue           Resets error counts for users and enables backups
      status                Display results from backupstate

";
  exit;
}

sub genbackupkey {
  system("$eig_backup_dir/bin/genbackupkey") == 0 or die "Failed to setup new SSH keypair: $!\n";
}

sub setupnrbip {
  my $devname = 'eth1';

  if (-e '/etc/sysconfig/network-scripts/ifcfg-bond0' and -e '/etc/sysconfig/network-scripts/ifcfg-bond1') {
    #hostgator sg box
    $devname = 'bond0:bnr';
  }
  print "DEV: $devname\n";
  my $ip = `wget --timeout=10 -t 1 -q -O - https://backupmaster.bluehost.com:1443/api/newbacknetip?hostname=$longhostname`;
  chomp($ip);
  unless ($ip =~ m/^172\.16\./) {
    print "$ip smells funny!\nBAILING!\n";
    quitter("ip smells funny");
  }

  print "our IP should be: $ip\n";
  unless (system("ip addr show |grep -q ' $ip/19 '")) {
    print "ip already configured!\n";
    return;
  }
  my $bnrcfg = "/etc/sysconfig/network-scripts/ifcfg-$devname";
  if (-e $bnrcfg) {
    print "checking $bnrcfg for IPADDR: ";
    unless (system("grep IPADDR $bnrcfg")) {
      print "found!\nRefusing to go further\n";
      quitter("ip already configured");
    } else {
      print "Great, nothing found\n";
      system("/bin/mv -vf $bnrcfg /etc/sysconfig/network-scripts/old.$$.ifcfg-$devname");
    }
  }

  print "creating $devname\n";

  my $config = "DEVICE=$devname\nIPADDR=$ip\nNETMASK=255.255.224.0\nTYPE=Ethernet\nONBOOT=yes\n";
  open(CNF, ">$bnrcfg");
  print CNF $config;
  close(CNF);
  print "bringing up interface\n";
  if (system("ifup $devname")) {
    print "Fail $!\n";
    quitter("failed to bring up ip");
  }
}


sub runincremental {
  system("$eig_backup_dir/bin/populate.pl") == 0 or die "Failed to populate the queue: $!\n";
  system("nohup $eig_backup_dir/bin/queuer.pl 2>&1 > /dev/null &") == 0 or die "Failed to start the queuer: $!\n";
}

sub runreseed {
  my $user = shift;
  if ( $user ) {
    system("nohup $eig_backup_dir/bin/backup.pl --dc --user=$user --no-incremental 2>&1 > /dev/null &") == 0 or die "Failed to start the queuer: $!\n";
  } else {
    system("rm -f /var/spool/eig_backup/* ; RESEED=.reseed $eig_backup_dir/bin/populate.pl") == 0 or die "Failed to populate the queue: $!\n";
    system("nohup $eig_backup_dir/bin/queuer.pl --reseed 2>&1 > /dev/null &") == 0 or die "Failed to start the queuer: $!\n";
  }
}

sub skipuser {
  my $user = shift;
  if ( $user ) {
    if ( -e "/var/cpanel/users/$user" ) {
      system("touch $spool_dir/$user.skip") == 0 or print "Failed to touch skip file: $!\n";
      print "Skipping backups for $user for 7 days\n";
    } else {
      print "cPanel user file not found for $user, not skipping\n";
    }
  } else {
    print "No username specified\n";
  }
}

sub setup {
  my $type = ( shift || "nfs" );

  #remove iSCSI mounts if nfs
  if ( $type eq 'nfs' ) {
    remove_iscsi();
  }

  #set backup route through shared ip
  setbackuproute();

  #make sure backupmaster has accurate data
  submit_backup_data();

  #enable ssh_sync in eig_backup.conf
  enable_ssh_sync();

  #addfstab entries
  addnewbackupfstabentries($type);

  #generate ssh key to rsync to backup server
  genbackupkey();

  #mount all partitions
  mount() if ( !defined($ARGV[1]) || $ARGV[1] !~ m/nomount/ );
}

sub arebackupsactive {
  return 0 if ( -f "/opt/eig_linux/var/queuer_status" && (`ls /var/spool/eig_backup | wc -l` > 0) );
  return 1;
}

sub addnewbackupfstabentries {
  my $type = shift;
  print "Checking fstab entries\n";
  my %mnts;
  $fstabmnts = undef;
  updatemnthash(\%devbymnt, \%mntbydev, \$fstabmnts);
  foreach (keys %$fstabmnts) {
    $mnts{$_} = 1;
  }
  my $firsttime    = 1;
  my $res=`wget -O - -q 'https://backupmaster.bluehost.com:1443/api/cboxinfo?hostname=$longhostname&type=mounts'`;
  my $shouldmounts=eval {decode_json($res)} or die "Unable to parse result from backupmaster";
  chomp($shouldmounts);
  foreach my $mntpnt (keys %$shouldmounts) {
    my $plabel = $shouldmounts->{$mntpnt}->{'plabel'};
    my $num = '';
    $num = $1 if $mntpnt =~ m#/backup(\d\w?)#;
    if ($fstabmnts->{$mntpnt}) {
      if ($fstabmnts->{$mntpnt} == 3) {
        system("/scripts/clear_orphaned_virtfs_mounts --all") if ( -x "/scripts/clear_orphaned_virtfs_mounts" );
        real_unmount($mntpnt);
        system("perl -p -i -e 's#.*$mntpnt\\s.*\$##g;' /etc/fstab");
      } else {
        next;
      }
    }
    print "Setting up $mntpnt\n";
    if ($firsttime) {
      runcmd("echo '\n' >>/etc/fstab");
      $firsttime = 0;
    }
    if ($type eq "xfs") {
      my $fstabentry = "LABEL=$plabel     $mntpnt    xfs    $xfsoptions";
      print "Adding to fstab: $fstabentry\n" if $DEBUG;
      runcmd("echo '$fstabentry' >>/etc/fstab");
    } elsif ($type eq "ext4") {
      my $fstabentry = "LABEL=$plabel     $mntpnt   ext4    $ext4options";
      print "Adding to fstab: $fstabentry\n" if $DEBUG;
      runcmd("echo -e '$fstabentry' >>/etc/fstab");
    } elsif ($type eq "nfs") {
      my $fstabentry = "$backup_server_config->{backup_ip}:/backup$num    $mntpnt    nfs4    $nfsrooptions";
      print "Adding to fstab: $fstabentry\n" if $DEBUG;
      runcmd("echo -e '$fstabentry' >>/etc/fstab");
    }
    runcmd("mkdir -v $mntpnt") if ( !-d $mntpnt );
  }
  #Remove empty lines from fstab
  system('sed -i \'/^$/d\' /etc/fstab');
  updatemnthash(\%devbymnt, \%mntbydev, \$fstabmnts);
}

sub isallunmounted {
  my %curmnted;
  my %curmnted2;
  my $fstab = {};
  updatemnthash(\%curmnted, \%curmnted2, \$fstab);
  foreach (keys %curmnted) {
    return 0;
  }
  return 1;
}

sub isallmounted {
  my %curmnted;
  my %curmnted2;
  my $fstab = {};
  updatemnthash(\%curmnted, \%curmnted2, \$fstab);
  foreach (keys %$fstab) {
    return 0 unless $curmnted{$_};
  }
  return 1;
}

sub sleeper {
  my $n      = shift;
  my $oldbuf = $|;
  $| = 1;
  while ($n > 0) {
    print "$n ";
    sleep 1;
    $n--;
  }
  print "\n";
  $| = $oldbuf;
}

sub updatemnthash {
  my $dbym_ref = shift;
  my $mbyd_ref = shift;
  my $fst_ref  = shift;
  foreach (`grep '/backup' /etc/fstab`) {
    my @p = split('\s+', $_);
    if ( $p[1] =~ m#/backup#) {
      if ( $p[0] !~ m/^\s*#/ && $p[0] =~ m/^$backup_server_config->{backup_ip}\:/ ) {
        $$fst_ref->{$p[1]} = 1;
      } elsif ( $p[0] =~ m/^#BHCOMMENTED#$backup_server_config->{backup_ip}\:/ ) {
        $$fst_ref->{$p[1]} = 2;
      } else {
        $$fst_ref->{$p[1]} = 3;
      }
    }
  }
  foreach (`grep ' /backup' /proc/mounts`) {
    my @p = split('\s+', $_);
    $$dbym_ref{$p[1]} = $p[0];
    $$mbyd_ref{$p[0]} = $p[1];
  }
}

sub unmount {
  print "unmount all backups\n";
  runcmd("/scripts/clear_orphaned_virtfs_mounts --all") if ( -x "/scripts/clear_orphaned_virtfs_mounts" );
  foreach my $mntpoint (keys %devbymnt) {
    comment_out($mntpoint);
#    runcmd("grep", "backup", "/etc/fstab");
    real_unmount($mntpoint);
#    runcmd("grep", "backup", "/etc/fstab");
  }
  runcmd("/scripts/clear_orphaned_virtfs_mounts --all") if ( -x "/scripts/clear_orphaned_virtfs_mounts" );
  print "unmount all done\n";
}

sub mount {
  print "mounting all backups\n";
  my %seen;
  foreach my $mntpoint (keys %$fstabmnts, keys %devbymnt) {
    next if ($seen{$mntpoint});
    $seen{$mntpoint} = 1;
    comment_in($mntpoint);
    real_mount($mntpoint);
  }
  if (isallmounted()) {
    print "mount all done\n";
  } else {
    print "mount all failed!\n";
    exit;
  }
}

sub comment_out {
  my $mntpoint = shift;
  print "commenting out $mntpoint in fstab\n" if $DEBUG;
  $mntpoint =~ s/\//\\\//g;
  runcmd("/bin/cp /etc/fstab /opt/eig_linux/data/backups/fstab.$$." . time());
  my $cmd = "perl -p -i -e 's/^(\\d+.*\\s+$mntpoint)/#BHCOMMENTED#\$1/g' /etc/fstab";
  runcmd($cmd);
}

sub remove_iscsi {
  my $exists = 1 if ( `grep "^LABEL=.*/backup" /etc/fstab | wc -l` > 0 );
  if ($exists) {
    print "Removing iSCSI mounts\n";
    runcmd("/bin/cp /etc/fstab /opt/eig_linux/data/backups/fstab.$$." . time());
    my $cmd = "perl -p -i -e 's/^(LABEL=.*\\s+\\/backup\\d+).*\$//g' /etc/fstab";
    runcmd($cmd);
    unmount();
    print "Complete\n";
  }
}

sub comment_in {
  my $mntpoint = shift;
  print "commenting in $mntpoint in fstab\n" if $DEBUG;
  $mntpoint =~ s/\//\\\//g;
  runcmd("/bin/cp /etc/fstab /opt/eig_linux/data/backups/fstab.$$." . time());
  my $cmd = "perl -p -i -e 's/^#BHCOMMENTED#(\\d+.*\\s+$mntpoint)/\$1/g' /etc/fstab";
  runcmd($cmd);
}


sub real_unmount {
  my $mntpoint = shift;
  print "unmounting $mntpoint\n" if $DEBUG;
  runcmd("umount", "$mntpoint");
}

sub real_mount {
  my $mntpoint = shift;
  print "mounting $mntpoint\n" if $DEBUG;
  runcmd("mount", "$mntpoint");
}

sub runcmd {
  print "DEBUG running: " . join(" ", @_) . "\n" if $DEBUG;
  return system(@_);
}

sub quitter {
  my $message = shift;
  require LWP::UserAgent;
  my $ua = LWP::UserAgent->new;
  $ua->agent("backuphelper/1.0");
  my $req = HTTP::Request->new(POST => 'https://backupmaster.bluehost.com:1443/api/logger.cgi');
  $req->content_type('application/x-www-form-urlencoded');
  my $who = $ENV{RUSER} || $ENV{REALUSER} || "system";
  my $msg = join('&', ("who=$who", "what=backuphelper", "data=$mode,$message"));
  $req->content($msg);
  my $res = $ua->request($req);
  exit;
}

sub load_config {
  open(DC, "<$eig_backup_config") 
    or die "Unable to open EIG Backup config file $eig_backup_config for reading: $!";
  foreach my $line (<DC>) {
    $eig_backup_config{$1} = $2 if ($line =~ m/^([^=]+?)=(.+)$/);
  }
  close(DC);
  if ( $eig_backup_config{ssh_sync} ) {
    updatebackupinfo();
    $backup_server_config = LoadFile( $backup_server_config );
    if ( !$backup_server_config->{backup_ip} ) {
      die "No SSH host found in $backup_server_config!\n" 
    }
  }
}

sub enable_ssh_sync {
  if ( !$eig_backup_config{ssh_sync} ) {
    print "Enabling SSH rsync in $eig_backup_config\n";
    open(CONF, ">>$eig_backup_config") or die "Can't open $eig_backup_config: $!\n";
    print CONF "ssh_sync=1\n";
    close(CONF);
    load_config();
  }
}

sub updatebackupinfo {
  system("/opt/eig_linux/bin/updatebackupinfo");
}

sub disable {
  system("touch /etc/disable_backups") == 0 or die "Failed to touch /etc/disable_backups: $!\n";
  system("/opt/eig_linux/bin/backupstate --submit") == 0 or print "Failed to update backupstate: $!\n";
  print "Backups disabled\n";
}

sub enable {
  if ( -f "/etc/disable_backups" ) {
    unlink "/etc/disable_backups" || die "Failed to remove /etc/disable_backups: $!\n";
  }
  mount() if ( !isallmounted() );
  system("/opt/eig_linux/bin/backupstate --submit") == 0 or print "Failed to update backupstate: $!\n";
  print "Backups enabled\n";
}

sub reset_queue {
  if ( -d $spool_dir ) {
    opendir(SPOOL, $spool_dir);
    foreach my $file ( readdir( SPOOL ) ) {
      truncate "$spool_dir/$file", 0;
    }
    closedir SPOOL;
  }
  &enable();
}

sub status {
  print "Running backupstate to gather data...\n";
  my $status_output = `$eig_backup_dir/bin/backupstate`;
  print "$status_output\n";
}

sub maint {
  disable();
  unmount() if ( !isallunmounted() );
  print "Maintenance mode enabled\n";
}

sub setbackuproute {
  return if ( $backup_server_config->{backup_ip} =~ m/^172\.16/ );
  my $myip = `wget --timeout=10 -t 1 -q -O - https://backupmaster.bluehost.com:1443/api/newbacknetip?hostname=$longhostname`;
  if ( $myip !~ m/^\d+\.\d+\.\d+\.\d+$/ ) {
    print "Invalid host returned from backupmaster: $myip\n";
  }
  my ($gateway,$interface) = split(',', `ip route | grep ^default | awk '{print \$3","\$5}'`);
  chomp $interface;
  my $file = "/etc/sysconfig/network-scripts/route-$interface";
  my $exists = 0;
  my @contents;
  my $route_line = "$backup_server_config->{backup_ip} via $gateway dev $interface src $myip";
  if ( -f $file ) {
    open(FILE, "+<", $file) || die "Failed to open routes-$interface: $!\n";
    foreach my $line (<FILE>) {
      if ( $line =~ m/^$route_line$/ && !$exists ) {
        $exists = 1;
        push @contents, $line;
      } else {
        if ( $line =~ m/^$backup_server_config->{backup_ip}\s/ ) {
          system("route",  "del", "-host", $backup_server_config->{backup_ip});
        } else {
          push @contents, $line if ( $line !~ m/^$backup_server_config->{backup_ip}\s/ );
        }
      }
    }
  } else {
    open(FILE, ">", $file) || die "Failed to open routes-$interface: $!\n";
  }
  seek( FILE, 0, 0 );
  print FILE "$route_line\n" if ( !$exists );
  print FILE @contents if ( @contents );
  truncate( FILE, tell(FILE) );
  close FILE;
  system("/etc/sysconfig/network-scripts/ifup-routes $interface 2>/dev/null") == 0 or print "Failed to bring up route to backup server: $!\n";
}

sub submit_backup_data {
  my $myip=`dig $longhostname +short`; 
  chomp $myip;
  print "Running submitbackupdata\n";
  system("wget -O - -q \"https://backupmaster.bluehost.com:1443/api/submitbackupdata?hostname=$longhostname&ip=\'$myip\'\"");
}

sub update_mounts {
  my %mounts;
  foreach my $mount ( keys %$fstabmnts ) {
    next if ( $mount !~ m%^/backup% );
    $mounts{$mount}{mounted} = 0;
    $mounts{$mount}{mounted} = 1 if ( $devbymnt{$mount} );
  }
  open( FSTAB, "+</etc/fstab" ) || die "Failed to open fstab: $!\n";
  my @out = ();
  my $needs_update = 0;
  foreach my $line ( <FSTAB> ) {
    if ( $line =~ m%^(.*)\s(/backup\d*)\s(.*)$% ) {
      chomp $line;
      push @out, "$1    $2    nfs4    $nfsrooptions";
      $needs_update = 1;
    } else {
      chomp $line;
      push @out, $line;
    }
  }
  if ( $needs_update ) {
    seek( FSTAB, 0, 0 );
    foreach my $line ( @out ) {
      print FSTAB "$line\n";
    }
    truncate( FSTAB, tell FSTAB );
  }
  close FSTAB;
  if ( $needs_update ) {
    my $short_options = $1 if ( $nfsrooptions =~ m/^(\S+)\s/ );
    foreach my $mount ( keys %mounts ) {
      if ( $mounts{$mount}{mounted} ) {
        print "Remounting $mount\n";
        system("umount $mount && mount $mount") == 0 or print "Failed to remount $mount: $!\n";
      } else {
        print "$mount is not mounted\n";
      }
    }
  }
}
