| # 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) |