xenserver/usr_share_openvswitch_scripts_ovs-xapi-sync

   1 #!/usr/bin/python
   2 # Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16
  17 # A daemon to monitor the external_ids columns of the Bridge and
  18 # Interface OVSDB tables for changes that require interrogating XAPI.
  19 # Its responsibilities include:
  20 #
  21 #   - Set the "bridge-id" key in the Bridge table.
  22 #   - Set the "iface-id" key in the Interface table.
  23 #   - Set the fail-mode on internal bridges.
  24
  25 import argparse
  26 import os
  27 import signal
  28 import sys
  29 import time
  30
  31 import XenAPI
  32
  33 import ovs.dirs
  34 from ovs.db import error
  35 from ovs.db import types
  36 import ovs.daemon
  37 import ovs.db.idl
  38
  39 root_prefix = ''                # Prefix for absolute file names, for testing.
  40 vlog = ovs.vlog.Vlog("ovs-xapi-sync")
  41 session = None
  42 force_run = False
  43
  44
  45 # Set up a session to interact with XAPI.
  46 #
  47 # On system start-up, OVS comes up before XAPI, so we can't log into the
  48 # session until later.  Try to do this on-demand, since we won't
  49 # actually do anything interesting until XAPI is up.
  50 def init_session():
  51     global session
  52     if session is not None:
  53         return True
  54
  55     try:
  56         session = XenAPI.xapi_local()
  57         session.xenapi.login_with_password("", "")
  58     except XenAPI.Failure, e:
  59         session = None
  60         vlog.warn("Couldn't login to XAPI (%s)" % e)
  61         return False
  62
  63     return True
  64
  65
  66 def get_network_by_bridge(br_name):
  67     if not init_session():
  68         vlog.warn("Failed to get bridge id %s because"
  69                 " XAPI session could not be initialized" % br_name)
  70         return None
  71
  72     for n in session.xenapi.network.get_all():
  73         rec = session.xenapi.network.get_record(n)
  74         if rec['bridge'] == br_name:
  75             return rec
  76
  77     return None
  78
  79
  80 # By default, the "bridge-id" external id in the Bridge table is the
  81 # same as "xs-network-uuids".  This may be overridden by defining a
  82 # "nicira-bridge-id" key in the "other_config" field of the network
  83 # record of XAPI.  If nicira-bridge-id is undefined returns default.
  84 # On error returns None.
  85 def get_bridge_id(br_name, default=None):
  86     rec = get_network_by_bridge(br_name)
  87     if rec:
  88         return rec['other_config'].get('nicira-bridge-id', default)
  89     return None
  90
  91
  92 # By default, the "iface-id" external id in the Interface table is the
  93 # same as "xs-vif-uuid".  This may be overridden by defining a
  94 # "nicira-iface-id" key in the "other_config" field of the VIF
  95 # record of XAPI.
  96 def get_iface_id(if_name, xs_vif_uuid):
  97     if not if_name.startswith("vif") and not if_name.startswith("tap"):
  98         # Treat whatever was passed into 'xs_vif_uuid' as a default
  99         # value for non-VIFs.
 100         return xs_vif_uuid
 101
 102     if not init_session():
 103         vlog.warn("Failed to get interface id %s because"
 104                 " XAPI session could not be initialized" % if_name)
 105         return xs_vif_uuid
 106
 107     try:
 108         vif = session.xenapi.VIF.get_by_uuid(xs_vif_uuid)
 109         rec = session.xenapi.VIF.get_record(vif)
 110         return rec['other_config'].get('nicira-iface-id', xs_vif_uuid)
 111     except XenAPI.Failure:
 112         vlog.warn("Could not find XAPI entry for VIF %s" % if_name)
 113         return xs_vif_uuid
 114
 115
 116 def set_or_delete(d, key, value):
 117     if value is None:
 118         if key in d:
 119             del d[key]
 120             return True
 121     else:
 122         if d.get(key) != value:
 123             d[key] = value
 124             return True
 125     return False
 126
 127
 128 def set_external_id(row, key, value):
 129     external_ids = row.external_ids
 130     if set_or_delete(external_ids, key, value):
 131         row.external_ids = external_ids
 132
 133
 134 # XenServer does not call interface-reconfigure on internal networks,
 135 # which is where the fail-mode would normally be set.
 136 def update_fail_mode(row):
 137     rec = get_network_by_bridge(row.name)
 138     if not rec:
 139         return
 140
 141     fail_mode = rec['other_config'].get('vswitch-controller-fail-mode')
 142
 143     if not fail_mode:
 144         pools = session.xenapi.pool.get_all()
 145         if len(pools) == 1:
 146             prec = session.xenapi.pool.get_record(pools[0])
 147             fail_mode = prec['other_config'].get(
 148                     'vswitch-controller-fail-mode')
 149
 150     if fail_mode not in ['standalone', 'secure']:
 151         fail_mode = 'standalone'
 152
 153     if row.fail_mode != fail_mode:
 154         row.fail_mode = fail_mode
 155
 156
 157 def update_in_band_mgmt(row):
 158     rec = get_network_by_bridge(row.name)
 159     if not rec:
 160         return
 161
 162     dib = rec['other_config'].get('vswitch-disable-in-band')
 163
 164     other_config = row.other_config
 165     if dib and dib not in ['true', 'false']:
 166         vlog.warn('"%s" isn\'t a valid setting for '
 167                 "other_config:disable-in-band on %s" % (dib, row.name))
 168     elif set_or_delete(other_config, 'disable-in-band', dib):
 169         row.other_config = other_config
 170
 171
 172 def update_bridge_id(row):
 173     id_ = get_bridge_id(row.name, row.external_ids.get("xs-network-uuids"))
 174     if not id_:
 175         return
 176
 177     set_external_id(row, "bridge-id", id_.split(";")[0])
 178
 179
 180 def keep_table_columns(schema, table_name, columns):
 181     table = schema.tables.get(table_name)
 182     if not table:
 183         raise error.Error("schema has no %s table" % table_name)
 184
 185     new_columns = {}
 186     for column_name in columns:
 187         column = table.columns.get(column_name)
 188         if not column:
 189             raise error.Error("%s table schema lacks %s column"
 190                               % (table_name, column_name))
 191         new_columns[column_name] = column
 192     table.columns = new_columns
 193     return table
 194
 195
 196 def prune_schema(schema):
 197     new_tables = {}
 198     new_tables["Bridge"] = keep_table_columns(
 199         schema, "Bridge", ("name", "external_ids", "other_config",
 200                            "fail_mode"))
 201     new_tables["Interface"] = keep_table_columns(
 202         schema, "Interface", ("name", "external_ids"))
 203     schema.tables = new_tables
 204
 205
 206 def handler(signum, _):
 207     global force_run
 208     if (signum == signal.SIGHUP):
 209         force_run = True
 210
 211
 212 def main():
 213     global force_run
 214
 215     parser = argparse.ArgumentParser()
 216     parser.add_argument("database", metavar="DATABASE",
 217             help="A socket on which ovsdb-server is listening.")
 218     parser.add_argument("--root-prefix", metavar="DIR",
 219                         help="Use DIR as alternate root directory"
 220                         " (for testing).")
 221
 222     ovs.vlog.add_args(parser)
 223     ovs.daemon.add_args(parser)
 224     args = parser.parse_args()
 225     ovs.vlog.handle_args(args)
 226     ovs.daemon.handle_args(args)
 227
 228     global root_prefix
 229     if args.root_prefix:
 230         root_prefix = args.root_prefix
 231
 232     remote = args.database
 233     schema_file = "%s/vswitch.ovsschema" % ovs.dirs.PKGDATADIR
 234     schema = ovs.db.schema.DbSchema.from_json(ovs.json.from_file(schema_file))
 235     prune_schema(schema)
 236     idl = ovs.db.idl.Idl(remote, schema)
 237
 238     ovs.daemon.daemonize()
 239
 240     # This daemon is usually started before XAPI, but to complete our
 241     # tasks, we need it.  Wait here until it's up.
 242     cookie_file = root_prefix + "/var/run/xapi_init_complete.cookie"
 243     while not os.path.exists(cookie_file):
 244         time.sleep(1)
 245
 246     signal.signal(signal.SIGHUP, handler)
 247
 248     bridges = {}                # Map from bridge name to xs_network_uuids
 249     iface_ids = {}              # Map from xs-vif-uuid to iface-id
 250     while True:
 251         if not force_run and not idl.run():
 252             poller = ovs.poller.Poller()
 253             idl.wait(poller)
 254             poller.block()
 255             continue
 256
 257         if force_run:
 258             vlog.info("Forced to re-run as the result of a SIGHUP")
 259             bridges = {}
 260             iface_ids = {}
 261             force_run = False
 262
 263         txn = ovs.db.idl.Transaction(idl)
 264
 265         new_bridges = {}
 266         for row in idl.tables["Bridge"].rows.itervalues():
 267             old_xnu = bridges.get(row.name)
 268             new_xnu = row.external_ids.get("xs-network-uuids", "")
 269             if old_xnu is None:
 270                 # New bridge.
 271                 update_fail_mode(row)
 272                 update_in_band_mgmt(row)
 273
 274             update_bridge_id(row)
 275             new_bridges[row.name] = new_xnu
 276         bridges = new_bridges
 277
 278         iface_by_name = {}
 279         for row in idl.tables["Interface"].rows.itervalues():
 280             iface_by_name[row.name] = row
 281
 282         new_iface_ids = {}
 283         for row in idl.tables["Interface"].rows.itervalues():
 284             # Match up paired vif and tap devices.
 285             if row.name.startswith("vif"):
 286                 vif = row
 287                 tap = iface_by_name.get("tap%s" % row.name[3:])
 288             elif row.name.startswith("tap"):
 289                 tap = row
 290                 vif = iface_by_name.get("vif%s" % row.name[3:])
 291             else:
 292                 tap = vif = None
 293
 294             # Several tap external-ids need to be copied from the vif.
 295             if row == tap and vif:
 296                 keys = ["attached-mac",
 297                         "xs-network-uuid",
 298                         "xs-vif-uuid",
 299                         "xs-vm-uuid"]
 300                 for k in keys:
 301                     set_external_id(row, k, vif.external_ids.get(k))
 302
 303             # Map from xs-vif-uuid to iface-id.
 304             #
 305             # (A tap's xs-vif-uuid comes from its vif.  That falls out
 306             # naturally from the copy loop above.)
 307             xvu = row.external_ids.get("xs-vif-uuid")
 308             if xvu:
 309                 iface_id = (new_iface_ids.get(xvu)
 310                             or iface_ids.get(xvu)
 311                             or get_iface_id(row.name, xvu))
 312                 new_iface_ids[xvu] = iface_id
 313             else:
 314                 # No xs-vif-uuid therefore no iface-id.
 315                 iface_id = None
 316             set_external_id(row, "iface-id", iface_id)
 317
 318             # When there's a vif and a tap, the tap is active (used for
 319             # traffic).  When there's just a vif, the vif is active.
 320             #
 321             # A tap on its own shouldn't happen, and we don't know
 322             # anything about other kinds of devices, so we don't use
 323             # an iface-status for those devices at all.
 324             if vif and tap:
 325                 set_external_id(tap, "iface-status", "active")
 326                 set_external_id(vif, "iface-status", "inactive")
 327             elif vif:
 328                 set_external_id(vif, "iface-status", "active")
 329             else:
 330                 set_external_id(row, "iface-status", None)
 331         iface_ids = new_iface_ids
 332
 333         txn.commit_block()
 334
 335
 336 if __name__ == '__main__':
 337     try:
 338         main()
 339     except SystemExit:
 340         # Let system.exit() calls complete normally
 341         raise
 342     except:
 343         vlog.exception("traceback")
 344         sys.exit(ovs.daemon.RESTART_EXIT_CODE)