#!/usr/bin/python
# Copyright (c) 2009, 2010, 2011 Nicira Networks
#
# 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.


# A daemon to monitor the external_ids columns of the Bridge and
# Interface OVSDB tables for changes that require interrogating XAPI.
# Its responsibilities include:
#
#   - Set the "bridge-id" key in the Bridge table.
#   - Set the "iface-id" key in the Interface table.
#   - Set the fail-mode on internal bridges.

import getopt
import logging, logging.handlers
import os
import signal
import subprocess
import sys
import time

import XenAPI

from ovs.db import error
from ovs.db import types
import ovs.util
import ovs.daemon
import ovs.db.idl

s_log     = logging.getLogger("ovs-xapi-sync")
l_handler = logging.handlers.RotatingFileHandler(
        "/var/log/openvswitch/ovs-xapi-sync.log")
l_formatter = logging.Formatter('%(filename)s: %(levelname)s: %(message)s')
l_handler.setFormatter(l_formatter)
s_log.addHandler(l_handler)
s_log.setLevel(logging.INFO)

vsctl="/usr/bin/ovs-vsctl"
session = None
force_run = False

# Set up a session to interact with XAPI.
#
# On system start-up, OVS comes up before XAPI, so we can't log into the
# session until later.  Try to do this on-demand, since we won't
# actually do anything interesting until XAPI is up.
def init_session():
    global session
    if session is not None:
        return True

    try:
        session = XenAPI.xapi_local()
        session.xenapi.login_with_password("", "")
    except:
        session = None
        s_log.warning("Couldn't login to XAPI")
        return False

    return True

def get_network_by_bridge(br_name):
    if not init_session():
        s_log.warning("Failed to get bridge id %s because"
                " XAPI session could not be initialized" % br_name)
        return None

    for n in session.xenapi.network.get_all():
        rec = session.xenapi.network.get_record(n)
        if rec['bridge'] == br_name:
            return rec

    return None

# By default, the "bridge-id" external id in the Bridge table is the
# same as "xs-network-uuids".  This may be overridden by defining a
# "nicira-bridge-id" key in the "other_config" field of the network
# record of XAPI.  If nicira-bridge-id is undefined returns default.
# On error returns None.
def get_bridge_id(br_name, default=None):
    rec = get_network_by_bridge(br_name)
    if rec:
        return rec['other_config'].get('nicira-bridge-id', default)
    return None

# By default, the "iface-id" external id in the Interface table is the
# same as "xs-vif-uuid".  This may be overridden by defining a
# "nicira-iface-id" key in the "other_config" field of the VIF
# record of XAPI.
def get_iface_id(if_name, xs_vif_uuid):
    if not if_name.startswith("vif") and not if_name.startswith("tap"):
        # Treat whatever was passed into 'xs_vif_uuid' as a default
        # value for non-VIFs.
        return xs_vif_uuid

    if not init_session():
        s_log.warning("Failed to get interface id %s because"
                " XAPI session could not be initialized" % if_name)
        return xs_vif_uuid

    try:
        vif = session.xenapi.VIF.get_by_uuid(xs_vif_uuid)
        rec = session.xenapi.VIF.get_record(vif)
        return rec['other_config'].get('nicira-iface-id', xs_vif_uuid)
    except XenAPI.Failure:
        s_log.warning("Could not find XAPI entry for VIF %s" % if_name)
        return xs_vif_uuid

def call_vsctl(args):
    cmd = [vsctl, "--timeout=30", "-vANY:console:off"] + args
    exitcode = subprocess.call(cmd)
    if exitcode != 0:
        s_log.warning("Couldn't call ovs-vsctl")

def set_external_id(table, record, key, value):
    if value:
        col = 'external-ids:"%s"="%s"' % (key, value)
        call_vsctl(["set", table, record, col])
    else:
        call_vsctl(["remove", table, record, "external-ids", key])


# XenServer does not call interface-reconfigure on internal networks,
# which is where the fail-mode would normally be set.
def update_fail_mode(name):
    rec = get_network_by_bridge(name)

    if not rec:
        return

    fail_mode = rec['other_config'].get('vswitch-controller-fail-mode')

    if not fail_mode:
        pools = session.xenapi.pool.get_all()
        if len(pools) == 1:
            prec = session.xenapi.pool.get_record(pools[0])
            fail_mode = prec['other_config'].get('vswitch-controller-fail-mode')

    if fail_mode not in ['standalone', 'secure']:
        fail_mode = 'standalone'

    call_vsctl(["set", "bridge", name, "fail_mode=" + fail_mode])

def update_in_band_mgmt(name):
    rec = get_network_by_bridge(name)

    if not rec:
        return

    dib = rec['other_config'].get('vswitch-disable-in-band')
    if not dib:
        call_vsctl(['remove', 'bridge', name, 'other_config',
                    'disable-in-band'])
    elif dib in ['true', 'false']:
        call_vsctl(['set', 'bridge', name,
                    'other_config:disable-in-band=' + dib])
    else:
        s_log.warning('"' + dib + '"'
                      "isn't a valid setting for other_config:disable-in-band on " +
                      name)

def update_bridge_id(name, ids):
    id = get_bridge_id(name, ids.get("xs-network-uuids"))

    if not id:
        return

    primary_id = id.split(";")[0]

    if ids.get("bridge-id") != primary_id:
        set_external_id("Bridge", name, "bridge-id", primary_id)
        ids["bridge-id"] = primary_id

def update_iface(name, ids):
    id = get_iface_id(name, ids.get("xs-vif-uuid"))
    if ids.get("iface-id") != id and id:
        set_external_id("Interface", name, "iface-id", id)
        ids["iface-id"] = id

    status = ids.get("iface-status")
    if status:
        set_external_id("Interface", name, "iface-status", status)

def keep_table_columns(schema, table_name, column_types):
    table = schema.tables.get(table_name)
    if not table:
        raise error.Error("schema has no %s table" % table_name)

    new_columns = {}
    for column_name, column_type in column_types.iteritems():
        column = table.columns.get(column_name)
        if not column:
            raise error.Error("%s table schema lacks %s column"
                              % (table_name, column_name))
        if column.type != column_type:
            raise error.Error("%s column in %s table has type \"%s\", "
                              "expected type \"%s\""
                              % (column_name, table_name,
                                 column.type.toEnglish(),
                                 column_type.toEnglish()))
        new_columns[column_name] = column
    table.columns = new_columns
    return table

def monitor_uuid_schema_cb(schema):
    string_type = types.Type(types.BaseType(types.StringType))
    string_map_type = types.Type(types.BaseType(types.StringType),
                                 types.BaseType(types.StringType),
                                 0, sys.maxint)

    new_tables = {}
    for table_name in ("Bridge", "Interface"):
        new_tables[table_name] = keep_table_columns(
            schema, table_name, {"name": string_type,
                                 "external_ids": string_map_type})
    schema.tables = new_tables

def usage():
    print "usage: %s [OPTIONS] DATABASE" % sys.argv[0]
    print "where DATABASE is a socket on which ovsdb-server is listening."
    ovs.daemon.usage()
    print "Other options:"
    print "  -h, --help               display this help message"
    sys.exit(0)

def handler(signum, frame):
    global force_run
    if (signum == signal.SIGHUP):
        force_run = True

def update_tap_from_vif(idl, tap_name, vif_name):
    ifaces = idl.data["Interface"]
    tap = None
    vif = None

    for i in ifaces.values():
        name = i.name.as_scalar().strip('"')
        if name == tap_name:
            tap = i
        elif name == vif_name:
            vif = i

    if vif and tap:
        vxid = vif.external_ids
        txid = tap.external_ids

        keys = ["attached-mac", "xs-network-uuid", "xs-vif-uuid", "xs-vm-uuid"]
        for k in keys:
            if vxid.get(k) != txid.get(k):
                set_external_id("Interface", tap_name, k, vxid.get(k))

def main(argv):
    global force_run

    try:
        options, args = getopt.gnu_getopt(
            argv[1:], 'h', ['help'] + ovs.daemon.LONG_OPTIONS)
    except getopt.GetoptError, geo:
        sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
        sys.exit(1)

    for key, value in options:
        if key in ['-h', '--help']:
            usage()
        elif not ovs.daemon.parse_opt(key, value):
            sys.stderr.write("%s: unhandled option %s\n"
                             % (ovs.util.PROGRAM_NAME, key))
            sys.exit(1)

    if len(args) != 1:
        sys.stderr.write("%s: exactly one nonoption argument is required "
                         "(use --help for help)\n" % ovs.util.PROGRAM_NAME)
        sys.exit(1)

    remote = args[0]
    idl = ovs.db.idl.Idl(remote, "Open_vSwitch", monitor_uuid_schema_cb)

    ovs.daemon.daemonize()

    # This daemon is usually started before XAPI, but to complete our
    # tasks, we need it.  Wait here until it's up.
    while not os.path.exists("/var/run/xapi_init_complete.cookie"):
        time.sleep(1)

    signal.signal(signal.SIGHUP, handler)

    bridges = {}
    interfaces = {}
    while True:
        if not force_run and not idl.run():
            poller = ovs.poller.Poller()
            idl.wait(poller)
            poller.block()
            continue

        if force_run:
            s_log.info("Forced to re-run as the result of a SIGHUP")
            bridges    = {}
            interfaces = {}
            force_run  = False

        new_bridges = {}
        for rec in idl.data["Bridge"].itervalues():
            name = rec.name.as_scalar()
            xs_network_uuids = rec.external_ids.get("xs-network-uuids")
            bridge_id = rec.external_ids.get("bridge-id")
            new_bridges[name] = {"xs-network-uuids": xs_network_uuids,
                                 "bridge-id": bridge_id}

        new_interfaces = {}
        for rec in idl.data["Interface"].itervalues():
            name = rec.name.as_scalar()
            xs_vif_uuid = rec.external_ids.get("xs-vif-uuid")
            iface_id = rec.external_ids.get("iface-id")
            new_interfaces[name] = {"xs-vif-uuid": xs_vif_uuid,
                                    "iface-id": iface_id}

            if name.startswith("vif"):
                new_interfaces[name]["iface-status"] = "active"

        #Tap devices take their xs-vif-uuid from their corresponding vif and
        #cause that vif to be labled inactive.
        for name in new_interfaces:
            if not name.startswith("tap"):
                continue

            vif = name.replace("tap", "vif", 1)

            if vif in new_interfaces:
                xs_vif_uuid = new_interfaces[vif]["xs-vif-uuid"]
                new_interfaces[name]["xs-vif-uuid"] = xs_vif_uuid

                new_interfaces[vif]["iface-status"] = "inactive"
                new_interfaces[name]["iface-status"] = "active"

                update_tap_from_vif(idl, name, vif)

        if bridges != new_bridges:
            for name,ids in new_bridges.items():
                if name not in bridges:
                    update_fail_mode(name)
                    update_in_band_mgmt(name)

                if (name not in bridges) or (bridges[name] != ids):
                    update_bridge_id(name, ids)

            bridges = new_bridges

        if interfaces != new_interfaces:
            for name,ids in new_interfaces.items():
                if (name not in interfaces) or (interfaces[name] != ids):
                    update_iface(name, ids)
            interfaces = new_interfaces

if __name__ == '__main__':
    try:
        main(sys.argv)
    except SystemExit:
        # Let system.exit() calls complete normally
        raise
    except:
        s_log.exception("traceback")
        sys.exit(ovs.daemon.RESTART_EXIT_CODE)