#!/usr/bin/env python3
#
# Script to manage S3-stored backups
#
# Copyright (c) 2009-2013 Ryan S. Tucker
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

import optparse
import os
import pwd
import secrets
import sys
import time

from boto.s3.connection import S3Connection

from collections import defaultdict
from math import log10
from subprocess import Popen


class BackupManager:

    def __init__(self, accesskey, sharedkey):
        self._accesskey = accesskey
        self._connection = S3Connection(accesskey, sharedkey)

        self._buckets = None
        self._bucketbackups = {}
        self._backups = None

    def _generate_backup_buckets(self):
        bucket_prefix = self._accesskey.lower() + '-bkup-'
        buckets = self._connection.get_all_buckets()
        self._buckets = []

        for bucket in buckets:
            if bucket.name.startswith(bucket_prefix):
                self._buckets.append(bucket)

    @property
    def backup_buckets(self):   # property
        if self._buckets is None:
            self._generate_backup_buckets()
        return self._buckets

    def _list_backups(self, bucket):
        """Returns a dict of backups in a bucket, with dicts of:
        {hostname (str):
            {Backup number (int):
                {'date': Timestamp of backup (int),
                 'keys': A list of keys comprising the backup,
                 'hostname': Hostname (str),
                 'backupnum': Backup number (int),
                 'finalized': 0, or the timestamp the backup was finalized
                }
            }
        }
        """

        backups = {}

        for key in bucket.list():
            keyparts = key.key.split('.')
            final = False

            if keyparts[-1] == 'COMPLETE':
                final = True
                keyparts.pop() # back to tar
                keyparts.pop() # back to backup number
            else:
                if keyparts[-1] == 'gpg':
                    keyparts.pop()

                if keyparts[-1] != 'tar' and len(keyparts[-1]) == 2:
                    keyparts.pop()

                if keyparts[-1] == 'tar':
                    keyparts.pop()

            nextpart = keyparts.pop()
            if nextpart == 'COMPLETE':
                print(("Stray file: %s" % key.key))
                continue
            backupnum = int(nextpart)
            hostname = '.'.join(keyparts)

            lastmod = time.strptime(key.last_modified,
                                    '%Y-%m-%dT%H:%M:%S.000Z')

            if hostname in list(backups.keys()):
                if not backupnum in list(backups[hostname].keys()):
                    backups[hostname][backupnum] = {
                        'date': lastmod,
                        'hostname': hostname,
                        'backupnum': backupnum,
                        'finalized': 0,
                        'keys': [],
                        'finalkey': None,
                        'finalized_age': -1,
                    }
            else:
                backups[hostname] = {
                    backupnum: {
                        'date': lastmod,
                        'hostname': hostname,
                        'backupnum': backupnum,
                        'finalized': 0,
                        'keys': [],
                        'finalkey': None,
                        'finalized_age': -1,
                    }
                }
            if final:
                backups[hostname][backupnum]['finalized'] = lastmod
                backups[hostname][backupnum]['finalkey'] = key
                timestamp = time.mktime(lastmod)
                delta = int(time.time() - timestamp + time.timezone)
                backups[hostname][backupnum]['finalized_age'] = delta
            else:
                if lastmod < backups[hostname][backupnum]['date']:
                    backups[hostname][backupnum]['date'] = lastmod
                backups[hostname][backupnum]['keys'].append(key)
        return backups

    def get_backups_by_bucket(self, bucket):
        if bucket.name not in self._bucketbackups:
            self._bucketbackups[bucket.name] = self._list_backups(bucket)

        return self._bucketbackups[bucket.name]

    @property
    def all_backups(self):  # property
        if self._backups is None:
            sys.stderr.write("Enumerating backups")
            self._backups = {}
            for bucket in self.backup_buckets:
                backups_dict = self.get_backups_by_bucket(bucket)
                for hostname, backups in list(backups_dict.items()):
                    sys.stderr.write('.')
                    sys.stderr.flush()
                    if hostname not in self._backups:
                        self._backups[hostname] = {}
                    self._backups[hostname].update(backups)
            sys.stderr.write("\n")
        return self._backups

    def invalidate_host_cache(self, hostname):
        nuke = []
        for bucket in self._bucketbackups:
            if hostname in self._bucketbackups[bucket]:
                nuke.append(bucket)

        for bucket in nuke:
            if bucket in self._bucketbackups:
                del self._bucketbackups[bucket]
                self._backups = None

    @property
    def backups_by_age(self):   # property
        "Returns a dict of {hostname: [(backupnum, age), ...]}"
        results = defaultdict(list)
        for hostname, backups in list(self.all_backups.items()):
            for backupnum, statusdict in list(backups.items()):
                results[hostname].append((backupnum,
                                          statusdict['finalized_age']))
        return results


def choose_host_to_backup(agedict, target_count=2):
    "Takes a dict from backups_by_age, returns a hostname to back up."

    host_scores = defaultdict(int)

    for hostname, backuplist in list(agedict.items()):
        bl = sorted(backuplist, key=lambda x: x[1])
        if len(bl) > 0 and bl[0][1] == -1:
            # unfinalized backup alert
            host_scores[hostname] += 200
            bl.pop(0)
        if len(bl) >= target_count:
            host_scores[hostname] -= 100
        host_scores[hostname] -= len(bl)
        if len(bl) > 0:
            # age of oldest backup helps score
            oldest = bl[0]
            host_scores[hostname] += log10(oldest[1])
            # recency of newest backup hurts score
            newest = bl[-1]
            host_scores[hostname] -= log10(max(1, (oldest[1] - newest[1])))

    for candidate, score in sorted(list(host_scores.items()),
                                   key=lambda x: x[1], reverse=True):
        yield (candidate, score)


def choose_backups_to_delete(agedict, target_count=2, max_age=30):
    "Takes a dict from backups_by_age, returns a list of backups to delete"

    decimate = defaultdict(list)

    for hostname, backuplist in list(agedict.items()):
        bl = []
        for backup in sorted(backuplist, key=lambda x: x[1]):
            if backup[1] > 0:
                bl.append(backup)

        while len(bl) > target_count:
            backup = bl.pop()
            if backup[1] > (max_age * 24 * 60 * 60):
                decimate[hostname].append(backup)

    return decimate


def iter_urls(keyset, expire=86400):
    """Given a list of keys and an optional expiration time (in seconds),
       returns an iterator of URLs to fetch to reassemble the backup."""

    for key in keyset:
        yield key.generate_url(expires_in=expire)


def make_restore_script(backup, expire=86400):
    """Returns a quick and easy restoration script to restore the given system,
       requires a backup, and perhaps expire"""

    myhostname = backup['hostname']
    mybackupnum = backup['backupnum']
    myfriendlytime = time.strftime('%Y-%m-%d at %H:%M GMT', backup['date'])
    myexpiretime = time.strftime('%Y-%m-%d at %H:%M GMT',
                                 time.gmtime(time.time() + expire))
    myexpiretimestamp = time.time() + expire

    output = []

    output.append('#!/bin/sh\n')
    output.append('# Restoration script for %s backup %s,\n' % (
                   myhostname, mybackupnum))
    output.append('# a backup created on %s.\n' % (myfriendlytime))
    output.append('# To use: bash scriptname /path/to/put/the/files\n\n')
    output.append('# WARNING: THIS FILE EXPIRES AFTER %s\n' % (myexpiretime))
    output.append('if [ "`date +%%s`" -gt "%i" ];\n' % (myexpiretimestamp))
    output.append('    then echo "Sorry, this restore script is too old.";\n')
    output.append('         exit 1;\n')
    output.append('fi\n\n')
    output.append('if [ -z "$1" ];\n')
    output.append('   then echo "Usage: ./scriptname /path/to/restore/to";\n')
    output.append('        exit 1;\n')
    output.append('fi\n\n')
    output.append('# Check the destination\n')
    output.append('if [ ! -d $1 ];\n')
    output.append('    then echo "Target $1 does not exist!";\n')
    output.append('         exit 1;\n')
    output.append('fi\n\n')
    output.append('if [ -n "`ls --almost-all $1`" ];\n')
    output.append('    then echo "Target $1 is not empty!";\n')
    output.append('         exit 1;\n')
    output.append('fi\n\n')
    output.append('# cd to the destination, create a temporary workspace\n')
    output.append('cd $1\n')
    output.append('mkdir .restorescript-scratch\n\n')
    output.append('# retrieve files\n')

    mysortedfilelist = []
    for key in backup['keys']:
        output.append('wget -O $1/.restorescript-scratch/%s "%s"\n' % (
                        key.name, key.generate_url(expires_in=expire)))
        mysortedfilelist.append('.restorescript-scratch/' + key.name)
    mysortedfilelist.sort()

    output.append('\n# decrypt files\n')
    output.append('gpg --decrypt-files << EOF\n')
    output.append('\n'.join(mysortedfilelist))
    output.append('\nEOF\n')

    output.append('\n# join and untar files\n')
    output.append('cat .restorescript-scratch/*.tar.?? | tar -xf -\n\n')

    output.append('echo "DONE!  Have a nice day."\n##\n')

    return output


def start_archive(hosts):
    "Starts an archive operation for a list of hosts."
    if 'LOGNAME' in os.environ:
        username = os.environ['LOGNAME']
    else:
        try:
            username = pwd.getpwuid(os.getuid()).pw_name
        except KeyError:
            username = 'nobody'

    scriptdir = os.path.dirname(sys.argv[0])

    cmd = [os.path.join(scriptdir, 'BackupPC_archiveStart'), 'archives3',
           username]
    cmd.extend(hosts)

    proc = Popen(cmd)
    proc.communicate()


def main():
    # check command line options
    parser = optparse.OptionParser(
        usage="usage: %prog [options] [list|delete|script]",
        description="" +
            "Companion maintenance script for BackupPC_archiveHost_s3. " +
            "By default, it assumes the 'list' command, which displays all " +
            "of the backups currently archived on S3.  The 'delete' command " +
            "is used to delete backups.  The 'script' command produces a " +
            "script that can be used to download and restore a backup.")
    parser.add_option("-H", "--host", dest="host",
                      help="Name of backed-up host")
    parser.add_option("-b", "--backup-number", dest="backupnum",
                      help="Backup number")
    parser.add_option("-a", "--age", dest="age",
                      help="Delete backups older than AGE days")
    parser.add_option("-k", "--keep", dest="keep",
                      help="When used with --age, keep this many recent " +
                           "backups (default=1)", default=1)
    parser.add_option("-f", "--filename", dest="filename",
                      help="Output filename for script")
    parser.add_option("-x", "--expire", dest="expire",
                      help="Maximum age of script, default 86400 seconds")
    parser.add_option("-t", "--test", dest="test", action="store_true",
                      help="Test mode; don't actually delete")
    parser.add_option("-u", "--unfinalized", dest="unfinalized",
                      action="store_true", help="Consider unfinalized backups")
    parser.add_option("-s", "--start-backups", dest="start",
                      action="store_true",
                      help="When used with --age, start backups for hosts " +
                           "with fewer than keep+1 backups")
    parser.add_option("-l", "--list", dest="list", action="store_true",
                      help="List stored backups after completing operations")

    (options, args) = parser.parse_args()

    bmgr = BackupManager(secrets.accesskey, secrets.sharedkey)

    if options.backupnum and not options.host:
        parser.error('Must specify --host when specifying --backup-number')

    if options.backupnum:
        options.backupnum = int(options.backupnum)

    if len(args) == 0:
        args.append('list')

    if len(args) > 1:
        parser.error('Too many arguments.')

    if args[0] != 'delete' and options.age:
        parser.error('--age only makes sense with delete')

    if options.start and not (args[0] == 'delete' and options.age):
        parser.error('--start-backups only makes sense with delete and --age')

    if args[0] != 'script' and (options.expire or options.filename):
        parser.error('--expire and --filename only make sense with script')

    if args[0] in ['list', 'script', 'delete']:
        if options.host:
            if options.host not in bmgr.all_backups:
                parser.error('No backups found for host "%s"' % options.host)
        else:
            if len(bmgr.all_backups) == 0:
                parser.error('No buckets found!')
    else:
        parser.error('Invalid option: %s' + args[0])

    if args[0] == 'script':
        if not options.host:
            parser.error('Must specify --host to generate a script for')

        if not options.backupnum and options.unfinalized:
            # assuming highest number
            options.backupnum = max(bmgr.all_backups[options.host].keys())
        elif not options.backupnum:
            # assuming highest finalized number
            options.backupnum = 0
            for backup in list(bmgr.all_backups[options.host].keys()):
                if bmgr.all_backups[options.host][backup]['finalized'] > 0:
                    options.backupnum = max(options.backupnum, backup)
            if options.backupnum == 0:
                parser.error('No finalized backups found!  Try '
                             '--unfinalized if you dare')

        backup = bmgr.all_backups[options.host][options.backupnum]

        if not options.expire:
            options.expire = "86400"

        if options.filename:
            fd = open(options.filename, 'w')
            fd.writelines(make_restore_script(backup,
                          expire=int(options.expire)))
        else:
            sys.stdout.writelines(make_restore_script(backup,
                                  expire=int(options.expire)))
    elif args[0] == 'delete':
        to_ignore = int(options.keep)
        to_delete = []
        if options.host and options.backupnum:
            print(("Will delete backup: %s %i (forced)" % (
                   options.host, options.backupnum)))
            to_delete.append((options.host, options.backupnum))
        elif options.age:
            to_delete_dict = choose_backups_to_delete(bmgr.backups_by_age,
                                target_count=to_ignore,
                                max_age=int(options.age))
            for hostname, backuplist in list(to_delete_dict.items()):
                for backupstat in backuplist:
                    print(("Will delete backup: %s %i (expired at %g days)" % (
                            hostname, backupstat[0], backupstat[1] / 86400.0)))
                    to_delete.append((hostname, backupstat[0]))

        else:
            parser.error('Need either an age or a host AND backup number.')

        if len(to_delete) > 0:
            for deletehost, deletebackupnum in to_delete:
                hostbackups = bmgr.all_backups.get(deletehost, {})
                deletebackup = hostbackups.get(deletebackupnum, {})
                deletekeys = deletebackup.get('keys', [])
                finalkey = deletebackup.get('finalkey', None)
                if len(deletekeys) > 0:
                    sys.stdout.write("Deleting backup: %s %d (%d keys)" % (
                            deletehost, deletebackupnum, len(deletekeys)))
                    for key in deletekeys:
                        if options.test:
                            sys.stdout.write('_')
                        else:
                            key.delete()
                            sys.stdout.write('.')
                        sys.stdout.flush()
                    if finalkey is not None:
                        if options.test:
                            sys.stdout.write('+')
                        else:
                            finalkey.delete()
                            sys.stdout.write('!')
                        sys.stdout.flush()
                    sys.stdout.write('\n')

        if options.start:
            for deletehost, deletebackupnum in to_delete:
                bmgr.invalidate_host_cache(deletehost)
            score_iter = choose_host_to_backup(bmgr.backups_by_age,
                                    target_count=int(options.keep) + 1)
            for candidate, score in score_iter:
                if score > 0:
                    sys.stdout.write('Starting archive operation for host: '
                                     '%s (score=%g)\n' % (candidate, score))
                    start_archive([candidate])
                    break
    if args[0] == 'list' or options.list:
        sys.stdout.write('%25s | %5s | %20s | %5s\n' % (
                "Hostname", "Bkup#", "Age", "Files"))
        sys.stdout.write(('-' * 72) + '\n')
        for hostname, backups in list(bmgr.all_backups.items()):
            for backupnum in sorted(backups.keys()):
                filecount = len(backups[backupnum]['keys'])
                datestruct = backups[backupnum]['date']
                if backups[backupnum]['finalized'] > 0:
                    inprogress = ''
                else:
                    inprogress = '*'
                timestamp = time.mktime(datestruct)
                delta = int(time.time() - timestamp + time.timezone)
                if delta < 3600:
                    prettydelta = '%i min ago' % (delta / 60)
                elif delta < 86400:
                    prettydelta = '%i hr ago' % (delta / 3600)
                else:
                    days = int(delta / 60 / 60 / 24)
                    if days == 1:
                        s = ''
                    else:
                        s = 's'
                    prettydelta = '%i day%s ago' % (days, s)

                sys.stdout.write('%25s | %5i | %20s | %5i%s\n' % (
                    hostname, backupnum, prettydelta, filecount, inprogress))
        sys.stdout.write('* == not yet finalized (Age == time of '
                         'last activity)\n')


if __name__ == '__main__':
    main()
