#!/usr/bin/env python
"""Tool to update Ganeti instances:

* add unique name to the NICs of all Ganeti instances
* rename all instance tags related with network firewall profiles to include
  the unique name of the corresponding NIC.

The name for each NIC is based on the PK of the NIC in Cyclades DB.
"""

FIREWALL_TAGS_PREFIX = "synnefo:network:"
FIREWALL_TAGS = {"ENABLED": "synnefo:network:%s:protected",
                 "DISABLED": "synnefo:network:%s:unprotected",
                 "PROTECTED": "synnefo:network:%s:limited"}

# Gevent patching
import gevent
from gevent import monkey
monkey.patch_all()

import sys
import subprocess
from optparse import OptionParser, TitledHelpFormatter

# Configure Django env
from synnefo import settings
from django.core.management import setup_environ
setup_environ(settings)

from django.db import close_connection
from synnefo.db.models import Backend, pooled_rapi_client
from synnefo.management.common import get_backend

import logging
logger = logging.getLogger("migrate_nics")
handler = logging.StreamHandler()

formatter = logging.Formatter("[%(levelname)s] %(message)s")
handler.setFormatter(formatter)
logger.setLevel(logging.DEBUG)
logger.addHandler(handler)
logger.propagate = False

DESCRIPTION = """\
Tool to update all Ganeti instances in order to add a unique name to NICs of
all instances and rename the instance firewall tags to include the NIC name.
"""


def main():
    parser = OptionParser(description=DESCRIPTION,
                          formatter=TitledHelpFormatter())
    parser.add_option("--backend-id", dest="backend_id",
                      help="Update instances only of this Ganeti backend."),
    parser.add_option("--dry-run", dest="dry_run", default=False,
                      action="store_true",
                      help="Do not send any jobs to Ganeti backend.")
    parser.add_option("--ganeti-dry-run", dest="ganeti_dry_run", default=False,
                      action="store_true",
                      help="Pass --dry-run option to Ganeti jobs.")
    parser.add_option("--parallel", dest="parallel", default=False,
                      action="store_true",
                      help="Use a seperate process for each backend.")
    parser.add_option("-d", "--debug", dest="debug", default=False,
                      action="store_true",
                      help="Display debug information.")
    options, args = parser.parse_args()

    if options.backend_id:
        backends = [get_backend(options.backend_id)]
    else:
        if Backend.objects.filter(offline=True).exists():
            msg = "Can not update intances. An 'offline' backend exists."
            raise Exception(msg)
        backends = Backend.objects.all()

    if options.debug:
        logger.setLevel(logging.DEBUG)

    if len(backends) > 1 and options.parallel:
        cmd = sys.argv
        processes = []
        for backend in backends:
            p = subprocess.Popen(cmd + ["--backend-id=%s" % backend.id])
            processes.append(p)
        for p in processes:
            p.wait()
        return
    else:
        [upgrade_backend(b, options.dry_run, options.ganeti_dry_run)
         for b in backends]
    return


def upgrade_backend(backend, dry_run, ganeti_dry_run):
    jobs = []
    instances_ids = get_instances_with_anonymous_nics(backend)
    for vm in backend.virtual_machines.filter(id__in=instances_ids):
        jobs.append(gevent.spawn(upgrade_vm, vm, dry_run, ganeti_dry_run))

    if jobs:
        for job_chunk in [jobs[x:x+25] for x in range(0, len(jobs), 25)]:
            gevent.joinall(jobs)
    else:
        logger.info("No anonymous NICs in backend '%s'. Nothing to do!",
                    backend.clustername)
    return


def get_instances_with_anonymous_nics(backend):
    """Get all Ganeti instances that have NICs without names."""
    with pooled_rapi_client(backend) as rc:
        instances = rc.GetInstances(bulk=True)
    # Filter snf- instances
    instances = filter(lambda i:
                       i["name"].startswith(settings.BACKEND_PREFIX_ID),
                       instances)
    # Filter instances with anonymous NICs
    instances = filter(lambda i: None in i["nic.names"], instances)
    # Get IDs of those instances
    instances_ids = map(lambda i:
                        i["name"].replace(settings.BACKEND_PREFIX_ID, "", 1),
                        instances)
    return instances_ids


def upgrade_vm(vm, dry_run, ganeti_dry_run):
    """Add names to Ganeti NICs and update firewall Tags."""
    logger.info("Updating NICs of instance %s" % vm.backend_vm_id)
    index_to_uuid = {}
    new_tags = []
    # Compute new NICs names and firewall tags
    for nic in vm.nics.all():
        if nic.index is None:
            msg = ("Cannot update NIC '%s'. The index of the NIC is unknown."
                   " Please run snf-manage reconcile-servers --fix-all and"
                   " retry!")
            logger.critical(msg)
            continue
        uuid = nic.backend_uuid
        # Map index -> UUID
        index_to_uuid[nic.index] = uuid

        # New firewall TAG with UUID
        firewall_profile = nic.firewall_profile
        if firewall_profile and firewall_profile != "DISABLED":
            firewall_tag = FIREWALL_TAGS[nic.firewall_profile] % uuid
            new_tags.append(firewall_tag)

    renamed_nics = [("modify", index, {"name": name})
                    for index, name in index_to_uuid.items()]

    instance = vm.backend_vm_id
    with pooled_rapi_client(vm) as rc:
        # Delete old Tags
        tags = rc.GetInstanceTags(instance)
        delete_tags = [t for t in tags if t.startswith(FIREWALL_TAGS_PREFIX)]
        if delete_tags:
            logger.debug("Deleting tags '%s' from instance '%s'",
                         delete_tags, vm.backend_vm_id)
            if not dry_run:
                rc.DeleteInstanceTags(instance, delete_tags,
                                      dry_run=ganeti_dry_run)

        # Add new Tags
        if new_tags:
            logger.debug("Adding new tags '%s' to instance '%s'",
                         new_tags, vm.backend_vm_id)
            if not dry_run:
                rc.AddInstanceTags(instance, new_tags, dry_run=ganeti_dry_run)

        # Add names to NICs
        logger.debug("Modifying NICs of instance '%s'. New NICs: '%s'",
                     vm.backend_vm_id, renamed_nics)
        if not dry_run:
            rc.ModifyInstance(vm.backend_vm_id,
                              nics=renamed_nics, dry_run=ganeti_dry_run)
    close_connection()


if __name__ == "__main__":
    main()
    sys.exit(0)