#!/usr/bin/python3
# Copyright 2020 TrilioData Inc.
# All Rights Reserved.

"""Starter script for TrilioVault Contego - Openstack Nova Compute Extension."""

# Normally, a nova service would import eventlet here and
# monkey_patch the core libraries so use the greenthread-friendly versions.
# However, since we actually execute some of the code to run in separate
# threads (hence we use the tpool() functionality provided by eventlet), we
# skip monkey_patching the thread libraries.

import oslo_service  # noqa
import eventlet
eventlet.sleep()
eventlet.monkey_patch()

import gettext
import os
import sys
import gc
import traceback
import greenlet
import signal
import pkg_resources
from contego.nova.extension.driver import vault
from contego.nova.extension.driver.backends.backend import Backend

try:
    from oslo_log import log as logging
except ImportError:
    from nova.openstack.common import log as logging

try:
    from oslo.config import cfg
except ImportError:
    from oslo_config import cfg

if 'unicode' in gettext.install.__code__.co_varnames:
    gettext.install('nova', unicode=1)
else:
    gettext.install('nova')


# Preload this otherwise it leads to the main
# manager class not loading because we won't be able to load the virt module
# so that we may pull out the connection string paramters.
from nova.compute import flavors

# If ../nova/__init__.py exists, add ../ to Python search path, so that
# it will override what happens to be installed in /usr/(local/)lib/python...
possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
                                                os.pardir,
                                                os.pardir))
if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
    sys.path.insert(0, possible_topdir)

from nova import objects as nova_objects
from nova import rpc as nova_rpc
from contego import objects
from contego import service
from contego import context
from contego import exception
from contego import config

LOG = logging.getLogger(__name__)

try:
    if sys.version_info.major == 3:
        CONTEGO_VERSION = pkg_resources.get_distribution("python3-tvault-contego").version
    else:
        CONTEGO_VERSION = pkg_resources.get_distribution("tvault-contego").version
except Exception as ex:
    LOG.warning("Not able to fetch Contego version.")
    CONTEGO_VERSION = ''
# Stole this from Essex RPC code. To debug problems, we allow
# dumping of all active greenthreads. There is no cost to this code living
# on a production system.



def find_objects(t):
    return [o for o in gc.get_objects() if isinstance(o, t)]


def print_threads():
    for i, gt in enumerate(find_objects(greenlet.greenlet)):
        LOG.info("greenthread %s\n%s", i,
                 ''.join(traceback.format_stack(gt.gr_frame)))
    for i, stack in list(sys._current_frames().items()):
        LOG.info("thread %s\n%s", i,
                 ''.join(traceback.format_stack(stack)))


def sig_usr2_handler(signum, frame):
    print_threads()


def sigend_handler():
    vault.update_in_progress_files_on_exit()
    vault.unmount_backup_media()


# set_process_cgroup - Moves the main PID to the "trilio" cgroup
# created by the install. Once the main PID is moved all children
# will be placed in the cgroup by default.
def set_process_cgroup():
    our_pid = os.getpid()
    if os.path.exists("/sys/fs/cgroup/cpu/trilio/tasks"):
        LOG.info('Moving PID %s to cgroup' % our_pid)
        cpu_taskfile = os.open("/sys/fs/cgroup/cpu/trilio/tasks", os.O_WRONLY)
        if cpu_taskfile < 0:
            LOG.error('Could not add PID to cpu tasks')
        else:
            os.write(cpu_taskfile, str(our_pid))
            os.close(cpu_taskfile)
    else:
        LOG.info('CPU Control group missing. Skipping...')

    if os.path.exists("/sys/fs/cgroup/blkio/trilio/tasks"):
        blkio_taskfile = os.open(
            "/sys/fs/cgroup/blkio/trilio/tasks", os.O_WRONLY)
        if blkio_taskfile < 0:
            LOG.error('Could not add PID to blkio tasks')
        else:
            os.write(blkio_taskfile, str(our_pid))
            os.close(blkio_taskfile)
    else:
        LOG.info('I/O Control Group missing. I/O limit not set.')


def main():
    nova_rpc.init(cfg.CONF)
    nova_objects.register_all()
    objects.register_all()

    signal.signal(signal.SIGUSR2, sig_usr2_handler)
    ctxt = context.get_admin_context()
    binary_name = 'tvault-contego'
    set_process_cgroup()

    server = service.Service.create(binary=binary_name,
                                    manager='contego.nova.extension.manager.ContegoManager',
                                    topic="contego")
    return server

if __name__ == '__main__':
    config.parse_args(sys.argv)
    contego_opts = [
        cfg.StrOpt('contego_' + CONTEGO_VERSION + '_manager',
                   default='contego.nova.extension.manager.ContegoManager',
                   help='TrilioVault Contego - Openstack Nova Compute Extension'),
        cfg.BoolOpt(
                    "use_virt_qemu",
                    default=False,
                    help="Use virtual env qemu-img binary for all operations,\
                          By default it will use system binary.",
                   ),
              ]

    if 'compute_driver' in list(cfg.CONF.keys()):
        cfg.CONF.set_default('compute_driver', 'libvirt.LibvirtDriver')
    else:
        contego_opts.append(cfg.StrOpt('compute_driver',
                                       default='libvirt.LibvirtDriver',
                                       help='TrilioVault Contego - Compute driver'))
    cfg.CONF.register_opts(contego_opts)

    try:
        logging.setup(cfg.CONF, 'tvault-contego')
    except TypeError:
        logging.setup('tvault-contego')

    if cfg.CONF.use_virt_qemu is True:
        try:
            backend = Backend()
            qemu_path = backend.get_qemu_img_path()
            if os.path.exists(qemu_path):
                virt_env_dir_path = os.path.dirname(qemu_path)
                os.environ['PATH'] = virt_env_dir_path + ':' + os.environ['PATH']
            else:
                raise Exception("Not able to find virtual env qemu-img directory "\
                                "path, using system binary")
        except Exception as ex:
            LOG.exception(ex)

    vault.mount_backup_media()

    retry = True

    try:
        server = main()
        service.serve(server)
        service.wait()
    except Exception as ex:
        LOG.exception(ex)
        raise
    finally:
        sigend_handler()
        signal.signal(signal.SIGTERM, sigend_handler)
        signal.signal(signal.SIGINT, sigend_handler)