# Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you 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. import sys import syslog import os from xml.dom.minidom import getDOMImplementation from xml.dom.minidom import parse as parseXML the_root_prefix = "" def root_prefix(): """Returns a string to prefix to all file name references, which is useful for testing.""" return the_root_prefix def set_root_prefix(prefix): global the_root_prefix the_root_prefix = prefix log_destination = "syslog" def get_log_destination(): """Returns the current log destination. 'syslog' means "log to syslog". 'stderr' means "log to stderr".""" return log_destination def set_log_destination(dest): global log_destination log_destination = dest # Logging. def log(s): if get_log_destination() == 'syslog': syslog.syslog(s) else: print >>sys.stderr, s # Exceptions. class Error(Exception): def __init__(self, msg): Exception.__init__(self) self.msg = msg # Run external utilities # def run_command(command): log("Running command: " + ' '.join(command)) rc = os.spawnl(os.P_WAIT, root_prefix() + command[0], *command) if rc != 0: log("Command failed %d: " % rc + ' '.join(command)) return False return True # # Configuration File Handling. # class ConfigurationFile(object): """Write a file, tracking old and new versions. Supports writing a new version of a file and applying and reverting those changes. """ __STATE = {"OPEN":"OPEN", "NOT-APPLIED":"NOT-APPLIED", "APPLIED":"APPLIED", "REVERTED":"REVERTED", "COMMITTED": "COMMITTED"} def __init__(self, path): dirname,basename = os.path.split(path) self.__state = self.__STATE['OPEN'] self.__children = [] self.__path = os.path.join(dirname, basename) self.__oldpath = os.path.join(dirname, "." + basename + ".xapi-old") self.__newpath = os.path.join(dirname, "." + basename + ".xapi-new") self.__f = open(self.__newpath, "w") def attach_child(self, child): self.__children.append(child) def path(self): return self.__path def readlines(self): try: return open(self.path()).readlines() except: return "" def write(self, args): if self.__state != self.__STATE['OPEN']: raise Error("Attempt to write to file in state %s" % self.__state) self.__f.write(args) def close(self): if self.__state != self.__STATE['OPEN']: raise Error("Attempt to close file in state %s" % self.__state) self.__f.close() self.__state = self.__STATE['NOT-APPLIED'] def changed(self): if self.__state != self.__STATE['NOT-APPLIED']: raise Error("Attempt to compare file in state %s" % self.__state) return True def apply(self): if self.__state != self.__STATE['NOT-APPLIED']: raise Error("Attempt to apply configuration from state %s" % self.__state) for child in self.__children: child.apply() log("Applying changes to %s configuration" % self.__path) # Remove previous backup. if os.access(self.__oldpath, os.F_OK): os.unlink(self.__oldpath) # Save current configuration. if os.access(self.__path, os.F_OK): os.link(self.__path, self.__oldpath) os.unlink(self.__path) # Apply new configuration. assert(os.path.exists(self.__newpath)) os.link(self.__newpath, self.__path) # Remove temporary file. os.unlink(self.__newpath) self.__state = self.__STATE['APPLIED'] def revert(self): if self.__state != self.__STATE['APPLIED']: raise Error("Attempt to revert configuration from state %s" % self.__state) for child in self.__children: child.revert() log("Reverting changes to %s configuration" % self.__path) # Remove existing new configuration if os.access(self.__newpath, os.F_OK): os.unlink(self.__newpath) # Revert new configuration. if os.access(self.__path, os.F_OK): os.link(self.__path, self.__newpath) os.unlink(self.__path) # Revert to old configuration. if os.access(self.__oldpath, os.F_OK): os.link(self.__oldpath, self.__path) os.unlink(self.__oldpath) # Leave .*.xapi-new as an aid to debugging. self.__state = self.__STATE['REVERTED'] def commit(self): if self.__state != self.__STATE['APPLIED']: raise Error("Attempt to commit configuration from state %s" % self.__state) for child in self.__children: child.commit() log("Committing changes to %s configuration" % self.__path) if os.access(self.__oldpath, os.F_OK): os.unlink(self.__oldpath) if os.access(self.__newpath, os.F_OK): os.unlink(self.__newpath) self.__state = self.__STATE['COMMITTED'] # # Helper functions for encoding/decoding database attributes to/from XML. # def _str_to_xml(xml, parent, tag, val): e = xml.createElement(tag) parent.appendChild(e) v = xml.createTextNode(val) e.appendChild(v) def _str_from_xml(n): def getText(nodelist): rc = "" for node in nodelist: if node.nodeType == node.TEXT_NODE: rc = rc + node.data return rc return getText(n.childNodes).strip() def _bool_to_xml(xml, parent, tag, val): if val: _str_to_xml(xml, parent, tag, "True") else: _str_to_xml(xml, parent, tag, "False") def _bool_from_xml(n): s = _str_from_xml(n) if s == "True": return True elif s == "False": return False else: raise Error("Unknown boolean value %s" % s) def _strlist_to_xml(xml, parent, ltag, itag, val): e = xml.createElement(ltag) parent.appendChild(e) for v in val: c = xml.createElement(itag) e.appendChild(c) cv = xml.createTextNode(v) c.appendChild(cv) def _strlist_from_xml(n, ltag, itag): ret = [] for n in n.childNodes: if n.nodeName == itag: ret.append(_str_from_xml(n)) return ret def _otherconfig_to_xml(xml, parent, val, attrs): otherconfig = xml.createElement("other_config") parent.appendChild(otherconfig) for n,v in val.items(): if not n in attrs: raise Error("Unknown other-config attribute: %s" % n) _str_to_xml(xml, otherconfig, n, v) def _otherconfig_from_xml(n, attrs): ret = {} for n in n.childNodes: if n.nodeName in attrs: ret[n.nodeName] = _str_from_xml(n) return ret # # Definitions of the database objects (and their attributes) used by interface-reconfigure. # # Each object is defined by a dictionary mapping an attribute name in # the xapi database to a tuple containing two items: # - a function which takes this attribute and encodes it as XML. # - a function which takes XML and decocdes it into a value. # # other-config attributes are specified as a simple array of strings _PIF_XML_TAG = "pif" _VLAN_XML_TAG = "vlan" _BOND_XML_TAG = "bond" _NETWORK_XML_TAG = "network" _ETHTOOL_OTHERCONFIG_ATTRS = ['ethtool-%s' % x for x in 'autoneg', 'speed', 'duplex', 'rx', 'tx', 'sg', 'tso', 'ufo', 'gso' ] _PIF_OTHERCONFIG_ATTRS = [ 'domain', 'peerdns', 'defaultroute', 'mtu', 'static-routes' ] + \ [ 'bond-%s' % x for x in 'mode', 'miimon', 'downdelay', 'updelay', 'use_carrier' ] + \ _ETHTOOL_OTHERCONFIG_ATTRS _PIF_ATTRS = { 'uuid': (_str_to_xml,_str_from_xml), 'management': (_bool_to_xml,_bool_from_xml), 'network': (_str_to_xml,_str_from_xml), 'device': (_str_to_xml,_str_from_xml), 'bond_master_of': (lambda x, p, t, v: _strlist_to_xml(x, p, 'bond_master_of', 'slave', v), lambda n: _strlist_from_xml(n, 'bond_master_of', 'slave')), 'bond_slave_of': (_str_to_xml,_str_from_xml), 'VLAN': (_str_to_xml,_str_from_xml), 'VLAN_master_of': (_str_to_xml,_str_from_xml), 'VLAN_slave_of': (lambda x, p, t, v: _strlist_to_xml(x, p, 'VLAN_slave_of', 'master', v), lambda n: _strlist_from_xml(n, 'VLAN_slave_Of', 'master')), 'ip_configuration_mode': (_str_to_xml,_str_from_xml), 'IP': (_str_to_xml,_str_from_xml), 'netmask': (_str_to_xml,_str_from_xml), 'gateway': (_str_to_xml,_str_from_xml), 'DNS': (_str_to_xml,_str_from_xml), 'MAC': (_str_to_xml,_str_from_xml), 'other_config': (lambda x, p, t, v: _otherconfig_to_xml(x, p, v, _PIF_OTHERCONFIG_ATTRS), lambda n: _otherconfig_from_xml(n, _PIF_OTHERCONFIG_ATTRS)), # Special case: We write the current value # PIF.currently-attached to the cache but since it will # not be valid when we come to use the cache later # (i.e. after a reboot) we always read it as False. 'currently_attached': (_bool_to_xml, lambda n: False), } _VLAN_ATTRS = { 'uuid': (_str_to_xml,_str_from_xml), 'tagged_PIF': (_str_to_xml,_str_from_xml), 'untagged_PIF': (_str_to_xml,_str_from_xml), } _BOND_ATTRS = { 'uuid': (_str_to_xml,_str_from_xml), 'master': (_str_to_xml,_str_from_xml), 'slaves': (lambda x, p, t, v: _strlist_to_xml(x, p, 'slaves', 'slave', v), lambda n: _strlist_from_xml(n, 'slaves', 'slave')), } _NETWORK_OTHERCONFIG_ATTRS = [ 'mtu', 'static-routes' ] + _ETHTOOL_OTHERCONFIG_ATTRS _NETWORK_ATTRS = { 'uuid': (_str_to_xml,_str_from_xml), 'bridge': (_str_to_xml,_str_from_xml), 'MTU': (_str_to_xml,_str_from_xml), 'PIFs': (lambda x, p, t, v: _strlist_to_xml(x, p, 'PIFs', 'PIF', v), lambda n: _strlist_from_xml(n, 'PIFs', 'PIF')), 'other_config': (lambda x, p, t, v: _otherconfig_to_xml(x, p, v, _NETWORK_OTHERCONFIG_ATTRS), lambda n: _otherconfig_from_xml(n, _NETWORK_OTHERCONFIG_ATTRS)), } # # Database Cache object # _db = None def db(): assert(_db is not None) return _db def db_init_from_cache(cache): global _db assert(_db is None) _db = DatabaseCache(cache_file=cache) def db_init_from_xenapi(session): global _db assert(_db is None) _db = DatabaseCache(session_ref=session) class DatabaseCache(object): def __read_xensource_inventory(self): filename = root_prefix() + "/etc/xensource-inventory" f = open(filename, "r") lines = [x.strip("\n") for x in f.readlines()] f.close() defs = [ (l[:l.find("=")], l[(l.find("=") + 1):]) for l in lines ] defs = [ (a, b.strip("'")) for (a,b) in defs ] return dict(defs) def __pif_on_host(self,pif): return self.__pifs.has_key(pif) def __get_pif_records_from_xapi(self, session, host): self.__pifs = {} for (p,rec) in session.xenapi.PIF.get_all_records().items(): if rec['host'] != host: continue self.__pifs[p] = {} for f in _PIF_ATTRS: self.__pifs[p][f] = rec[f] self.__pifs[p]['other_config'] = {} for f in _PIF_OTHERCONFIG_ATTRS: if not rec['other_config'].has_key(f): continue self.__pifs[p]['other_config'][f] = rec['other_config'][f] def __get_vlan_records_from_xapi(self, session): self.__vlans = {} for (v,rec) in session.xenapi.VLAN.get_all_records().items(): if not self.__pif_on_host(rec['untagged_PIF']): continue self.__vlans[v] = {} for f in _VLAN_ATTRS: self.__vlans[v][f] = rec[f] def __get_bond_records_from_xapi(self, session): self.__bonds = {} for (b,rec) in session.xenapi.Bond.get_all_records().items(): if not self.__pif_on_host(rec['master']): continue self.__bonds[b] = {} for f in _BOND_ATTRS: self.__bonds[b][f] = rec[f] def __get_network_records_from_xapi(self, session): self.__networks = {} for (n,rec) in session.xenapi.network.get_all_records().items(): self.__networks[n] = {} for f in _NETWORK_ATTRS: if f == "PIFs": # drop PIFs on other hosts self.__networks[n][f] = [p for p in rec[f] if self.__pif_on_host(p)] elif f == "MTU" and f not in rec: # XenServer 5.5 network records did not have an # MTU field, so allow this to be missing. pass else: self.__networks[n][f] = rec[f] self.__networks[n]['other_config'] = {} for f in _NETWORK_OTHERCONFIG_ATTRS: if not rec['other_config'].has_key(f): continue self.__networks[n]['other_config'][f] = rec['other_config'][f] def __to_xml(self, xml, parent, key, ref, rec, attrs): """Encode a database object as XML""" e = xml.createElement(key) parent.appendChild(e) if ref: e.setAttribute('ref', ref) for n,v in rec.items(): if attrs.has_key(n): h,_ = attrs[n] h(xml, e, n, v) else: raise Error("Unknown attribute %s" % n) def __from_xml(self, e, attrs): """Decode a database object from XML""" ref = e.attributes['ref'].value rec = {} for n in e.childNodes: if n.nodeName in attrs: _,h = attrs[n.nodeName] rec[n.nodeName] = h(n) return (ref,rec) def __init__(self, session_ref=None, cache_file=None): if session_ref and cache_file: raise Error("can't specify session reference and cache file") if cache_file == None: import XenAPI session = XenAPI.xapi_local() if not session_ref: log("No session ref given on command line, logging in.") session.xenapi.login_with_password("root", "") else: session._session = session_ref try: inventory = self.__read_xensource_inventory() assert(inventory.has_key('INSTALLATION_UUID')) log("host uuid is %s" % inventory['INSTALLATION_UUID']) host = session.xenapi.host.get_by_uuid(inventory['INSTALLATION_UUID']) self.__get_pif_records_from_xapi(session, host) self.__get_vlan_records_from_xapi(session) self.__get_bond_records_from_xapi(session) self.__get_network_records_from_xapi(session) finally: if not session_ref: session.xenapi.session.logout() else: log("Loading xapi database cache from %s" % cache_file) xml = parseXML(root_prefix() + cache_file) self.__pifs = {} self.__bonds = {} self.__vlans = {} self.__networks = {} assert(len(xml.childNodes) == 1) toplevel = xml.childNodes[0] assert(toplevel.nodeName == "xenserver-network-configuration") for n in toplevel.childNodes: if n.nodeName == "#text": pass elif n.nodeName == _PIF_XML_TAG: (ref,rec) = self.__from_xml(n, _PIF_ATTRS) self.__pifs[ref] = rec elif n.nodeName == _BOND_XML_TAG: (ref,rec) = self.__from_xml(n, _BOND_ATTRS) self.__bonds[ref] = rec elif n.nodeName == _VLAN_XML_TAG: (ref,rec) = self.__from_xml(n, _VLAN_ATTRS) self.__vlans[ref] = rec elif n.nodeName == _NETWORK_XML_TAG: (ref,rec) = self.__from_xml(n, _NETWORK_ATTRS) self.__networks[ref] = rec else: raise Error("Unknown XML element %s" % n.nodeName) def save(self, cache_file): xml = getDOMImplementation().createDocument( None, "xenserver-network-configuration", None) for (ref,rec) in self.__pifs.items(): self.__to_xml(xml, xml.documentElement, _PIF_XML_TAG, ref, rec, _PIF_ATTRS) for (ref,rec) in self.__bonds.items(): self.__to_xml(xml, xml.documentElement, _BOND_XML_TAG, ref, rec, _BOND_ATTRS) for (ref,rec) in self.__vlans.items(): self.__to_xml(xml, xml.documentElement, _VLAN_XML_TAG, ref, rec, _VLAN_ATTRS) for (ref,rec) in self.__networks.items(): self.__to_xml(xml, xml.documentElement, _NETWORK_XML_TAG, ref, rec, _NETWORK_ATTRS) f = open(cache_file, 'w') f.write(xml.toprettyxml()) f.close() def get_pif_by_uuid(self, uuid): pifs = map(lambda (ref,rec): ref, filter(lambda (ref,rec): uuid == rec['uuid'], self.__pifs.items())) if len(pifs) == 0: raise Error("Unknown PIF \"%s\"" % uuid) elif len(pifs) > 1: raise Error("Non-unique PIF \"%s\"" % uuid) return pifs[0] def get_pifs_by_device(self, device): return map(lambda (ref,rec): ref, filter(lambda (ref,rec): rec['device'] == device, self.__pifs.items())) def get_pif_by_bridge(self, bridge): networks = map(lambda (ref,rec): ref, filter(lambda (ref,rec): rec['bridge'] == bridge, self.__networks.items())) if len(networks) == 0: raise Error("No matching network \"%s\"" % bridge) answer = None for network in networks: nwrec = self.get_network_record(network) for pif in nwrec['PIFs']: pifrec = self.get_pif_record(pif) if answer: raise Error("Multiple PIFs on host for network %s" % (bridge)) answer = pif if not answer: raise Error("No PIF on host for network %s" % (bridge)) return answer def get_pif_record(self, pif): if self.__pifs.has_key(pif): return self.__pifs[pif] raise Error("Unknown PIF \"%s\"" % pif) def get_all_pifs(self): return self.__pifs def pif_exists(self, pif): return self.__pifs.has_key(pif) def get_management_pif(self): """ Returns the management pif on host """ all = self.get_all_pifs() for pif in all: pifrec = self.get_pif_record(pif) if pifrec['management']: return pif return None def get_network_record(self, network): if self.__networks.has_key(network): return self.__networks[network] raise Error("Unknown network \"%s\"" % network) def get_bond_record(self, bond): if self.__bonds.has_key(bond): return self.__bonds[bond] else: return None def get_vlan_record(self, vlan): if self.__vlans.has_key(vlan): return self.__vlans[vlan] else: return None # # # def ethtool_settings(oc): settings = [] if oc.has_key('ethtool-speed'): val = oc['ethtool-speed'] if val in ["10", "100", "1000"]: settings += ['speed', val] else: log("Invalid value for ethtool-speed = %s. Must be 10|100|1000." % val) if oc.has_key('ethtool-duplex'): val = oc['ethtool-duplex'] if val in ["10", "100", "1000"]: settings += ['duplex', 'val'] else: log("Invalid value for ethtool-duplex = %s. Must be half|full." % val) if oc.has_key('ethtool-autoneg'): val = oc['ethtool-autoneg'] if val in ["true", "on"]: settings += ['autoneg', 'on'] elif val in ["false", "off"]: settings += ['autoneg', 'off'] else: log("Invalid value for ethtool-autoneg = %s. Must be on|true|off|false." % val) offload = [] for opt in ("rx", "tx", "sg", "tso", "ufo", "gso"): if oc.has_key("ethtool-" + opt): val = oc["ethtool-" + opt] if val in ["true", "on"]: offload += [opt, 'on'] elif val in ["false", "off"]: offload += [opt, 'off'] else: log("Invalid value for ethtool-%s = %s. Must be on|true|off|false." % (opt, val)) return settings,offload # By default the MTU is taken from the Network.MTU setting for VIF, # PIF and Bridge. However it is possible to override this by using # {VIF,PIF,Network}.other-config:mtu. # # type parameter is a string describing the object that the oc parameter # is from. e.g. "PIF", "Network" def mtu_setting(nw, type, oc): mtu = None nwrec = db().get_network_record(nw) if nwrec.has_key('MTU'): mtu = nwrec['MTU'] else: mtu = "1500" if oc.has_key('mtu'): log("Override Network.MTU setting on bridge %s from %s.MTU is %s" % \ (nwrec['bridge'], type, mtu)) mtu = oc['mtu'] if mtu is not None: try: int(mtu) # Check that the value is an integer return mtu except ValueError, x: log("Invalid value for mtu = %s" % mtu) return None # # IP Network Devices -- network devices with IP configuration # def pif_ipdev_name(pif): """Return the ipdev name associated with pif""" pifrec = db().get_pif_record(pif) nwrec = db().get_network_record(pifrec['network']) if nwrec['bridge']: # TODO: sanity check that nwrec['bridgeless'] != 'true' return nwrec['bridge'] else: # TODO: sanity check that nwrec['bridgeless'] == 'true' return pif_netdev_name(pif) # # Bare Network Devices -- network devices without IP configuration # def netdev_exists(netdev): return os.path.exists(root_prefix() + "/sys/class/net/" + netdev) def pif_netdev_name(pif): """Get the netdev name for a PIF.""" pifrec = db().get_pif_record(pif) if pif_is_vlan(pif): return "%(device)s.%(VLAN)s" % pifrec else: return pifrec['device'] # # Bridges # def pif_is_bridged(pif): pifrec = db().get_pif_record(pif) nwrec = db().get_network_record(pifrec['network']) if nwrec['bridge']: # TODO: sanity check that nwrec['bridgeless'] != 'true' return True else: # TODO: sanity check that nwrec['bridgeless'] == 'true' return False def pif_bridge_name(pif): """Return the bridge name of a pif. PIF must be a bridged PIF.""" pifrec = db().get_pif_record(pif) nwrec = db().get_network_record(pifrec['network']) if nwrec['bridge']: return nwrec['bridge'] else: raise Error("PIF %(uuid)s does not have a bridge name" % pifrec) # # Bonded PIFs # def pif_is_bond(pif): pifrec = db().get_pif_record(pif) return len(pifrec['bond_master_of']) > 0 def pif_get_bond_masters(pif): """Returns a list of PIFs which are bond masters of this PIF""" pifrec = db().get_pif_record(pif) bso = pifrec['bond_slave_of'] # bond-slave-of is currently a single reference but in principle a # PIF could be a member of several bonds which are not # concurrently attached. Be robust to this possibility. if not bso or bso == "OpaqueRef:NULL": bso = [] elif not type(bso) == list: bso = [bso] bondrecs = [db().get_bond_record(bond) for bond in bso] bondrecs = [rec for rec in bondrecs if rec] return [bond['master'] for bond in bondrecs] def pif_get_bond_slaves(pif): """Returns a list of PIFs which make up the given bonded pif.""" pifrec = db().get_pif_record(pif) bmo = pifrec['bond_master_of'] if len(bmo) > 1: raise Error("Bond-master-of contains too many elements") if len(bmo) == 0: return [] bondrec = db().get_bond_record(bmo[0]) if not bondrec: raise Error("No bond record for bond master PIF") return bondrec['slaves'] # # VLAN PIFs # def pif_is_vlan(pif): return db().get_pif_record(pif)['VLAN'] != '-1' def pif_get_vlan_slave(pif): """Find the PIF which is the VLAN slave of pif. Returns the 'physical' PIF underneath the a VLAN PIF @pif.""" pifrec = db().get_pif_record(pif) vlan = pifrec['VLAN_master_of'] if not vlan or vlan == "OpaqueRef:NULL": raise Error("PIF is not a VLAN master") vlanrec = db().get_vlan_record(vlan) if not vlanrec: raise Error("No VLAN record found for PIF") return vlanrec['tagged_PIF'] def pif_get_vlan_masters(pif): """Returns a list of PIFs which are VLANs on top of the given pif.""" pifrec = db().get_pif_record(pif) vlans = [db().get_vlan_record(v) for v in pifrec['VLAN_slave_of']] return [v['untagged_PIF'] for v in vlans if v and db().pif_exists(v['untagged_PIF'])] # # Datapath base class # class Datapath(object): """Object encapsulating the actions necessary to (de)configure the datapath for a given PIF. Does not include configuration of the IP address on the ipdev. """ def __init__(self, pif): self._pif = pif def configure_ipdev(self, cfg): """Write ifcfg TYPE field for an IPdev, plus any type specific fields to cfg """ raise NotImplementedError def preconfigure(self, parent): """Prepare datapath configuration for PIF, but do not actually apply any changes. Any configuration files should be attached to parent. """ raise NotImplementedError def bring_down_existing(self): """Tear down any existing network device configuration which needs to be undone in order to bring this PIF up. """ raise NotImplementedError def configure(self): """Apply the configuration prepared in the preconfigure stage. Should assume any configuration files changed attached in the preconfigure stage are applied and bring up the necesary devices to provide the datapath for the PIF. Should not bring up the IPdev. """ raise NotImplementedError def post(self): """Called after the IPdev has been brought up. Should do any final setup, including reinstating any devices which were taken down in the bring_down_existing hook. """ raise NotImplementedError def bring_down(self): """Tear down and deconfigure the datapath. Should assume the IPdev has already been brought down. """ raise NotImplementedError def DatapathFactory(pif): # XXX Need a datapath object for bridgeless PIFs try: network_conf = open(root_prefix() + "/etc/xensource/network.conf", 'r') network_backend = network_conf.readline().strip() network_conf.close() except Exception, e: raise Error("failed to determine network backend:" + e) if network_backend == "bridge": from InterfaceReconfigureBridge import DatapathBridge return DatapathBridge(pif) elif network_backend in ["openvswitch", "vswitch"]: from InterfaceReconfigureVswitch import DatapathVswitch return DatapathVswitch(pif) else: raise Error("unknown network backend %s" % network_backend)