X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=src%2Fnepi%2Fresources%2Fomf%2Finterface.py;h=d7142d1b54c5f4b1dd6139a3ed7eb2b725a289c3;hb=d50ba1a08e541ded7a8b322493ebb1d0cc59c6ff;hp=b4c1df7b38d80d2f1674eb78e2aa08ee89733026;hpb=09ac796bac9aa2c41c5ad830f404fe128fffb22d;p=nepi.git diff --git a/src/nepi/resources/omf/interface.py b/src/nepi/resources/omf/interface.py index b4c1df7b..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 +import os, time +from nepi.util.timefuncs import tnow from nepi.execution.resource import ResourceManager, clsinit_copy, \ - ResourceState, reschedule_delay + 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,13 +114,13 @@ 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 @@ -125,91 +129,212 @@ class OMFWifiInterface(OMFResource): """ 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 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.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 + + ## 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) + 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._omf_api : - msg = "Credentials are not initialzed. XMPP Connections impossible" + 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) raise RuntimeError, msg - if not (self.get('mode') and self.get('type') and self.get('essid') \ - and 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 not self.node.get('hostname') : - msg = "The channel is connected with an undefined node" + 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" + + 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 - # Just for information - self.debug(" " + self.rtype() + " ( Guid : " + str(self._guid) +") : " + \ - self.get('mode') + " : " + self.get('type') + " : " + \ - self.get('essid') + " : " + self.get('ip')) - - # Check if the node is already deployed - if self.state < ResourceState.PROVISIONED: - if self.configure_iface(): - self.configure_ip() + uid = self.check_deploy(self.create_id) + if not uid: + self._create_cnt +=1 + self.ec.schedule(reschedule_check, self.deploy) + return False + + self._topic_iface = uid + self._omf_api.enroll_topic(self._topic_iface) + return True - super(OMFWifiInterface, self).do_deploy() + 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 + + """ + 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 """ if self._omf_api: - OMFAPIFactory.release_api(self.get('xmppSlice'), - self.get('xmppHost'), self.get('xmppPort'), - self.get('xmppPassword'), exp_id = self.exp_id) + 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()