#!/usr/bin/python2

import re
import os
import stat
import subprocess
import sys
from optparse import OptionParser
import time
import signal
from collections import defaultdict
import zlib
import abc

# path-name: //var/lib/Acronis/mount/{crc32(arch)}_{cont_id}_{pit}_{index}

VERBOSE = True
MOUNT_DIR = "/var/lib/Acronis/mount"
IOSTAMP_DIR = "/var/lib/Acronis/IOStamp"
DEV_DIR = "/dev"
TI_MNT_NONE = "none"
CONTAINER_ID_NONE = "0"
FS_XFS = "xfs"
FS_EXT4 = "ext4"
MOUNT_OPT_NOATIME = "noatime"
MOUNT_OPT_NOUUID = "nouuid"
MOUNT_OPT_NOINIT_ITABLE = "noinit_itable"


def log(arg):
    if VERBOSE:
        print arg


def outprint(arg):
    print arg


class MntDevMgr(object):
    """ Mount Device Manager """
    __metaclass__ = abc.ABCMeta

    def __init__(self, options):
        self.archive = options.archive
        self.pit = options.pit
        self.index = options.index
        self.device = options.device
        self.fstype = options.fstype

    @staticmethod
    def extract_name(device):
        """ Extract device name from '/dev/xxx' -> 'xxx' """
        if not device:
            return device
        return device.split("/")[-1]

    @staticmethod
    def execute(cmd):
        log("Executing: " + cmd)
        p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        stdout, stderr = p.communicate()
        p.wait()
        out = stdout.splitlines()
        err = stderr.splitlines()
        log("ret=%r" % p.returncode)
        log("out=%r" % out)
        log("err=%r" % err)
        return p.returncode, out, err

    @staticmethod
    def build_mount_folder(arch, cid, pit, index):
        return "%s/%s_%s_%s_%s" % (MOUNT_DIR, format(zlib.crc32(arch) % (1 << 32), 'x'), cid, pit, index)

    @staticmethod
    def print_device(device):
        outprint("DEVICE:%s" % device)

    @staticmethod
    def print_mount_dir(mount_dir):
        outprint("MNTDIR:%s" % mount_dir)

    @staticmethod
    def dev_timestamp(device):
        try:
            with open("%s/%s" % (IOSTAMP_DIR, MntDevMgr.extract_name(device)), 'r') as f:
                s_stamp = f.read().replace('\n', '')
                return int(s_stamp)
        except Exception as ex:
            print("Error %r" % ex)
        return None

    @staticmethod
    def get_idle(stamp):
        if stamp is None:
            raise ValueError("Timestamp is 'None'")
        t = int(time.time())
        return max(0, t - stamp)

    @staticmethod
    def dev_idle_time(device):
        stamp = MntDevMgr.dev_timestamp(device)
        return MntDevMgr.get_idle(stamp)

    @staticmethod
    def get_max_timestamp(devices):
        return max([0] + [MntDevMgr.dev_timestamp(dev["dev"]) for dev in devices])

    @staticmethod
    def dev2obj(elem):
        mount_point = elem[1]
        components = MntDevMgr.extract_name(mount_point).split("_")
        cid = CONTAINER_ID_NONE
        pit = "0"
        if len(components) > 1 and len(components[1]) > 0:
            cid = components[1]
        if len(components) > 2 and len(components[2]) > 0:
            pit = components[2]
        return {
                    'dev': elem[0],
                    'mpoint': elem[1],
                    'arch': elem[2],
                    'fstype': elem[3],
                    'majmin': elem[4],
                    'pid': elem[5],
                    'index': elem[6],
                    'cid': cid,
                    'pit': pit
                }

    @staticmethod
    def get_devices():
        devices = []
        ret, out, _ = MntDevMgr.execute("trueimagemnt --list")
        if ret != 0:
            raise SystemError("Error code: %r" % ret)
        for elem in out:
            components = elem.split(" ")
            devices.append(MntDevMgr.dev2obj(components))
        return devices

    @staticmethod
    def stop_service(pid):
        MntDevMgr.execute("trueimagemnt --stop %s" % pid)

    @staticmethod
    def daemon_status(pid):
        try:
            with open("/proc/%s/cmdline" % pid, 'r') as f:
                cmdline = f.read()
                if "TrueImageMountDemonBin" in cmdline:
                    return True
        except Exception as ex:
            print("Error %r" % ex)
        return False

    @staticmethod
    def get_devices_groupped_by_pid():
        devices = MntDevMgr.get_devices()
        pids = defaultdict(list)
        for dev in devices:
            pids[dev['pid']].append(dev)
        return dict(pids)

    @staticmethod
    def status_str(b):
        return "On" if b else "Off"

    @abc.abstractmethod
    def get_mount_folder(self):
        pass

    @abc.abstractmethod
    def mount_prepare(self, folder):
        pass

    @abc.abstractmethod
    def umount_done(self, device, folder):
        pass

    @abc.abstractmethod
    def create_folder(self, folder):
        pass

    @abc.abstractmethod
    def mount_to_folder(self, folder):
        pass

    @abc.abstractmethod
    def remove_folder(self, folder):
        pass

    @abc.abstractmethod
    def umount_from_folder(self, folder):
        pass

    @abc.abstractmethod
    def check_folder_is_mount(self, folder):
        pass

    @abc.abstractmethod
    def check_folder_is_busy(self, folder):
        pass

    def equal_dev(self, dev):
        return self.pit == dev['pit']

    def get_mount_options(self):
        opts = [MOUNT_OPT_NOATIME]
        if self.fstype == FS_XFS:
            opts.append(MOUNT_OPT_NOUUID)
        if self.fstype == FS_EXT4:
            opts.append(MOUNT_OPT_NOINIT_ITABLE)
        return opts

    def get_mount_options_with_key(self):
        opts = self.get_mount_options()
        return "-o " + ",".join(opts) if opts else ""

    def mount(self):
        self.print_device(self.device)
        log("mounting device %s" % self.device)
        folder = self.get_mount_folder()
        self.mount_prepare(folder)
        if self.mount_to_folder(folder):
            self.print_mount_dir(folder)
        else:
            self.remove_folder(folder)

    def umount_device(self, dev, folder):
        if self.umount_from_folder(folder):
            self.umount_done(dev['dev'], folder)
            return True
        return True

    def umount_device_with_check(self, dev):
        if not self.check_device_is_mount(dev):
            folder = dev['mpoint']
            return self.umount_device(dev, folder)
        folder = self.build_mount_folder(dev['arch'], dev['cid'], dev['pit'], dev['index'])
        return self.umount_device(dev, folder)

    def check_devices_is_umount(self, devices, silent=True):
        for dev in devices:
            if self.check_device_is_mount(dev, silent):
                return False
        return True

    def check_device_is_mount(self, dev, silent=True):
        folder = self.build_mount_folder(dev['arch'], dev['cid'], dev['pit'], dev['index'])
        if self.check_folder_is_mount(folder):
            if not silent:
                self.print_mount_dir(folder)
            return True
        return False

    def check_device_is_busy(self, dev):
        if not self.check_device_is_mount(dev):
            return False
        folder = self.build_mount_folder(dev['arch'], dev['cid'], dev['pit'], dev['index'])
        return self.check_folder_is_busy(folder)

    def status(self):
        devices = MntDevMgr.get_devices()
        for dev in devices:
            if self.pit is None or self.equal_dev(dev):
                self.print_device(dev['dev'])
                self.check_device_is_mount(dev, False)


class HostMntDevMgr(MntDevMgr):
    def __init__(self, options):
        super(HostMntDevMgr, self).__init__(options)

    def get_mount_folder(self):
        return self.build_mount_folder(self.archive, CONTAINER_ID_NONE, self.pit, self.index)

    def mount_prepare(self, folder):
        self.create_folder(folder)

    def umount_done(self, device, folder):
        self.remove_folder(folder)

    def create_folder(self, folder):
        self.execute("mkdir -p %s" % folder)

    def mount_to_folder(self, folder):
        ret, _, _ = self.execute("mount %s %s %s" % (self.get_mount_options_with_key(), self.device, folder))
        return ret == 0

    def remove_folder(self, folder):
        self.execute("rm -rf %s" % folder)

    def umount_from_folder(self, folder):
        self.execute("umount %s" % folder)
        return not self.check_folder_is_mount(folder)

    def check_folder_is_mount(self, folder):
        ret, _, _ = self.execute("mountpoint %s" % folder)
        return ret == 0

    def check_folder_is_busy(self, folder):
        ret, _, _ = self.execute("fuser -vm %s" % folder)
        return ret == 0


class VzCtMntDevMgr(MntDevMgr):
    def __init__(self, options, cont_id):
        super(VzCtMntDevMgr, self).__init__(options)
        self.cont_id = cont_id if cont_id != CONTAINER_ID_NONE else options.cont_id

    def get_mount_folder(self):
        return self.build_mount_folder(self.archive, self.cont_id, self.pit, self.index)

    def mount_prepare(self, folder):
        d_rel = self.device.replace("/dev/", "")
        self.execute("vzctl set %s --devnodes %s:rw" % (self.cont_id, d_rel))
        self.execute("vzctl set %s --device-add hdd --device %s --mnt_opts %s" %
                     (self.cont_id, self.device, MOUNT_OPT_NOINIT_ITABLE))
        self.create_folder(folder)

    def umount_done(self, device, folder):
        self.execute("vzctl set %s --devnodes %s:none" % (self.cont_id, device))
        self.execute("vzctl exec %s rm %s" % (self.cont_id, device))
        self.remove_folder(folder)

    def create_folder(self, folder):
        self.execute("vzctl exec %s mkdir -p %s" % (self.cont_id, folder))

    def mount_to_folder(self, folder):
        ret, _, _ = self.execute("vzctl exec %s mount %s /dev/%s %s" % (self.cont_id,
                                                                        self.get_mount_options_with_key(),
                                                                        self.extract_name(self.device),
                                                                        folder))
        return ret == 0

    def remove_folder(self, folder):
        self.execute("vzctl exec %s rm -rf %s" % (self.cont_id, folder))

    def umount_from_folder(self, folder):
        self.execute("vzctl exec %s umount %s" % (self.cont_id, folder))
        return not self.check_folder_is_mount(folder)

    def check_folder_is_mount(self, folder):
        ret, _, _ = self.execute("vzctl exec %s mountpoint %s" % (self.cont_id, folder))
        return ret == 0

    def check_folder_is_busy(self, folder):
        ret, _, _ = self.execute("vzctl exec %s fuser -vm %s" % (self.cont_id, folder))
        return ret == 0

    def equal_dev(self, dev):
        return self.cont_id == dev['cid'] and self.pit == dev['pit']


def create_mount_manager(cont_id, options):
    if cont_id == CONTAINER_ID_NONE:
        mount_manager = HostMntDevMgr(options)
    else:
        mount_manager = VzCtMntDevMgr(options, cont_id)
    return mount_manager


def umount_devices(options, devices):
    for dev in devices:
        if dev['mpoint'] == TI_MNT_NONE:
            continue
        mount_manager = create_mount_manager(dev["cid"], options)
        if not mount_manager.umount_device_with_check(dev):
            log("Can't umount folder %s in container %s: filesystem is busy" % (dev['mpoint'], dev['cid']))
            return False
    return True


def purge_devices_by_attr(options, value, attr):
    pids = MntDevMgr.get_devices_groupped_by_pid()
    for pid, devices in pids.iteritems():
        mount_manager = None
        for dev in devices:
            if dev[attr] == value:
                mount_manager = create_mount_manager(dev["cid"], options)
                if dev['mpoint'] == TI_MNT_NONE:
                    continue
                log("purge dev=%s" % dev['dev'])
                mount_manager.umount_device_with_check(dev)
        if mount_manager and mount_manager.check_devices_is_umount(devices):
            mount_manager.stop_service(pid)


def purge_devices_by_name(options):
    purge_devices_by_attr(options, options.device, "dev")


def purge_devices_by_pit(options):
    purge_devices_by_attr(options, options.pit, "pit")


def need_umount_devices(options, devices):
    if options.timeout == 0:
        return True
    max_timestamps = MntDevMgr.get_max_timestamp(devices)
    idle = MntDevMgr.get_idle(max_timestamps)
    return idle >= options.timeout


def purge_all_devices(options):
    pids = MntDevMgr.get_devices_groupped_by_pid()
    for pid, devices in pids.iteritems():
        if need_umount_devices(options, devices):
            if umount_devices(options, devices):
                MntDevMgr.stop_service(pid)


def info_all_devices(options):
    devices = MntDevMgr.get_devices()
    for dev in devices:
        mount_manager = create_mount_manager(dev["cid"], options)
        device = dev['dev']
        pid = dev['pid']
        outprint("Daemon: %s" % pid)
        s = mount_manager.daemon_status(pid)
        outprint(" Status: %s" % mount_manager.status_str(s))
        if s:
            outprint(" Device: %s" % device)
            outprint(" Idle: %r" % mount_manager.dev_idle_time(device))
            outprint(" Busy: %r" % mount_manager.check_device_is_busy(dev))


def main():
    global VERBOSE

    parser = OptionParser()
    parser.add_option("-c", "--cleanup",  action="store_true", dest="cleanup",  help="cleanup devices",     default=False)
    parser.add_option("-I", "--info",     action="store_true", dest="info",     help="print info",          default=False)
    parser.add_option("-u", "--purge",    action="store_true", dest="purge",    help="purge devices",       default=False)
    parser.add_option("-s", "--status",   action="store_true", dest="status",   help="status of mount",     default=False)
    parser.add_option("-i", "--cont_id",  action="store",      dest="cont_id",  help="container id",        default=CONTAINER_ID_NONE,  type="string",   metavar="CONT_ID")
    parser.add_option("-p", "--pit",      action="store",      dest="pit",      help="point in time",       default=None,               type="string",   metavar="PIT")
    parser.add_option("-d", "--device",   action="store",      dest="device",   help="device",              default=None,               type="string",   metavar="DEVICE")
    parser.add_option("-t", "--timeout",  action="store",      dest="timeout",  help="timeout",             default=0,                  type="int",      metavar="TIMEOUT")
    parser.add_option("-v", "--verbose",  action="store_true", dest="verbose",  help="verbose output",      default=True)
    parser.add_option("-f", "--fstype",   action="store",      dest="fstype",   help="type of file system", default=None)  
    parser.add_option("-a", "--archive",  action="store",      dest="archive",  help="archive",             default=None,               type="string")
    parser.add_option("-x", "--index",    action="store",      dest="index",    help="index of volume",     default=None,               type="string")

    options, args = parser.parse_args()

    VERBOSE = options.verbose
    if options.info:
        VERBOSE = False

    log("cleanup: %r" % options.cleanup)
    log("status: %r" % options.status)
    log("purge: %r" % options.purge)
    log("cont_id: %r" % options.cont_id)
    log("pit: %r" % options.pit)
    log("device: %r" % options.device)
    log("timeout: %r" % options.timeout)
    log("fstype: %r" % options.fstype)

    try:
        if options.purge:
            if options.device:
                purge_devices_by_name(options)
                return
            purge_all_devices(options)
            return

        if options.info:
            info_all_devices(options)
            return

        mount_manager = create_mount_manager(options.cont_id, options)
        if options.cleanup:
            if options.pit:
                purge_devices_by_pit(options)
                return
            purge_all_devices(options)
            return

        if options.status:
            mount_manager.status()
            return

        mount_manager.mount()
    except Exception as ex:
        sys.exit(ex)


if __name__ == "__main__":
    # execute only if run as a script
    main()