#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright 2020 Red Hat, Inc.
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.
__metaclass__ = type

import glob
import os
import re

from ansible.module_utils._text import to_native
from ansible.module_utils.basic import AnsibleModule

ANSIBLE_METADATA = {
    'metadata_version': '1.1',
    'status': ['preview'],
    'supported_by': 'community'
}

DOCUMENTATION = """
---
module: tripleo_ovs_update
author:
  - Sofer Athlan-Guyot <sathlang@redhat.com>
version_added: '2.8'
short_description: Handle special ovs update.
notes: []
description:
  - This module check if ovs need a special treatment during update of the
    package.
options:
  debug:
    description:
      - Whether or not debug is enabled.
    default: False
    required: False
    type: bool
"""

EXAMPLES = """
- name: Special treatment for ovs upgrade.
  tripleo_ovs_upgrade:
"""

RETURN = """
msg:
    description: Descrption of the action taken.
    returned: always
    type: str
changed:
    description: Was the ovs package update or not.
    returned: always
    type: bool
"""


def pkg_manager(module, downloader=False):
    dnf = module.get_bin_path('dnf')
    if dnf:
        module.debug("Using dnf as package manager")
        if not downloader:
            return dnf
        else:
            return ['dnf', 'download']
    if not downloader:
        return module.get_bin_path('yum')
    else:
        return ['yumdownloader']


def get_current_ovs_pkg_name(module):
    """ Get currently installed ovs pkg name, layered or not."""
    cmd = ['rpm', '-qa']
    _, output, _ = module.run_command(cmd, check_rc=True)
    ovs_re = re.compile(r"""
    ^(openvswitch[0-9]+\.[0-9]+-[0-9]+\.[0-9]+\.[0-9]+ # layered
    |                                                  # or
    openvswitch(?!-[a-z]+))                            # non-layered
    """, re.X)
    for pkg in output.split("\n"):
        ovs = re.search(ovs_re, pkg)
        if ovs:
            return ovs.group(0)
    return None


# Process rhosp-openvswitch layered package for new version number
# return stuff like ["2.11"] in original module
def get_version(module, pkg, new=True):
    if new:
        cmd = [pkg_manager(module), 'info', '-q', pkg]
    else:
        cmd = ['rpm', '-qi', pkg]
    # This may fail if the package is not around for non-lp product.
    _, output, _ = module.run_command(cmd, check_rc=False)
    versions = re.findall(r'Version[^:]*:[^0-9]*([0-9.]+)', output)
    found = []
    for version in versions:
        if version:
            # we are only interested in major/minor number here.
            if new:
                # We can have several version here
                found.append(version.split('.')[:2])
            else:
                found = version.split('.')[:2]
    return found


def flatten_version(versions, join_str=''):
    flatten_str = ""
    if not isinstance(versions, list):
        versions = [versions]
    if isinstance(versions[0], list):
        for version in versions:
            flatten_str += join_str.join(version)
    else:
        flatten_str += join_str.join(versions)
    return flatten_str


def get_current_ovs_pkg_names(module, pkg):
    cmd = ['rpm', '-qa', pkg]
    _, output, _ = module.run_command(cmd, check_rc=True)
    # Make sure we remove empty element.
    return [pkg for pkg in output.split("\n") if pkg]


def remove_package_noaction(module, pkgs, excludes=[]):
    cmd = ['rpm', '-e', '--noscripts', '--nopreun',
           '--nopostun', '--notriggers', '--nodeps']
    pkgs_to_remove = []
    for pkg in pkgs:
        for exclude in excludes:
            if not re.match(r'{}'.format(exclude), pkg):
                pkgs_to_remove.append(pkg)
    _, output, _ = module.run_command(cmd + pkgs_to_remove, check_rc=True)
    return output


def upgrade_pkg(module, pkg):
    cmd = [pkg_manager(module), 'upgrade', '-y', pkg]
    _, output, _ = module.run_command(cmd, check_rc=True)
    return output


def set_openflow_version_on_bridges(module, bridges=None):
    if bridges is None:
        bridges = ['br-int']
    for bridge in bridges:
        cmd = ['ovs-vsctl', 'set', 'bridge', bridge,
               'protocols=OpenFlow10,OpenFlow13,OpenFlow15']
        rc, out, err = module.run_command(cmd)
        if rc != 0:
            module.warn('Cannot set new OpenFlow protocols on a bridge: '
                        '%s: %s.' %
                        (bridge, to_native(err)))


def layer_product_upgrade(module, result, ovs_pkg, lp_ovs_current_version):
    """Actually do the layered ovs upgrade with workaround.

    So we have a layered package (rhosp|rdo)-openvswitch. To prevent
    any cut in networking during update/upgrade, we update ovs without
    triggering the scripts in the package that stop the service.

    So first it determines if the package has a upgrade coming and
    then erases it making sure no package script is triggered and
    finally it re-install the new package.

    It also prevents incomptible issues between ovs database schema
    during a rolling update.

    No cut in service at the cost of a needed reboot to get the new
    binaries in place.

    """
    layered_product_name = get_layered_product_name()
    lp_ovs_coming_versions = get_version(module, layered_product_name)
    ovs_current_version = get_version(module, ovs_pkg, new=False)

    pkg_suffix = ''
    if int(ovs_current_version[0]) >= 3 or int(ovs_current_version[1]) >= 10:
        pkg_suffix = '.'.join(ovs_current_version)

    if ovs_pkg == 'openvswitch':
        pkg_base_name = 'openvswitch*'
    else:
        pkg_base_name = 'openvswitch{}*'.format(pkg_suffix)

    if flatten_version(lp_ovs_coming_versions) \
       != flatten_version(ovs_current_version):
        # NOTE(mjozefcz): Workaround for bz1863024.
        if '2.11' == flatten_version(ovs_current_version, join_str='.'):
            set_openflow_version_on_bridges(module)
        ovs_pkgs = get_current_ovs_pkg_names(module, pkg_base_name)
        remove_package_noaction(module, ovs_pkgs,
                                excludes=['selinux'])
        upgraded = upgrade_pkg(module, layered_product_name)
        result['msg'] += \
            """ Layer product update workaround applied for {} \
Upgraded:'{}'""".format(ovs_pkgs, upgraded)
        result['changed'] = True
    else:
        result['msg'] += " No need to upgrade ovs."


def pkg_has_disruption(module):
    """Check if the current ovs pkg include a disruptive action."""
    awk_cmds = ["awk '/postuninstall/,/*/' | grep -q 'systemctl.*try-restart'",
                "awk '/preun/,/*/' | grep -q 'systemctl.*disable'"]
    rc = 1
    for awk in awk_cmds:
        cmd = "rpm -q --scripts openvswitch | {}".format(awk)
        rc, _, _ = module.run_command(cmd, check_rc=False,
                                      use_unsafe_shell=True)
        if rc == 0:
            break
    return rc == 0


def upgrade_non_layered_ovs(module, result):
    tmp_dir = '/root/OVS_UPGRADE'
    cmds = [
        ['rm', '-rf', tmp_dir],
        ['install', '-d', '-o', 'root', '-g', 'root', '-m', '0750', tmp_dir],
        [pkg_manager(module), 'makecache'],
        pkg_manager(module, downloader=True)
        + ['--destdir', tmp_dir, '--resolve', 'openvswitch']]
    for cmd in cmds:
        module.run_command(cmd, check_rc=True)

    for pkg in glob.glob(tmp_dir + '/*.rpm'):
        cmd = ['rpm', '-U',
               '--replacepkgs',
               '--notriggerun',
               '--nopostun',
               pkg]
        module.run_command(cmd, check_rc=True)
        result['msg'] += " {} handled".format(pkg)
        result['changed'] = True


def non_layered_ovs_upgrade(module, result):
    if not pkg_has_disruption(module):
        result['msg'] += 'Nothing to be done for non layered ovs upgrade, ' \
            "post-script doesn't have restart."
    else:
        result['msg'] += "OVS upgrade special handling."
        upgrade_non_layered_ovs(module, result)


def get_distro():
    """Get the distro as defined in /etc/os-release[ID]."""
    distro = None
    os_release_file = '/etc/os-release'
    if os.path.isfile(os_release_file):
        with open(os_release_file) as release_file:
            for line in release_file.readlines():
                match = re.match('^ *ID *="?([^"]+)"?$', line)
                if match:
                    distro = match.group(1)
                    break
    return distro


def get_layered_product_name():
    """Get the layer product name version depending on os.

    It's rhosp-openvswitch on redhat, and rdo-openvswitch on centos.

    """
    distro = get_distro()
    if distro is not None and distro == 'centos':
        return 'rdo-openvswitch'
    return 'rhosp-openvswitch'


def main():
    module = AnsibleModule(argument_spec={}, supports_check_mode=False)

    result = dict(
        changed=False,
        msg=''
    )

    layered_product_name = get_layered_product_name()
    ovs_current_pkg = get_current_ovs_pkg_name(module)
    if ovs_current_pkg:
        # We found a ovs package, let's dive in.
        ovs_current_version = get_version(module,
                                          layered_product_name,
                                          new=False)
        if ovs_current_version:
            result['msg'] += "Found a layered product ovs - {} - " \
                .format(layered_product_name)
            layer_product_upgrade(module, result,
                                  ovs_current_pkg, ovs_current_version)
        else:
            result['msg'] += "Found ovs. "
            non_layered_ovs_upgrade(module, result)
    else:
        result['msg'] += "No ovs installed, nothing to do."

    module.exit_json(**result)


if __name__ == '__main__':
    main()