src/nepi/resources/omf/messages_5_4.py

   1 #
   2 #    NEPI, a framework to manage network experiments
   3 #    Copyright (C) 2013 INRIA
   4 #
   5 #    This program is free software: you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation, either version 3 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 #
  18 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  19 #         Julien Tribino <julien.tribino@inria.fr>
  20
  21 from xml.etree import cElementTree as ET
  22
  23 class MessageHandler():
  24     """
  25     .. class:: Class Args :
  26
  27         :param sliceid: Slice Name (= Xmpp Slice)
  28         :type expid: str
  29         :param expid: Experiment ID (= Xmpp User)
  30         :type expid: str
  31
  32     .. note::
  33
  34        This class is used only for OMF 5.4 Protocol and is going to become unused
  35
  36     """
  37
  38     def __init__(self, sliceid, expid ):
  39         """
  40
  41         :param sliceid: Slice Name (= Xmpp Slice)
  42         :type expid: str
  43         :param expid: Experiment ID (= Xmpp User)
  44         :type expid: str
  45
  46         """
  47         self._slice_id = sliceid
  48         self._exp_id = expid
  49
  50
  51     def _id_element(self, parent, markup):
  52         """ Insert a markup element with an id
  53
  54         :param parent: Parent element in an XML point of view
  55         :type parent: ElementTree Element
  56         :param markup: Name of the markup
  57         :type markup: str
  58
  59         """
  60         elt = ET.SubElement(parent, markup)
  61         elt.set("id", "\'omf-payload\'")
  62         return elt
  63
  64     def _attr_element(self, parent, markup, text):
  65         """ Insert a markup element with a text (value)
  66
  67         :param parent: Parent element in an XML point of view
  68         :type parent: ElementTree Element
  69         :param markup: Name of the markup
  70         :type markup: str
  71         :param text: Value of the markup element
  72         :type text: str
  73
  74         """
  75         elt = ET.SubElement(parent, markup)
  76         elt.text = text
  77         return elt
  78
  79     def execute_function(self, target, appid, cmdlineargs, path, env):
  80         """ Build an Execute Message
  81
  82         :param target: Hrn of the target node (ex : omf.plexus.wlab17)
  83         :type target: str
  84         :param appid: Application id
  85         :type appid: str
  86         :param cmdlineargs: Arguments of the application
  87         :type cmdlineargs: str
  88         :param path: Path of the application
  89         :type path: str
  90         :param env: Environment variables
  91         :type env: str
  92
  93         """
  94         payload = ET.Element("omf-message")
  95         execute = self._id_element(payload,"EXECUTE")
  96         env = self._attr_element(execute, "ENV", env)
  97         sliceid = self._attr_element(execute,"SLICEID",self._slice_id)
  98         expid = self._attr_element(execute,"EXPID",self._exp_id)
  99         target = self._attr_element(execute,"TARGET",target)
 100         appid = self._attr_element(execute,"APPID",appid)
 101         cmdlineargs = self._attr_element(execute,"CMDLINEARGS",cmdlineargs)
 102         path = self._attr_element(execute,"PATH",path)
 103         return payload
 104
 105     def stdin_function(self, target, value, appid):
 106         """ Build an Execute Message
 107
 108         :param value: parameter that go in the stdin
 109         :type value: str
 110         :param target: Hrn of the target node (ex : omf.plexus.wlab17)
 111         :type target: str
 112         :param appid: Application id
 113         :type appid: str
 114
 115         """
 116         payload = ET.Element("omf-message")
 117         stdin = self._id_element(payload,"STDIN")
 118         value = self._attr_element(stdin,"VALUE",value)
 119         sliceid = self._attr_element(stdin,"SLICEID",self._slice_id)
 120         expid = self._attr_element(stdin,"EXPID",self._exp_id)
 121         target = self._attr_element(stdin,"TARGET",target)
 122         appid = self._attr_element(stdin,"APPID",appid)
 123         return payload
 124
 125     def exit_function(self, target, appid):
 126         """ Build an Exit Message
 127
 128         :param target: Hrn of the target node (ex : omf.plexus.wlab17)
 129         :type target: str
 130         :param appid: Application id (ex : vlc#1)
 131         :type appid: str
 132
 133         """
 134         payload = ET.Element("omf-message")
 135         execute = self._id_element(payload,"EXIT")
 136         sliceid = self._attr_element(execute,"SLICEID",self._slice_id)
 137         expid = self._attr_element(execute,"EXPID",self._exp_id)
 138         target = self._attr_element(execute,"TARGET",target)
 139         appid = self._attr_element(execute,"APPID",appid)
 140         return payload
 141
 142     def configure_function(self, target, value, path):
 143         """ Build a Configure Message
 144
 145         :param target: Hrn of the target node (ex : omf.plexus.wlab17)
 146         :type target: str
 147         :param value: guid of the RM
 148         :type value: int
 149         :param path: Path of the element to configure (ex : net/w0/channel)
 150         :type path: dict
 151
 152         """
 153         payload = ET.Element("omf-message")
 154         config = self._id_element(payload, "CONFIGURE")
 155         sliceid = self._attr_element(config,"SLICEID",self._slice_id)
 156         expid = self._attr_element(config,"EXPID",self._exp_id)
 157         target = self._attr_element(config,"TARGET",target)
 158         value = self._attr_element(config,"VALUE",value)
 159         path = self._attr_element(config,"PATH",path)
 160         return payload
 161
 162     def log_function(self,level, logger, level_name, data):
 163         """ Build a Log Message
 164
 165         :param level: Level of logging
 166         :type level: str
 167         :param logger: Element publishing the log
 168         :type logger: str
 169         :param level_name: Name of the level (ex : INFO)
 170         :type level_name: str
 171         :param data: Content to publish
 172         :type data: str
 173
 174         """
 175         payload = ET.Element("omf-message")
 176         log = self._id_element(payload, "LOGGING")
 177         level = self._attr_element(log,"LEVEL",level)
 178         sliceid = self._attr_element(log,"SLICEID",self._slice_id)
 179         logger = self._attr_element(log,"LOGGER",logger)
 180         expid = self._attr_element(log,"EXPID",self._exp_id)
 181         level_name = self._attr_element(log,"LEVEL_NAME",level_name)
 182         data = self._attr_element(log,"DATA",data)
 183         return payload
 184
 185     def alias_function(self, name, target):
 186         """ Build an Alias Message
 187
 188         :param name: Name of the new alias
 189         :type name: str
 190         :param target: Hrn of the target node (ex : omf.plexus.wlab17)
 191         :type target: str
 192
 193         """
 194         payload = ET.Element("omf-message")
 195         alias = self._id_element(payload,"ALIAS")
 196         sliceid = self._attr_element(alias,"SLICEID",self._slice_id)
 197         expid = self._attr_element(alias,"EXPID",self._exp_id)
 198         name = self._attr_element(alias,"NAME",name)
 199         target = self._attr_element(alias,"TARGET",target)
 200         return payload
 201
 202     def enroll_function(self, enrollkey, image, index, target ):
 203         """ Build an Enroll Message
 204
 205         :param enrollkey: Type of enrollment (= 1)
 206         :type enrollkey: str
 207         :param image: Image (= * when all the nodes are concerned)
 208         :type image: str
 209         :param index: Index (= 1 in general)
 210         :type index: str
 211         :param target: Hrn of the target node (ex : omf.plexus.wlab17)
 212         :type target: str
 213
 214         """
 215         payload = ET.Element("omf-message")
 216         enroll = self._id_element(payload,"ENROLL")
 217         enrollkey = self._attr_element(enroll,"ENROLLKEY",enrollkey)
 218         sliceid = self._attr_element(enroll,"SLICEID",self._slice_id)
 219         image = self._attr_element(enroll,"IMAGE",image)
 220         expid = self._attr_element(enroll,"EXPID",self._exp_id)
 221         index = self._attr_element(enroll,"INDEX",index)
 222         target = self._attr_element(enroll,"TARGET",target)
 223         return payload
 224
 225     def noop_function(self,target):
 226         """ Build a Noop Message
 227
 228         :param target: Hrn of the target node (ex : omf.plexus.wlab17)
 229         :type target: str
 230
 231         """
 232         payload = ET.Element("omf-message")
 233         noop = self._id_element(payload,"NOOP")
 234         sliceid = self._attr_element(noop,"SLICEID",self._slice_id)
 235         expid = self._attr_element(noop,"EXPID",self._exp_id)
 236         target = self._attr_element(noop,"TARGET",target)
 237         return payload
 238
 239     def newexp_function(self, experimentid, address):
 240         """ Build a NewExp Message
 241
 242         :param experimentid: Id of the new experiment
 243         :type experimentid: str
 244         :param address: Adress of the destination set of nodes
 245         :type address: str
 246
 247         """
 248         payload = ET.Element("omf-message")
 249         newexp = self._id_element(payload,"EXPERIMENT_NEW")
 250         experimentid = self._attr_element(newexp,"EXPERIMENT_ID",experimentid)
 251         sliceid = self._attr_element(newexp,"SLICEID",self._slice_id)
 252         expid = self._attr_element(newexp,"EXPID",self._exp_id)
 253         address = self._attr_element(newexp,"ADDRESS",address)
 254         return payload
 255