X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=xenserver%2Fusr_share_openvswitch_scripts_ovs-xapi-sync;h=1c8ad51a4b18b665a536effb87b8274615308478;hb=HEAD;hp=ef10ce792338fd16a16db8187f6f1391529c47ee;hpb=40043044700de567251236d2e4afa89e02b9d1c2;p=sliver-openvswitch.git diff --git a/xenserver/usr_share_openvswitch_scripts_ovs-xapi-sync b/xenserver/usr_share_openvswitch_scripts_ovs-xapi-sync index ef10ce792..1c8ad51a4 100755 --- a/xenserver/usr_share_openvswitch_scripts_ovs-xapi-sync +++ b/xenserver/usr_share_openvswitch_scripts_ovs-xapi-sync @@ -1,5 +1,5 @@ #!/usr/bin/python -# Copyright (c) 2009, 2010, 2011 Nicira Networks +# Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -22,33 +22,39 @@ # - Set the "iface-id" key in the Interface table. # - Set the fail-mode on internal bridges. -import getopt -import logging, logging.handlers +import argparse import os -import signal -import subprocess import sys import time import XenAPI +import ovs.dirs from ovs.db import error from ovs.db import types -import ovs.util import ovs.daemon import ovs.db.idl +import ovs.unixctl +import ovs.unixctl.server -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" +vlog = ovs.vlog.Vlog("ovs-xapi-sync") session = None -force_run = False +flush_cache = False +exiting = False +xapi_down = False + + +def unixctl_exit(conn, unused_argv, unused_aux): + global exiting + exiting = True + conn.reply(None) + + +def unixctl_flush_cache(conn, unused_argv, unused_aux): + global flush_cache + flush_cache = True + conn.reply(None) + # Set up a session to interact with XAPI. # @@ -63,26 +69,40 @@ def init_session(): try: session = XenAPI.xapi_local() session.xenapi.login_with_password("", "") - except: + except XenAPI.Failure, e: session = None - s_log.warning("Couldn't login to XAPI") + vlog.warn("Couldn't login to XAPI (%s)" % e) 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" + vlog.warn("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 + recs = session.xenapi.network.get_all_records_where('field "bridge"="%s"' % br_name) + if len(recs) > 0: + return recs.values()[0] return None +# There are possibilities when multiple xs-network-uuids are set for a bridge. +# In cases like that, we should choose the bridge-id associated with the bridge +# name. +def get_single_bridge_id(bridge_ids, br_name, default=None): + global xapi_down + + rec = get_network_by_bridge(br_name) + if rec and rec['uuid'] in bridge_ids: + return rec['uuid'] + + vlog.warn("Failed to get a single bridge id from Xapi.") + xapi_down = True + return default + # 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 @@ -94,6 +114,7 @@ def get_bridge_id(br_name, default=None): 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 @@ -105,7 +126,7 @@ def get_iface_id(if_name, xs_vif_uuid): return xs_vif_uuid if not init_session(): - s_log.warning("Failed to get interface id %s because" + vlog.warn("Failed to get interface id %s because" " XAPI session could not be initialized" % if_name) return xs_vif_uuid @@ -114,24 +135,57 @@ def get_iface_id(if_name, 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) + vlog.warn("Could not find XAPI entry for VIF %s" % if_name) return xs_vif_uuid -def call_vsctl(args): - cmd = [vsctl, "--timeout=30", "-vANY:console:emer"] + args - exitcode = subprocess.call(cmd) - if exitcode != 0: - s_log.warning("Couldn't call ovs-vsctl") -def set_external_id(table, record, key, value): - col = 'external-ids:"' + key + '"="' + value + '"' - call_vsctl(["set", table, record, col]) +# By default, the "vm-id" external id in the Interface table is the +# same as "xs-vm-uuid". This may be overridden by defining a +# "nicira-vm-id" key in the "other_config" field of the VM +# record of XAPI. +def get_vm_id(if_name, xs_vm_uuid): + if not if_name.startswith("vif") and not if_name.startswith("tap"): + # Treat whatever was passed into 'xs_vm_uuid' as a default + # value for non-VIFs. + return xs_vm_uuid + + if not init_session(): + vlog.warn("Failed to get vm id for interface id %s because" + " XAPI session could not be initialized" % if_name) + return xs_vm_uuid + + try: + vm = session.xenapi.VM.get_by_uuid(xs_vm_uuid) + rec = session.xenapi.VM.get_record(vm) + return rec['other_config'].get('nicira-vm-id', xs_vm_uuid) + except XenAPI.Failure: + vlog.warn("Could not find XAPI entry for VIF %s" % if_name) + return xs_vm_uuid + + +def set_or_delete(d, key, value): + if value is None: + if key in d: + del d[key] + return True + else: + if d.get(key) != value: + d[key] = value + return True + return False + + +def set_external_id(row, key, value): + row.verify("external_ids") + external_ids = row.external_ids + if set_or_delete(external_ids, key, value): + row.external_ids = external_ids + # 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) - +def update_fail_mode(row): + rec = get_network_by_bridge(row.name) if not rec: return @@ -141,196 +195,209 @@ def update_fail_mode(name): 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') + 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]) + row.verify("fail_mode") + if row.fail_mode != fail_mode: + row.fail_mode = fail_mode -def update_in_band_mgmt(name): - rec = get_network_by_bridge(name) +def update_in_band_mgmt(row): + rec = get_network_by_bridge(row.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_id(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 - -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 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) + row.verify("other_config") + other_config = row.other_config + if dib and dib not in ['true', 'false']: + vlog.warn('"%s" isn\'t a valid setting for ' + "other_config:disable-in-band on %s" % (dib, row.name)) + elif set_or_delete(other_config, 'disable-in-band', dib): + row.other_config = other_config + + +def main(): + global flush_cache, xapi_down + + parser = argparse.ArgumentParser() + parser.add_argument("database", metavar="DATABASE", + help="A socket on which ovsdb-server is listening.") + parser.add_argument("--root-prefix", metavar="DIR", default='', + help="Use DIR as alternate root directory" + " (for testing).") + + ovs.vlog.add_args(parser) + ovs.daemon.add_args(parser) + args = parser.parse_args() + ovs.vlog.handle_args(args) + ovs.daemon.handle_args(args) + + remote = args.database + schema_helper = ovs.db.idl.SchemaHelper() + schema_helper.register_columns("Bridge", ["name", "external_ids", + "other_config", "fail_mode"]) + schema_helper.register_columns("Interface", ["name", "external_ids"]) + idl = ovs.db.idl.Idl(remote, schema_helper) ovs.daemon.daemonize() + ovs.unixctl.command_register("exit", "", 0, 0, unixctl_exit, None) + ovs.unixctl.command_register("flush-cache", "", 0, 0, unixctl_flush_cache, + None) + error, unixctl_server = ovs.unixctl.server.UnixctlServer.create(None) + if error: + ovs.util.ovs_fatal(error, "could not create unixctl server", vlog) + # 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"): + cookie_file = args.root_prefix + "/var/run/xapi_init_complete.cookie" + while not os.path.exists(cookie_file): time.sleep(1) - signal.signal(signal.SIGHUP, handler) - - bridges = {} - interfaces = {} + bridges = {} # Map from bridge name to nicira-bridge-id + iface_ids = {} # Map from xs-vif-uuid to iface-id + vm_ids = {} # Map from xs-vm-uuid to vm-id + seqno = idl.change_seqno # Sequence number when we last processed the db while True: - if not force_run and not idl.run(): + unixctl_server.run() + if exiting: + break; + + idl.run() + if not xapi_down and not flush_cache and seqno == idl.change_seqno: poller = ovs.poller.Poller() + unixctl_server.wait(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 + if xapi_down: + vlog.warn("Xapi is probably down. Retry again after a second.") + time.sleep(1) + xapi_down = False + + if flush_cache: + vlog.info("Flushing cache as the result of unixctl.") + bridges = {} + iface_ids = {} + vm_ids = {} + flush_cache = False + seqno = idl.change_seqno + + txn = ovs.db.idl.Transaction(idl) 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} - - #Tap devices take their xs-vif-uuid from their corresponding vif - 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 - - 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_id(name, ids) - interfaces = new_interfaces + for row in idl.tables["Bridge"].rows.itervalues(): + bridge_id = bridges.get(row.name) + if bridge_id is None: + # Configure the new bridge. + update_fail_mode(row) + update_in_band_mgmt(row) + + # Get the correct bridge_id, if we can. + bridge_id = get_bridge_id(row.name) + if bridge_id is None: + xs_network_uuids = row.external_ids.get("xs-network-uuids") + if xs_network_uuids: + bridge_ids = xs_network_uuids.split(";") + if len(bridge_ids) == 1: + bridge_id = bridge_ids[0] + else: + bridge_id = get_single_bridge_id(bridge_ids, + row.name) + set_external_id(row, "bridge-id", bridge_id) + + if bridge_id is not None: + new_bridges[row.name] = bridge_id + bridges = new_bridges + + iface_by_name = {} + for row in idl.tables["Interface"].rows.itervalues(): + iface_by_name[row.name] = row + + new_iface_ids = {} + new_vm_ids = {} + for row in idl.tables["Interface"].rows.itervalues(): + # Match up paired vif and tap devices. + if row.name.startswith("vif"): + vif = row + tap = iface_by_name.get("tap%s" % row.name[3:]) + elif row.name.startswith("tap"): + tap = row + vif = iface_by_name.get("vif%s" % row.name[3:]) + else: + tap = vif = None + + # Several tap external-ids need to be copied from the vif. + if row == tap and vif: + keys = ["attached-mac", + "xs-network-uuid", + "xs-vif-uuid", + "xs-vm-uuid"] + for k in keys: + set_external_id(row, k, vif.external_ids.get(k)) + + # Map from xs-vif-uuid to iface-id. + # + # (A tap's xs-vif-uuid comes from its vif. That falls out + # naturally from the copy loop above.) + xvu = row.external_ids.get("xs-vif-uuid") + if xvu: + iface_id = (new_iface_ids.get(xvu) + or iface_ids.get(xvu) + or get_iface_id(row.name, xvu)) + new_iface_ids[xvu] = iface_id + else: + # No xs-vif-uuid therefore no iface-id. + iface_id = None + set_external_id(row, "iface-id", iface_id) + + # Map from xs-vm-uuid to vm-id. + xvmu = row.external_ids.get("xs-vm-uuid") + if xvmu: + vm_id = (new_vm_ids.get(xvmu) + or vm_ids.get(xvmu) + or get_vm_id(row.name, xvmu)) + new_vm_ids[xvmu] = vm_id + else: + vm_id = None + set_external_id(row, "vm-id", vm_id) + + # When there's a vif and a tap, the tap is active (used for + # traffic). When there's just a vif, the vif is active. + # + # A tap on its own shouldn't happen, and we don't know + # anything about other kinds of devices, so we don't use + # an iface-status for those devices at all. + if vif and tap: + set_external_id(tap, "iface-status", "active") + set_external_id(vif, "iface-status", "inactive") + elif vif: + set_external_id(vif, "iface-status", "active") + else: + set_external_id(row, "iface-status", None) + iface_ids = new_iface_ids + vm_ids = new_vm_ids + + txn.add_comment("ovs-xapi-sync: Updating records from XAPI") + txn.commit_block() + + unixctl_server.close() + idl.close() + if __name__ == '__main__': try: - main(sys.argv) + main() except SystemExit: # Let system.exit() calls complete normally raise except: - s_log.exception("traceback") + vlog.exception("traceback") sys.exit(ovs.daemon.RESTART_EXIT_CODE)