# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright (c) 2013 TrilioData, Inc.
# All Rights Reserved.


import setuptools
import atexit
import jinja2
from setuptools.command.install import install
import os
import sys
from distutils.dir_util import copy_tree
from pathlib import Path
from workloadmgr.openstack.common import setup as common_setup
import pwd
import configparser
import subprocess
import fnmatch
from distutils.sysconfig import (
    EXEC_PREFIX,
    get_python_lib,
)

requires = common_setup.parse_requirements()
depend_links = common_setup.parse_dependency_links()
project = 'workloadmgr'

filters = [
    "AvailabilityZoneFilter = "
    "workloadmgr.openstack.common.scheduler.filters."
    "availability_zone_filter:AvailabilityZoneFilter",
    "CapabilitiesFilter = "
    "workloadmgr.openstack.common.scheduler.filters."
    "capabilities_filter:CapabilitiesFilter",
    "CapacityFilter = "
    "workloadmgr.scheduler.filters.capacity_filter:CapacityFilter",
    "JsonFilter = "
    "workloadmgr.openstack.common.scheduler.filters.json_filter:JsonFilter",
    "RetryFilter = "
    "workloadmgr.scheduler.filters.retry_filter:RetryFilter",
]

weights = [
    "CapacityWeigher = workloadmgr.scheduler.weights.capacity:CapacityWeigher",
]

services_dir = '/etc/workloadmgr'
config_dir = '/etc/workloadmgr'
log_dir = '/var/log/workloadmgr'
signin_dir = '/var/cache/workloadmgr'
mount_dirs = ['/var/triliovault-mounts', '/var/triliovault']
tvault_sec_key_file_path = '/etc/workloadmgr/tvault_key.pem'

template_files = {
    "wlm-api.service": "workloadmgr/templates/wlm-api.service.j2",
    "wlm-cron.service": "workloadmgr/templates/wlm-cron.service.j2",
    "wlm-scheduler.service": "workloadmgr/templates/wlm-scheduler.service.j2",
    "wlm-workloads.service": "workloadmgr/templates/wlm-workloads.service.j2"
}
log_files = ['workloadmgr-api.log',
             'workloadmgr-cron.log',
             'workloadmgr-scheduler.log',
             'workloadmgr-workloads.log'
             ]


# Gets the user info from the linux passwd db such as u_id, g_id, home dir etc.
# and return the u_id, g_id
def get_user_info(user_name):
    try:
        user_info = pwd.getpwnam(user_name)
        u_id = user_info.pw_uid
        g_id = user_info.pw_gid
    except KeyError:
        u_id = 162  # nova u_id
        g_id = 162  # nova g_id
    return u_id, g_id


# Recursive search for a file root path
def find(pattern, path):
    for root, dirs, files in os.walk(path):
        for name in files:
            if fnmatch.fnmatch(name, pattern):
                return root


# Recursive chown
def _chown(s_dir, u_id, g_id):
    os.chown(s_dir, u_id, g_id)
    for root, dirs, files in os.walk(s_dir):
        for dir in dirs:
            os.chown(os.path.join(root, dir), u_id, g_id)
        for file in files:
            os.chown(os.path.join(root, file), u_id, g_id)


# Set config parameters
def set_config_param(bin_path):

    config = configparser.ConfigParser()
    config_file = './etc/workloadmgr/workloadmgr.conf'
    config.read(config_file)
    config['DEFAULT']['wlm_rootwrap'] = '%s/workloadmgr-rootwrap' % (bin_path)

    with open(config_file, 'w') as configfile:
        config.write(configfile)

# Post installation script to minimize manual intervention
def _post_install():
    print('POST INSTALLATION')

    binary_path = os.path.abspath(os.path.join(sys.executable, os.pardir))
    bin_paths = ['%s/bin' % (EXEC_PREFIX),
                 '%s/local/bin' % (EXEC_PREFIX)]

    for path in bin_paths:
        if os.path.isfile('%s/workloadmgr-api' % (path)):
            binary_path = path
            break

    config_parameters = [{'exec_path': binary_path}]

    Path(services_dir).mkdir(exist_ok=True)
    Path(config_dir).mkdir(exist_ok=True)
    u_id, g_id = get_user_info('nova')

    print("Creating service files from templates...")
    env = jinja2.Environment(
        loader=jinja2.FileSystemLoader(searchpath="."),
        trim_blocks=True,
        autoescape = True,
        lstrip_blocks=True)
    for serv_file, temp_file in template_files.items():
        template = env.get_template(temp_file)
        for parameter in config_parameters:
            result = template.render(parameter)
        f = open(os.path.join(services_dir, serv_file), "w")
        f.write(result)
        f.close()

    print("Setting config parmaters")
    set_config_param(binary_path)

    print("Copying config files")
    copy_tree('./etc/workloadmgr', config_dir)
    _chown(config_dir, u_id, g_id)
    root_uid = pwd.getpwnam('root').pw_uid
    os.chown(tvault_sec_key_file_path, root_uid, g_id)
    os.chmod(tvault_sec_key_file_path, 0o640)
    os.chown("/etc/workloadmgr/workloadmgr.conf", root_uid, g_id)
    os.chmod("/etc/workloadmgr/workloadmgr.conf", 0o640)

    print("Creating log files")
    Path(log_dir).mkdir(exist_ok=True)
    for log_file in log_files:
        Path('%s/%s' % (log_dir, log_file)).touch(exist_ok=True)
    _chown(log_dir, u_id, g_id)

    print("Creating mount directories")
    for mount_dir in mount_dirs:
        Path(mount_dir).mkdir(exist_ok=True)
        _chown(mount_dir, u_id, g_id)

    print("Creating signin directory")
    Path(signin_dir).mkdir(exist_ok=True)
    _chown(signin_dir, u_id, g_id)

    print("POST INSTALLATION DONE")


class new_install(install):
    def __init__(self, *args, **kwargs):
        super(new_install, self).__init__(*args, **kwargs)
        atexit.register(_post_install)


cmdclass = common_setup.get_cmdclass()
cmdclass['install'] = new_install

setuptools.setup(
    name=project,
    version='5.0.4',
    description='Data Protection As a Service',
    author='TrilioData',
    author_email='support@trilio.io',
    url='https://www.trilio.io',
    classifiers=[
        'Environment :: OpenStack',
        'Intended Audience :: Information Technology',
        'Intended Audience :: System Administrators',
        'License :: OSI Approved :: Apache Software License',
        'Operating System :: POSIX :: Linux',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3',
        'Programming Language :: Python :: 3.6',
    ],
    cmdclass=cmdclass,
    packages=setuptools.find_packages(exclude=['smoketests','tests',
        'workloadmgr/tvault_configurator']),
    install_requires=requires,
    dependency_links=depend_links,
    entry_points={
        'workloadmgr.scheduler.filters': filters,
        'workloadmgr.scheduler.weights': weights,
    },
    include_package_data=True,
    test_suite='nose.collector',
    scripts=['bin/workloadmgr-all',
             'bin/workloadmgr-api',
             'bin/workloadmgr-cron',
             'bin/workloadmgr-workloads',
             'bin/workloadmgr-clear-rabbit-queues',
             'bin/workloadmgr-manage',
             'bin/workloadmgr-rootwrap',
             'bin/workloadmgr-scheduler',
             'bin/workloadmgr-rpc-zmq-receiver'],
    py_modules=[])