| # 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. |
| from OvmCommonModule import * |
| import traceback |
| import time |
| import re |
| |
| logger = OvmLogger("OvmNetwork") |
| |
| class Filter: |
| class Network: |
| IFNAME_LO = r'(lo)' |
| IFNAME_BRIDGE = r'(xenbr\d+|vlan\d+)' |
| IFNAME_PIF = r'(eth\d+$|bond\d+$)' |
| IFNAME_VLAN = r'(eth\d+.\d+$|bond\d+.\d+$)' |
| |
| |
| class Parser(object): |
| ''' |
| classdocs |
| ''' |
| def findall(self, pattern, samples): |
| """ |
| @param pattern: search pattern |
| @param result: Parser line execution result |
| @return : list of search |
| find result of Parser which has same pattern |
| findall Parser find all pattern in a string |
| """ |
| result = [] |
| for line in samples: |
| items = re.findall(pattern, line) |
| for item in items: |
| result.append(item) |
| return result |
| |
| def checkPattern(self, pattern, cmd_result): |
| """ |
| @param pattern: search pattern |
| @param cmd_result: Parser line execution result |
| @return : True (if pattern is occurred) |
| """ |
| for line in cmd_result: |
| items = re.findall(pattern, line) |
| if len(items) > 0: |
| return True |
| return False |
| |
| def search(self, cmd_result, pattern): |
| return None |
| |
| class OvmVlanDecoder(json.JSONDecoder): |
| def decode(self, jStr): |
| deDict = asciiLoads(jStr) |
| vlan = OvmVlan() |
| setAttrFromDict(vlan, 'vid', deDict, int) |
| setAttrFromDict(vlan, 'pif', deDict) |
| return vlan |
| |
| class OvmVlanEncoder(json.JSONEncoder): |
| def default(self, obj): |
| if not isinstance(obj, OvmVlan): raise Exception("%s is not instance of OvmVlan"%type(obj)) |
| dct = {} |
| safeDictSet(obj, dct, 'name') |
| safeDictSet(obj, dct, 'vid') |
| safeDictSet(obj, dct, 'pif') |
| return dct |
| |
| def toOvmVlan(jStr): |
| return json.loads(jStr, cls=OvmVlanDecoder) |
| |
| def fromOvmVlan(vlan): |
| return normalizeToGson(json.dumps(vlan, cls=OvmVlanEncoder)) |
| |
| class OvmBridgeDecoder(json.JSONDecoder): |
| def decode(self, jStr): |
| deDic = asciiLoads(jStr) |
| bridge = OvmBridge() |
| setAttrFromDict(bridge, 'name', deDic) |
| setAttrFromDict(bridge, 'attach', deDic) |
| return bridge |
| |
| class OvmBridgeEncoder(json.JSONEncoder): |
| def default(self, obj): |
| if not isinstance(obj, OvmBridge): raise Exception("%s is not instance of OvmBridge"%type(obj)) |
| dct = {} |
| safeDictSet(obj, dct, 'name') |
| safeDictSet(obj, dct, 'attach') |
| safeDictSet(obj, dct, 'interfaces') |
| return dct |
| |
| def toOvmBridge(jStr): |
| return json.loads(jStr, cls=OvmBridgeDecoder) |
| |
| def fromOvmBridge(bridge): |
| return normalizeToGson(json.dumps(bridge, cls=OvmBridgeEncoder)) |
| |
| class OvmInterface(OvmObject): |
| name = '' |
| |
| class OvmVlan(OvmInterface): |
| vid = 0 |
| pif = '' |
| |
| class OvmBridge(OvmInterface): |
| attach = '' |
| interfaces = [] |
| |
| |
| class OvmNetwork(OvmObject): |
| ''' |
| Network |
| ''' |
| |
| @property |
| def pifs(self): |
| return self._getInterfaces("pif") |
| |
| @property |
| def vlans(self): |
| return self._getInterfaces("vlan") |
| |
| @property |
| def bridges(self): |
| return self._getInterfaces("bridge") |
| |
| def __init__(self): |
| self.Parser = Parser() |
| |
| def _createVlan(self, vlan): |
| """ |
| @param jsonString : parameter from client side |
| @return : succ xxxxx |
| ex. jsonString => {vid:100, pif:eth0} |
| ex. return => |
| """ |
| |
| #Pre-condition |
| #check Physical Interface Name |
| if vlan.pif not in self.pifs.keys(): |
| msg = "Physical Interface(%s) does not exist" % vlan.pif |
| logger.debug(self._createVlan, msg) |
| raise Exception(msg) |
| |
| #Pre-condition |
| #check Vlan Interface Name |
| ifName = "%s.%s" % (vlan.pif, vlan.vid) |
| if ifName in self.vlans.keys(): |
| msg = "Vlan Interface(%s) already exist, return it" % ifName |
| logger.debug(self._createVlan, msg) |
| return self.vlans[ifName] |
| |
| doCmd(['vconfig', 'add', vlan.pif, vlan.vid]) |
| self.bringUP(ifName) |
| logger.debug(self._createVlan, "Create vlan %s successfully"%ifName) |
| return self.vlans[ifName] |
| |
| def _deleteVlan(self, name): |
| if name not in self.vlans.keys(): |
| raise Exception("No vlan device %s found"%name) |
| |
| vlan = self.vlans[name] |
| self.bringDown(vlan.name) |
| doCmd(['vconfig', 'rem', vlan.name]) |
| logger.debug(self._deleteVlan, "Delete vlan %s successfully"%vlan.name) |
| |
| |
| def _createBridge(self, bridge): |
| """ |
| @return : success |
| ex. {bridge:xapi100, attach:eth0.100} |
| create bridge interface, and attached it |
| cmd 1: brctl addbr bridge |
| cmd 2: brctl addif brdige attach |
| """ |
| |
| if "xenbr" not in bridge.name and "vlan" not in bridge.name: |
| raise Exception("Invalid bridge name %s. Bridge name must be in partten xenbr/vlan, e.g. xenbr0"%bridge.name) |
| |
| #pre-condition |
| #check Bridge Interface Name |
| if bridge.name in self.bridges.keys(): |
| msg = "Bridge(%s) already exist, return it" % bridge.name |
| logger.debug(self._createBridge, msg) |
| return self.bridges[bridge.name] |
| |
| #pre-condition |
| #check attach must exist |
| #possible to attach in PIF or VLAN |
| if bridge.attach not in self.vlans.keys() and bridge.attach not in self.pifs.keys(): |
| msg = "%s is not either pif or vlan" % bridge.attach |
| logger.error(self._createBridge, msg) |
| raise Exception(msg) |
| |
| doCmd(['brctl', 'addbr', bridge.name]) |
| doCmd(['brctl', 'addif', bridge.name, bridge.attach]) |
| self.bringUP(bridge.name) |
| logger.debug(self._createBridge, "Create bridge %s on %s successfully"%(bridge.name, bridge.attach)) |
| return self.bridges[bridge.name] |
| |
| def _getBridges(self): |
| return self.bridges.keys() |
| |
| def _getVlans(self): |
| return self.vlans.keys() |
| |
| def _deleteBridge(self, name): |
| if name not in self.bridges.keys(): |
| raise Exception("Can not find bridge %s"%name) |
| |
| bridge = self.bridges[name] |
| if bridge.attach in bridge.interfaces: bridge.interfaces.remove(bridge.attach) |
| if len(bridge.interfaces) != 0: |
| logger.debug(self._deleteBridge, "There are still some interfaces(%s) on bridge %s"%(bridge.interfaces, bridge.name)) |
| return False |
| self.bringDown(bridge.name) |
| doCmd(['brctl', 'delbr', bridge.name]) |
| logger.debug(self._deleteBridge, "Delete bridge %s successfully"%bridge.name) |
| return True |
| |
| def _getInterfaces(self, type): |
| """ |
| @param type : ["pif", "bridge", "tap"] |
| @return : dictionary of Interface Objects |
| get All Interfaces based on type |
| """ |
| devices = os.listdir('/sys/class/net') |
| ifs = {} |
| if type == "pif": |
| devs = self.Parser.findall(Filter.Network.IFNAME_PIF, devices) |
| for dev in set(devs): |
| ifInst = OvmInterface() |
| ifInst.name = dev |
| ifs[dev] = ifInst |
| |
| elif type == "vlan": |
| devs = self.Parser.findall(Filter.Network.IFNAME_VLAN, devices) |
| for dev in set(devs): |
| ifInst = OvmVlan() |
| ifInst.name = dev |
| (pif, vid) = dev.split('.') |
| ifInst.pif = pif |
| ifInst.vid = vid |
| ifs[dev] = ifInst |
| |
| elif type == "bridge": |
| devs = self.Parser.findall(Filter.Network.IFNAME_BRIDGE, devices) |
| for dev in set(devs): |
| ifInst = OvmBridge() |
| ifInst.name = dev |
| devs = os.listdir(join('/sys/class/net', dev, 'brif')) |
| ifInst.interfaces = devs |
| attches = self.Parser.findall(Filter.Network.IFNAME_PIF, devs) + self.Parser.findall(Filter.Network.IFNAME_VLAN, devs) |
| if len(attches) > 1: raise Exception("Multiple PIF on bridge %s (%s)"%(dev, attches)) |
| elif len(attches) == 0: ifInst.attach = "null" |
| elif len(attches) == 1: ifInst.attach = attches[0] |
| ifs[dev] = ifInst |
| |
| return ifs |
| |
| def bringUP(self, ifName): |
| doCmd(['ifconfig', ifName, 'up']) |
| |
| def bringDown(self, ifName): |
| doCmd(['ifconfig', ifName, 'down']) |
| |
| @staticmethod |
| def createBridge(jStr): |
| try: |
| network = OvmNetwork() |
| network._createBridge(toOvmBridge(jStr)) |
| return SUCC() |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.createBridge, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.createBridge), errmsg) |
| |
| @staticmethod |
| def deleteBridge(name): |
| try: |
| network = OvmNetwork() |
| network._deleteBridge(name) |
| return SUCC() |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.deleteBridge, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.deleteBridge), errmsg) |
| |
| @staticmethod |
| def getAllBridges(): |
| try: |
| network = OvmNetwork() |
| rs = toGson(network._getBridges()) |
| logger.debug(OvmNetwork.getAllBridges, rs) |
| return rs |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.getAllBridges, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.getAllBridges), errmsg) |
| |
| @staticmethod |
| def getBridgeByIp(ip): |
| try: |
| routes = doCmd(['ip', 'route']).split('\n') |
| brName = None |
| for r in routes: |
| if ip in r and "xenbr" in r or "vlan" in r: |
| brName = r.split(' ')[2] |
| break |
| if not brName: raise Exception("Cannot find bridge with IP %s"%ip) |
| logger.debug(OvmNetwork.getBridgeByIp, "bridge:%s, ip:%s"%(brName, ip)) |
| return toGson({"bridge":brName}) |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.getBridgeByIp, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.getBridgeByIp), errmsg) |
| |
| @staticmethod |
| def getVlans(): |
| try: |
| network = OvmNetwork() |
| rs = toGson(network._getVlans()) |
| logger.debug(OvmNetwork.getVlans, rs) |
| return rs |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.getVlans, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.getVlans), errmsg) |
| |
| @staticmethod |
| def createVlan(jStr): |
| try: |
| network = OvmNetwork() |
| vlan = network._createVlan(toOvmVlan(jStr)) |
| rs = fromOvmVlan(vlan) |
| logger.debug(OvmNetwork.createVlan, rs) |
| return rs |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.createVlan, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.createVlan), errmsg) |
| |
| @staticmethod |
| def createVlanBridge(bridgeDetails, vlanDetails): |
| try: |
| network = OvmNetwork() |
| v = toOvmVlan(vlanDetails) |
| b = toOvmBridge(bridgeDetails) |
| vlan = network._createVlan(v) |
| b.attach = vlan.name |
| network._createBridge(b) |
| return SUCC() |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.createVlanBridge, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.createVlanBridge), errmsg) |
| |
| @staticmethod |
| def deleteVlanBridge(name): |
| try: |
| network = OvmNetwork() |
| if name not in network.bridges.keys(): |
| logger.debug(OvmNetwork.deleteVlanBridge, "No bridge %s found"%name) |
| return SUCC() |
| |
| bridge = network.bridges[name] |
| vlanName = bridge.attach |
| if network._deleteBridge(name): |
| if vlanName != "null": |
| network._deleteVlan(vlanName) |
| else: |
| logger.warning(OvmNetwork.deleteVlanBridge, "Bridge %s has no vlan device"%name) |
| return SUCC() |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.deleteVlanBridge, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.deleteVlanBridge), errmsg) |
| |
| @staticmethod |
| def getBridgeDetails(name): |
| try: |
| network = OvmNetwork() |
| if name not in network.bridges.keys(): |
| raise Exception("No bridge %s found"%name) |
| bridge = network.bridges[name] |
| rs = fromOvmBridge(bridge) |
| logger.debug(OvmNetwork.getBridgeDetails, rs) |
| return rs |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.getBridgeDetails, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.getBridgeDetails), errmsg) |
| |
| @staticmethod |
| def deleteVlan(name): |
| try: |
| network = OvmNetwork() |
| network._deleteVlan(name) |
| return SUCC() |
| except Exception, e: |
| errmsg = fmt_err_msg(e) |
| logger.error(OvmNetwork.deleteVlan, errmsg) |
| raise XmlRpcFault(toErrCode(OvmNetwork, OvmNetwork.deleteVlan), errmsg) |
| |
| if __name__ == "__main__": |
| try: |
| OvmNetwork.getBridgeDetails(sys.argv[1]) |
| #======================================================================= |
| # txt = json.dumps({"vid":104, "pif":"eth0"}) |
| # txt2 = json.dumps({"name":"xapi3", "attach":"eth0.104"}) |
| # print nw.createVlan(txt) |
| # print nw.createBridge(txt2) |
| # |
| # nw.deleteBridge("xapi3") |
| # nw.deleteVlan("eth0.104") |
| #======================================================================= |
| |
| except Exception, e: |
| print e |
