X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=src%2Fnepi%2Fresources%2Fomf%2Finterface.py;h=d7142d1b54c5f4b1dd6139a3ed7eb2b725a289c3;hb=d50ba1a08e541ded7a8b322493ebb1d0cc59c6ff;hp=08d39ec9d69f145ef008cb7a3963ca0b1b1ed9e5;hpb=96413965c9502aa92248775e83d6e864b53692bc;p=nepi.git diff --git a/src/nepi/resources/omf/interface.py b/src/nepi/resources/omf/interface.py index 08d39ec9..d7142d1b 100644 --- a/src/nepi/resources/omf/interface.py +++ b/src/nepi/resources/omf/interface.py @@ -18,14 +18,16 @@ # Author: Alina Quereilhac # Julien Tribino -from nepi.execution.resource import ResourceManager, clsinit_copy, ResourceState, \ - reschedule_delay +import os, time +from nepi.util.timefuncs import tnow +from nepi.execution.resource import ResourceManager, clsinit_copy, \ + ResourceState from nepi.execution.attribute import Attribute, Flags -from nepi.resources.omf.node import OMFNode +from nepi.resources.omf.node import OMFNode, confirmation_counter, reschedule_check from nepi.resources.omf.omf_resource import ResourceGateway, OMFResource from nepi.resources.omf.channel import OMFChannel -from nepi.resources.omf.omf_api import OMFAPIFactory +from nepi.resources.omf.omf_api_factory import OMFAPIFactory @clsinit_copy class OMFWifiInterface(OMFResource): @@ -36,33 +38,24 @@ class OMFWifiInterface(OMFResource): :type ec: ExperimentController :param guid: guid of the RM :type guid: int - :param creds: Credentials to communicate with the rm (XmppClient for OMF) - :type creds: dict - - .. note:: - - This class is used only by the Experiment Controller through the Resource - Factory """ - _rtype = "OMFWifiInterface" - _authorized_connections = ["OMFNode" , "OMFChannel"] - - #alias2name = dict({'w0':'wlan0', 'w1':'wlan1'}) + _rtype = "omf::WifiInterface" + _authorized_connections = ["omf::Node" , "omf::Channel", "wilabt::sfa::Node"] @classmethod def _register_attributes(cls): """Register the attributes of an OMF interface """ - alias = Attribute("alias","Alias of the interface", default = "w0") + name = Attribute("name","Alias of the interface : wlan0, wlan1, ..", default = "wlan0") mode = Attribute("mode","Mode of the interface") - type = Attribute("type","Type of the interface") + hw_mode = Attribute("hw_mode","Choose between : a, b, g, n") essid = Attribute("essid","Essid of the interface") ip = Attribute("ip","IP of the interface") - cls._register_attribute(alias) + cls._register_attribute(name) cls._register_attribute(mode) - cls._register_attribute(type) + cls._register_attribute(hw_mode) cls._register_attribute(essid) cls._register_attribute(ip) @@ -78,8 +71,21 @@ class OMFWifiInterface(OMFResource): """ super(OMFWifiInterface, self).__init__(ec, guid) + self._conf = False + self.alias = None + self._type = None + + self.create_id = None + self._create_cnt = 0 + self.release_id = None + self._release_cnt = 0 + self._topic_iface = None self._omf_api = None - self._alias = self.get('alias') + self._type = "" + + # For performance tests + self.perf = True + self.begin_deploy_time = None def valid_connection(self, guid): """ Check if the connection with the guid in parameter is possible. @@ -91,17 +97,15 @@ class OMFWifiInterface(OMFResource): """ rm = self.ec.get_resource(guid) - if rm.rtype() in self._authorized_connections: + if rm.get_rtype() in self._authorized_connections: msg = "Connection between %s %s and %s %s accepted" % \ - (self.rtype(), self._guid, rm.rtype(), guid) + (self.get_rtype(), self._guid, rm.get_rtype(), guid) self.debug(msg) - return True msg = "Connection between %s %s and %s %s refused" % \ - (self.rtype(), self._guid, rm.rtype(), guid) + (self.get_rtype(), self._guid, rm.get_rtype(), guid) self.debug(msg) - return False @property @@ -110,116 +114,227 @@ class OMFWifiInterface(OMFResource): @property def node(self): - rm_list = self.get_connected(OMFNode.rtype()) + rm_list = self.get_connected(OMFNode.get_rtype()) if rm_list: return rm_list[0] return None @property def channel(self): - rm_list = self.get_connected(OMFChannel.rtype()) + rm_list = self.get_connected(OMFChannel.get_rtype()) if rm_list: return rm_list[0] return None - def configure_iface(self): """ Configure the interface without the ip """ if self.node.state < ResourceState.READY: - self.ec.schedule(reschedule_delay, self.deploy) + self.ec.schedule(self.reschedule_delay, self.deploy) return False - try : - for attrname in ["mode", "type", "essid"]: + for attrname in ["mode", "type", "essid"]: + if attrname == "type" : + attrval = self._type + else : attrval = self.get(attrname) - attrname = "net/%s/%s" % (self._alias, attrname) - self._omf_api.configure(self.node.get('hostname'), attrname, + attrname = "net/%s/%s" % (self.alias, attrname) + self._omf_api.configure(self.node.get('hostname'), attrname, attrval) - except AttributeError: - self._state = ResourceState.FAILED - msg = "Credentials are not initialzed. XMPP Connections impossible" - self.debug(msg) - #raise - super(OMFWifiInterface, self).provision() + super(OMFWifiInterface, self).do_provision() return True def configure_ip(self): """ Configure the ip of the interface + .. note : The ip is separated from the others parameters to avoid + CELL ID shraing problem. By putting th ip at the end of the configuration, + each node use the same channel and can then share the same CELL ID. + In the second case, the channel is defined at the end and the node don't + share a common CELL ID and can not communicate. + """ if self.channel.state < ResourceState.READY: - self.ec.schedule(reschedule_delay, self.deploy) + self.ec.schedule(self.reschedule_delay, self.deploy) return False - try : - attrval = self.get("ip") - attrname = "net/%s/%s" % (self._alias, "ip") - self._omf_api.configure(self.node.get('hostname'), attrname, + attrval = self.get("ip") + if '/' in attrval: + attrval,mask = attrval.split('/') + attrname = "net/%s/%s" % (self.alias, "ip") + self._omf_api.configure(self.node.get('hostname'), attrname, attrval) - except AttributeError: - msg = "Credentials are not initialzed. XMPP Connections impossible" - self.debug(msg) - self.fail() - #raise - return True - def deploy(self): + + def configure_on_omf5(self): + """ Method to configure the wifi interface when OMF 5.4 is used. + + """ + + self._type = self.get('hw_mode') + if self.get('name') == "wlan0" or "eth0": + self.alias = "w0" + else: + self.alias = "w1" + res = False + if self.state < ResourceState.PROVISIONED: + if self._conf == False: + self._conf = self.configure_iface() + if self._conf == True: + res = self.configure_ip() + return res + + def check_deploy(self, cid): + """ Check, through the mail box in the parser, + if the confirmation of the creation has been received + + :param cid: the id of the original message + :type guid: string + + """ + uid = self._omf_api.check_mailbox("create", cid) + if uid : + return uid + return False + + def do_deploy(self): """ Deploy the RM. It means : Get the xmpp client and send messages - using OMF 5.4 protocol to configure the interface. - It becomes DEPLOYED after sending messages to configure the interface + using OMF 5.4 or 6 protocol to configure the interface. + """ - if not self._omf_api : - self._omf_api = OMFAPIFactory.get_api(self.get('xmppSlice'), - self.get('xmppHost'), self.get('xmppPort'), - self.get('xmppPassword'), exp_id = self.exp_id) + if not self.node or self.node.state < ResourceState.READY: + self.debug("---- RESCHEDULING DEPLOY ---- node state %s " + % self.node.state ) + self.ec.schedule(self.reschedule_delay, self.deploy) + return - if not self._omf_api : - msg = "Credentials are not initialzed. XMPP Connections impossible" - self.error(msg) - self.fail() + if not self.channel or self.channel.state < ResourceState.READY: + self.debug("---- RESCHEDULING DEPLOY ---- channel state %s " + % self.channel.state ) + self.ec.schedule(self.reschedule_delay, self.deploy) return - if not (self.get('mode') and self.get('type') and self.get('essid') \ - and self.get('ip')): - msg = "Interface's variable are not initialized" + ## For performance test + if self.perf: + self.begin_deploy_time = tnow() + self.perf = False + + self.set('xmppUser',self.node.get('xmppUser')) + self.set('xmppServer',self.node.get('xmppServer')) + self.set('xmppPort',self.node.get('xmppPort')) + self.set('xmppPassword',self.node.get('xmppPassword')) + self.set('version',self.node.get('version')) + + if not self.get('xmppServer'): + msg = "XmppServer is not initialzed. XMPP Connections impossible" self.error(msg) - self.fail() - return False + raise RuntimeError, msg + + if not (self.get('xmppUser') or self.get('xmppPort') + or self.get('xmppPassword')): + msg = "Credentials are not all initialzed. Default values will be used" + self.warn(msg) - if not self.node.get('hostname') : - msg = "The channel is connected with an undefined node" + if not self._omf_api : + self._omf_api = OMFAPIFactory.get_api(self.get('version'), + self.get('xmppServer'), self.get('xmppUser'), self.get('xmppPort'), + self.get('xmppPassword'), exp_id = self.exp_id) + + if not (self.get('name')): + msg = "Interface's name is not initialized" self.error(msg) - self.fail() - return False + raise RuntimeError, msg - # Just for information - self.debug(" " + self.rtype() + " ( Guid : " + str(self._guid) +") : " + \ - self.get('mode') + " : " + self.get('type') + " : " + \ - self.get('essid') + " : " + self.get('ip')) + if not (self.get('mode') and self.get('essid') \ + and self.get('hw_mode') and self.get('ip')): + msg = "Interface's variable are not initialized" + self.error(msg) + raise RuntimeError, msg + + if self.get('version') == "5": + res = self.configure_on_omf5() + + else : + res = self.configure_on_omf6() + + if res: + super(OMFWifiInterface, self).do_deploy() + + def configure_on_omf6(self): + """ Method to configure the wifi interface when OMF 6 is used. + + """ + if not self.create_id : + props = {} + props['wlan:if_name'] = self.get('name') + props['wlan:mode'] = { + "mode": self.get('mode'), + "hw_mode" : self.get('hw_mode'), + "channel" : self.channel.get('channel'), + "essid" : self.get('essid'), + "ip_addr" : self.get('ip'), + "frequency" : self.channel.frequency, + "phy" : "%0%" + } + props['wlan:hrn'] = self.get('name') + props['wlan:type'] = "wlan" - # Check if the node is already deployed - chk1 = True - if self.state < ResourceState.PROVISIONED: - chk1 = self.configure_iface() - if chk1: - chk2 = self.configure_ip() + self.create_id = os.urandom(16).encode('hex') + self._omf_api.frcp_create( self.create_id, self.node.get('hostname'), "wlan", props = props) + + if self._create_cnt > confirmation_counter: + msg = "Couldn't retrieve the confirmation of the creation" + self.error(msg) + raise RuntimeError, msg - if not (chk1 and chk2) : + uid = self.check_deploy(self.create_id) + if not uid: + self._create_cnt +=1 + self.ec.schedule(reschedule_check, self.deploy) return False - - super(OMFWifiInterface, self).deploy() + + self._topic_iface = uid + self._omf_api.enroll_topic(self._topic_iface) return True - def release(self): - """ Clean the RM at the end of the experiment and release the API + def check_release(self, cid): + """ Check, through the mail box in the parser, + if the confirmation of the release has been received + + :param cid: the id of the original message + :type guid: string """ - if self._omf_api : - OMFAPIFactory.release_api(self.get('xmppSlice'), - self.get('xmppHost'), self.get('xmppPort'), - self.get('xmppPassword'), exp_id = self.exp_id) + res = self._omf_api.check_mailbox("release", cid) + if res : + return res + return False + + def do_release(self): + """ Clean the RM at the end of the experiment and release the API - super(OMFWifiInterface, self).release() + """ + if self._omf_api: + if self.get('version') == "6" and self._topic_iface : + if not self.release_id: + self.release_id = os.urandom(16).encode('hex') + self._omf_api.frcp_release( self.release_id, self.node.get('hostname'),self._topic_iface, res_id=self._topic_iface) + + if self._release_cnt < confirmation_counter: + cid = self.check_release(self.release_id) + if not cid: + self._release_cnt +=1 + self.ec.schedule(reschedule_check, self.release) + return + else: + msg = "Couldn't retrieve the confirmation of the release" + self.error(msg) + + + OMFAPIFactory.release_api(self.get('version'), + self.get('xmppServer'), self.get('xmppUser'), self.get('xmppPort'), + self.get('xmppPassword'), exp_id = self.exp_id) + + super(OMFWifiInterface, self).do_release()