#!/usr/bin/perl -w
use strict;

use Getopt::Long;
use YAML qw( LoadFile );
use JSON qw( decode_json );
use Sys::Hostname;
use lib '/opt/eig_linux/lib';
use BackupRestore;
use Data::Dumper;

my $DEBUG = ($ARGV[1] && $ARGV[1] =~ m/debug/i) ? 1 : 0;
my $longhostname  = hostname;
my $eig_backup_dir = "/opt/eig_linux";
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 $br = new BackupRestore();

my ($expected_mounts, $active_mounts, $configured_mounts);
my $ipv4_r = '(\d{1,3}\.){3}\d{1,3}';

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;

my %argmap = (
    'incremental'   => \&runincremental,
    'reseed'        => \&runreseed,
    'skipuser'      => \&skipuser,
    'setup'         => \&setup,
    'update_mounts' => \&ensure_mount_configs,
    'unmount'       => \&unmount,
    'umount'        => \&unmount,
    'mount'         => \&mount,
    'genbackupkey'  => \&genbackupkey,
    'disable'       => \&disable,
    'enable'        => \&enable,
    'maint'         => \&maint,
    'reset_queue'   => \&reset_queue,
    'status'        => \&status,
    'usage'         => \&usage,
);
if ($mode && exists $argmap{$mode}) {
    refresh_mount_info();
    $argmap{$mode}->($ARGV[1]);
} else { 
    print "Unrecognized command";
    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 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;
    print "No username specified\n" && return unless $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";
    }
}

sub setup {
    genbackupkey();
    ensure_mount_configs();
}

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

# Checks fstab or autofs.backups to make sure all mount points are defined
sub ensure_mount_configs {
    my $nfs_options  = "defaults,noexec,nosuid,nodev,_netdev,noatime,intr,rsize=32768,wsize=32768,nolock,sync,tcp,soft,timeo=20,ro    0 0";
    my $autofs_options = "-fstype=nfs4,defaults,noexec,nosuid,nodev,_netdev,noatime,rsize=32768,wsize=32768,nolock,sync,tcp,soft,timeo=20,retry=2,retrans=2,ro";

    # Make sure we have all configs we need 
    updatebackupinfo();
    $br = new BackupRestore(); # Refresh any config variables
    refresh_mount_info();
    quitter("No expected backup mounts found, is server setup in backupmaster?") unless keys %$expected_mounts;
    quitter("No valid backup server found") unless $br->{config}->{backup_ip} && $br->{config}->{backup_ip} =~ m/$ipv4_r/;

    # Unmount everything
    unmount() if !isallunmounted();

    # Wipe current configs
    runcmd("/bin/cp /etc/fstab /opt/eig_linux/data/backups/fstab.$$." . time());
    foreach my $mount (keys %$expected_mounts){ 
        my $cmd = "perl -i -ne 'print unless /^(#BHCOMMENTED#)?$ipv4_r:\\$mount\\s/' /etc/fstab";
        runcmd($cmd);
        if ( -f "/etc/auto.backups" ) { 
            my $cmd = "perl -i -ne 'print unless /^(#BHCOMMENTED#)?\\$mount\\s/' /etc/auto.backups";
            runcmd($cmd);
        }
    }

    # Setup current configs
    if ($br->{config}->{autofs}) { 
        foreach my $mount (keys %$expected_mounts){ 
            runcmd("echo -e '$mount $autofs_options $br->{config}->{backup_ip}:$mount' >> /etc/auto.backups");
        }
    } else { 
        foreach my $mount (keys %$expected_mounts){ 
            my $fstabentry = "$br->{config}->{backup_ip}:$mount    $mount    nfs4    $nfs_options";
            runcmd("echo -e '$fstabentry' >>/etc/fstab");
            mkdir $mount unless -d $mount;
        }
    }
    refresh_mount_info();

    # Mount it all up again
    mount();
}

sub isallunmounted {
    foreach my $key (keys %$expected_mounts) {
        return 0 if $active_mounts->{nfs4}->{$key};
        return 0 if $br->{config}->{autofs} && $active_mounts->{autofs}->{$key};
    }
    return 1;
}

sub isallmounted {
    foreach my $key (keys %$expected_mounts) {
        if ($br->{config}->{autofs}) {
            return 0 unless $active_mounts->{autofs}->{$key};
        } else {
            return 0 unless $active_mounts->{nfs4}->{$key};
        }
    }
    return 1;
}

# Gets the expected mounts from backup master, the active backup mounts from /proc/mounts, and the configured mounts from /etc/fstab
sub refresh_mount_info {
    ($expected_mounts, $active_mounts, $configured_mounts) = (undef, undef, undef);
    # Expected Mounts
    my $mount_cache = "/opt/eig_linux/data/backup_mount_cache.json";
    if (! -f $mount_cache) {
        updatebackupinfo();
        $br = new BackupRestore(); # Refresh any config variables
        # Cache should be fresh as updatebackupinfo refreshes it
        quitter("No mounts found!") if (! -f $mount_cache );
    }
    $expected_mounts  = decode_json(slurp($mount_cache));

    # Active Mounts 
    open (my $fh, '<', '/proc/mounts');
    while ( my $line = <$fh>) {
        chomp ($line);
        next unless $line =~ m%\s(/backup\d*)\s+(autofs|nfs4)%;
        $active_mounts->{$2}->{$1} = $line;
    }
    close $fh;

    # Configured mounts
    open ($fh, '<', '/etc/fstab');
    while ( my $line = <$fh>) {
        chomp $line;
        next unless $line =~ m%^(#BHCOMMENTED#)?$ipv4_r:(/backup\d*)\s%;
        $configured_mounts->{fstab}->{$3} = $line;
    }
    close $fh;
    if ($br->{config}->{autofs} && -f "/etc/auto.backups"){ 
        open ($fh, '<', '/etc/auto.backups');
        while ( my $line = <$fh>) {
            chomp $line;
            next unless $line =~ m%^(/backup\d+)\s%;
            $configured_mounts->{autofs}->{$1} = $line
        }
        close $fh;
    }
    if ($DEBUG) { 
        print "Expected:\n";
        print Dumper($expected_mounts);
        print "Active:\n";
        print Dumper($active_mounts);
        print "Configured:\n";
        print Dumper($configured_mounts);
    }
}

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 %$expected_mounts) {
        comment_out($mntpoint);
        runcmd("umount", "$mntpoint") if $active_mounts->{nfs4}->{$mntpoint};
    }
    runcmd("service autofs restart") if $br->{config}->{autofs};
    refresh_mount_info();
    print "unmount all done\n";
}

sub mount {
    print "mounting all backups\n";
    if ($br->{config}->{autofs}) {
        runcmd("service autofs restart");
    } else { 
        foreach my $mntpoint (keys %$expected_mounts) {
            comment_in($mntpoint);
            runcmd("mount", "$mntpoint") if !$active_mounts->{nfs4}->{$mntpoint};
        }
    }
    refresh_mount_info();
    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;
    if ($br->{config}->{autofs} && -f "/etc/auto.backups") {
        my $cmd = "perl -p -i -e 's/^($mntpoint)/#BHCOMMENTED#\$1/g' /etc/auto.backups";
        runcmd($cmd);
    } else { 
        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 comment_in {
    my $mntpoint = shift;
    print "commenting in $mntpoint in fstab\n" if $DEBUG;
    $mntpoint =~ s/\//\\\//g;
    if ($br->{config}->{autofs} && -f "/etc/auto.backups") {
        my $cmd = "perl -p -i -e 's/^#BHCOMMENTED#($mntpoint)/\$1/g' /etc/auto.backups";
        runcmd($cmd);
    } else { 
        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 runcmd {
    print "DEBUG running: " . join(" ", @_) . "\n" if $DEBUG;
    return system(@_);
}

sub quitter {
    my $message = shift;
    $br->logger('LOG_INFO',$message);
    exit;
}

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

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 {
    return 0 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 slurp {local$/=<>if local@ARGV=@_}
