#!/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
from contego import rpc

from nova.conductor import rpcapi as conductor_rpcapi
from nova.objects import base as objects_base
import nova.db.api

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()


# 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 block_db_access():
    class NoDB(object):
        def __getattr__(self, attr):
            return self

        def __call__(self, *args, **kwargs):
            stacktrace = "".join(traceback.format_stack())
            LOG.error('No db access allowed in tvault-contego: %s' %
                      stacktrace)
            raise exception.DBNotAllowed('tvault-contego')

    nova.db.api.IMPL = NoDB()


def setup_conductor():
    try:
        block_db_access()
        objects_base.NovaObject.indirection_api = \
            conductor_rpcapi.ConductorAPI()
    except Exception as ex:
        LOG.exception(ex)
        raise ex

def main():
    # Before intializing nova components, use conf
    # values from nova conf
    cfg.CONF.transport_url = cfg.CONF.nova_transport_url
    cfg.CONF.control_exchange = 'nova'
    nova_rpc.init(cfg.CONF)
    nova_objects.register_all()
    setup_conductor()
    cfg.CONF.transport_url = cfg.CONF.dmapi_transport_url
    cfg.CONF.control_exchange = 'contego'

    rpc.init(cfg.CONF)
    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, __name__)
    except TypeError:
        logging.setup('tvault-contego')
    LOG = logging.getLogger(__name__)
    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)

    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)