doc/templates/template_rm.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 # Authors: Alina Quereilhac <alina.quereilhac@inria.fr>
  19 #          Julien Tribino <julien.tribino@inria.fr>
  20
  21
  22 from nepi.execution.attribute import Attribute, Flags, Types
  23 from nepi.execution.resource import ResourceManager, clsinit_copy, \
  24         ResourceState
  25
  26 #clsinit_copy is used to inherit attributes from the parent class
  27 @clsinit_copy
  28 class RMClass(ResourceManager):
  29     # Name that will be used in the NEPI script to identify the resource type
  30     _rtype = "platform::RMType"
  31     # User friendly description of the RM
  32     _help = "Describes what this RM does"
  33     # Name of the platform this RM belongs to
  34     _platform = "platform"
  35     # list of valid connection for this RM
  36     _authorized_connections = ["platform::AnotherRMType1" , "platform::AnotherRMType2"]
  37
  38     @classmethod
  39     def _register_attributes(cls):
  40         """
  41         This method is used to register all the attribute of this RM. Check the
  42         file src/execution/attribute.py to see all the fields of this class
  43         """
  44
  45         attribute1 = Attribute("nameOfAttribute1", "Description of Attribute 1",
  46                 flags = Flags.Design)
  47
  48         attribute2 = Attribute("nameOfAttribute2", "Description of Attribute 2",
  49                 flags = Flags.Design)
  50
  51         cls._register_attribute(attribute1)
  52         cls._register_attribute(attribute2)
  53
  54     def __init__(self, ec, guid):
  55         """
  56         Declares and initializes variables of the RM that are not Attributes.
  57         Attributes represent resource configuration exposed to the user,
  58         other class variables can declared here for RM internal use.
  59         """
  60
  61         super(RMClass, self).__init__(ec, guid)
  62
  63     def log_message(self, msg):
  64         """
  65         Prints a log message adding a identification prefix.
  66
  67         The log message for the RMClass can be redefined here.
  68         It can be used to add information about related resources such as
  69         the hostname of the node RM associated to an application RM.
  70         """
  71
  72         return " %s guid %d - %s " % (self._rtype, self.guid, msg)
  73
  74     def valid_connection(self, guid):
  75         """
  76         Checks whether the RMClass instance can be connected to the
  77         other RM corresponding to the given guid.
  78         """
  79
  80         rm = self.ec.get_resource(guid)
  81
  82         if rm.get_rtype() not in self._authorized_connections:
  83             msg = ("Connection between %s %s and %s %s refused: "
  84                     "An Application can be connected only to a Node" ) % \
  85                 (self.get_rtype(), self._guid, rm.get_rtype(), guid)
  86
  87             return False
  88
  89         elif len(self.connections) != 0 :
  90             msg = ("Connection between %s %s and %s %s refused: "
  91                     "This Application is already connected" ) % \
  92                 (self.get_rtype(), self._guid, rm.get_rtype(), guid)
  93             self.debug(msg)
  94
  95             return False
  96
  97         return True
  98
  99     def do_discover(self):
 100         """
 101         Perform actions required to discover resources matching some criteria
 102         specified by the user through the configuration of Attributes.
 103         """
 104
 105         super(RMClass, self).do_discover()
 106
 107     def do_reserve(self):
 108         """
 109         Perform actions required to reserve resources matching some criteria
 110         specified by the user through the configuration of Attributes.
 111         """
 112
 113         super(RMClass, self).do_reserve()
 114
 115     def do_provision(self):
 116         """
 117         Perform actions required to provision a resource in the platform,
 118         matching the criteria specified by the user.
 119         """
 120
 121         super(RMClass, self).do_provision()
 122
 123     def do_deploy(self):
 124         """
 125         Perform actions required to deploy a resource in the platform.
 126
 127         Deploying a resource most frequently involves invoking the
 128         do_discover and do_provision methods. In order to deploy a
 129         resource it might be necessary wait until other associated
 130         resource is in a given state, as in the following example:
 131
 132         other_rm_list = self.get_connected(OtherRMClass.get_rtype())
 133         other_rm = other_rm_list[0]
 134
 135         if other_rm.state < ResourceState.READY:
 136             self.ec.schedule(self.reschedule_delay, self.deploy)
 137
 138         elif other_rm.state == ResourceState.FAILED:
 139             msg = "Failed to deploy resource"
 140             self.error(msg)
 141             raise RuntimeError(msg)
 142
 143         else:
 144             self.do_discover()
 145             self.do_provision()
 146
 147             super(RMClass, self).do_deploy()
 148
 149         """
 150
 151         super(RMClass, self).do_deploy()
 152
 153     def do_start(self):
 154         """
 155         Perform actions required to start a resource in the platform.
 156         """
 157
 158         super(RMClass, self).do_start()
 159
 160     def do_stop(self):
 161         """
 162         Perform actions required to stop a resource in the platform.
 163         """
 164
 165         super(RMClass, self).do_stop()
 166
 167     def do_release(self):
 168         """
 169         Perform actions required to release a resource in the platform.
 170         """
 171
 172         super(RMClass, self).do_release()
 173
 174     @property
 175     def state(self):
 176         """
 177         Returns the state of the RM.
 178
 179         The state method should never raise an exception, instead if an
 180         error occurs it should log the error and invoke the self.do_fail
 181         method as follows:
 182
 183         self.error(msg, out, err)
 184         self.do_fail()
 185         """
 186
 187         return super(RMClass, self).state
 188
 189