src/nepi/core/execute.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from nepi.core.attributes import Attribute, AttributesMap
   5 from nepi.util import proxy, validation
   6 from nepi.util.constants import STATUS_FINISHED
   7 from nepi.util.parser._xml import XmlExperimentParser
   8 import sys
   9
  10 class ConnectorType(object):
  11     def __init__(self, testbed_id, factory_id, name, max = -1, min = 0):
  12         super(ConnectorType, self).__init__()
  13         if max == -1:
  14             max = sys.maxint
  15         elif max <= 0:
  16                 raise RuntimeError(
  17              "The maximum number of connections allowed need to be more than 0")
  18         if min < 0:
  19             raise RuntimeError(
  20              "The minimum number of connections allowed needs to be at least 0")
  21         # connector_type_id -- univoquely identifies a connector type
  22         # across testbeds
  23         self._connector_type_id = (testbed_id.lower(), factory_id.lower(),
  24                 name.lower())
  25         # name -- display name for the connector type
  26         self._name = name
  27         # max -- maximum amount of connections that this type support,
  28         # -1 for no limit
  29         self._max = max
  30         # min -- minimum amount of connections required by this type of connector
  31         self._min = min
  32         # from_connections -- connections where the other connector is the "From"
  33         # to_connections -- connections where the other connector is the "To"
  34         # keys in the dictionary correspond to the
  35         # connector_type_id for possible connections. The value is a tuple:
  36         # (can_cross, connect)
  37         # can_cross: indicates if the connection is allowed accros different
  38         #    testbed instances
  39         # code: is the connection function to be invoked when the elements
  40         #    are connected
  41         self._from_connections = dict()
  42         self._to_connections = dict()
  43
  44     @property
  45     def connector_type_id(self):
  46         return self._connector_type_id
  47
  48     @property
  49     def name(self):
  50         return self._name
  51
  52     @property
  53     def max(self):
  54         return self._max
  55
  56     @property
  57     def min(self):
  58         return self._min
  59
  60     def add_from_connection(self, testbed_id, factory_id, name, can_cross, code):
  61         self._from_connections[(testbed_id.lower(), factory_id.lower(),
  62             name.lower())] = (can_cross, code)
  63
  64     def add_to_connection(self, testbed_id, factory_id, name, can_cross, code):
  65         self._to_connections[(testbed_id.lower(), factory_id.lower(),
  66             name.lower())] = (can_cross, code)
  67
  68     def can_connect(self, testbed_id, factory_id, name, count,
  69             must_cross = False):
  70         connector_type_id = (testbed_id.lower(), factory_id.lower(),
  71             name.lower())
  72         if connector_type_id in self._from_connections:
  73             (can_cross, code) = self._from_connections[connector_type_id]
  74         elif connector_type_id in self._to_connections:
  75             (can_cross, code) = self._to_connections[connector_type_id]
  76         else:
  77             return False
  78         return not must_cross or can_cross
  79
  80     def code_to_connect(self, testbed_id, factory_id, name):
  81         connector_type_id = (testbed_id.lower(), factory_id.lower(),
  82             name.lower())
  83         if not connector_type_id in self._to_connections.keys():
  84             return False
  85         (can_cross, code) = self._to_connections[connector_type_id]
  86         return code
  87
  88 # TODO: create_function, start_function, stop_function, status_function
  89 # need a definition!
  90 class Factory(AttributesMap):
  91     def __init__(self, factory_id, create_function, start_function,
  92             stop_function, status_function, configure_function,
  93             allow_addresses = False, allow_routes = False):
  94         super(Factory, self).__init__()
  95         self._factory_id = factory_id
  96         self._allow_addresses = (allow_addresses == True)
  97         self._allow_routes = (allow_routes == True)
  98         self._create_function = create_function
  99         self._start_function = start_function
 100         self._stop_function = stop_function
 101         self._status_function = status_function
 102         self._configure_function = configure_function
 103         self._connector_types = dict()
 104         self._traces = list()
 105         self._box_attributes = AttributesMap()
 106
 107     @property
 108     def factory_id(self):
 109         return self._factory_id
 110
 111     @property
 112     def allow_addresses(self):
 113         return self._allow_addresses
 114
 115     @property
 116     def allow_routes(self):
 117         return self._allow_routes
 118
 119     @property
 120     def box_attributes(self):
 121         return self._box_attributes
 122
 123     @property
 124     def create_function(self):
 125         return self._create_function
 126
 127     @property
 128     def start_function(self):
 129         return self._start_function
 130
 131     @property
 132     def stop_function(self):
 133         return self._stop_function
 134
 135     @property
 136     def status_function(self):
 137         return self._status_function
 138
 139     @property
 140     def configure_function(self):
 141         return self._configure_function
 142
 143     @property
 144     def traces(self):
 145         return self._traces
 146
 147     def connector_type(self, name):
 148         return self._connector_types[name]
 149
 150     def add_connector_type(self, connector_type):
 151         self._connector_types[connector_type.name] = connector_type
 152
 153     def add_trace(self, trace_id):
 154         self._traces.append(trace_id)
 155
 156     def add_box_attribute(self, name, help, type, value = None, range = None,
 157         allowed = None, flags = Attribute.NoFlags, validation_function = None):
 158         self._box_attributes.add_attribute(name, help, type, value, range,
 159                 allowed, flags, validation_function)
 160
 161 class TestbedInstance(object):
 162     def __init__(self, testbed_id, testbed_version):
 163         self._testbed_id = testbed_id
 164         self._testbed_version = testbed_version
 165
 166     @property
 167     def guids(self):
 168         raise NotImplementedError
 169
 170     def configure(self, name, value):
 171         """Set a configuartion attribute for the testbed instance"""
 172         raise NotImplementedError
 173
 174     def create(self, guid, factory_id):
 175         """Instructs creation of element """
 176         raise NotImplementedError
 177
 178     def create_set(self, guid, name, value):
 179         """Instructs setting an initial attribute on an element"""
 180         raise NotImplementedError
 181
 182     def factory_set(self, guid, name, value):
 183         """Instructs setting an attribute on a factory"""
 184         raise NotImplementedError
 185
 186     def connect(self, guid1, connector_type_name1, guid2,
 187             connector_type_name2):
 188         raise NotImplementedError
 189
 190     def cross_connect(self, guid, connector_type_name, cross_guid,
 191             cross_testbed_id, cross_factory_id, cross_connector_type_name):
 192         raise NotImplementedError
 193
 194     def add_trace(self, guid, trace_id):
 195         raise NotImplementedError
 196
 197     def add_address(self, guid, address, netprefix, broadcast):
 198         raise NotImplementedError
 199
 200     def add_route(self, guid, destination, netprefix, nexthop):
 201         raise NotImplementedError
 202
 203     def do_setup(self):
 204         """After do_setup the testbed initial configuration is done"""
 205         raise NotImplementedError
 206
 207     def do_create(self):
 208         """After do_create all instructed elements are created and
 209         attributes setted"""
 210         raise NotImplementedError
 211
 212     def do_connect(self):
 213         """After do_connect all internal connections between testbed elements
 214         are done"""
 215         raise NotImplementedError
 216
 217     def do_configure(self):
 218         """After do_configure elements are configured"""
 219         raise NotImplementedError
 220
 221     def do_cross_connect(self):
 222         """After do_cross_connect all external connections between different testbed
 223         elements are done"""
 224         raise NotImplementedError
 225
 226     def start(self):
 227         raise NotImplementedError
 228
 229     def stop(self):
 230         raise NotImplementedError
 231
 232     def set(self, time, guid, name, value):
 233         raise NotImplementedError
 234
 235     def get(self, time, guid, name):
 236         raise NotImplementedError
 237
 238     def action(self, time, guid, action):
 239         raise NotImplementedError
 240
 241     def status(self, guid):
 242         raise NotImplementedError
 243
 244     def trace(self, guid, trace_id):
 245         raise NotImplementedError
 246
 247     def shutdown(self):
 248         raise NotImplementedError
 249
 250 class ExperimentController(object):
 251     def __init__(self, experiment_xml):
 252         self._experiment_xml = experiment_xml
 253         self._testbeds = dict()
 254         self._access_config = dict()
 255
 256     @property
 257     def experiment_xml(self):
 258         return self._experiment_xml
 259
 260     def set_access_configuration(self, testbed_guid, access_config):
 261         self._access_config[testbed_guid] = access_config
 262
 263     def trace(self, testbed_guid, guid, trace_id):
 264         return self._testbeds[testbed_guid].trace(guid, trace_id)
 265
 266     def start(self):
 267         self._create_testbed_instances()
 268         for testbed in self._testbeds.values():
 269             testbed.do_setup()
 270         for testbed in self._testbeds.values():
 271             testbed.do_create()
 272             testbed.do_connect()
 273             testbed.do_configure()
 274         for testbed in self._testbeds.values():
 275             testbed.do_cross_connect()
 276         for testbed in self._testbeds.values():
 277             testbed.start()
 278
 279     def stop(self):
 280        for testbed in self._testbeds.values():
 281            testbed.stop()
 282
 283     def is_finished(self, guid):
 284         for testbed in self._testbeds.values():
 285             for guid_ in testbed.guids:
 286                 if guid_ == guid:
 287                     return testbed.status(guid) == STATUS_FINISHED
 288         raise RuntimeError("No element exists with guid %d" % guid)
 289
 290     def shutdown(self):
 291        for testbed in self._testbeds.values():
 292            testbed.shutdown()
 293
 294     def _create_testbed_instances(self):
 295         parser = XmlExperimentParser()
 296         data = parser.from_xml_to_data(self._experiment_xml)
 297         element_guids = list()
 298         for guid in data.guids:
 299             if data.is_testbed_data(guid):
 300                 (testbed_id, testbed_version) = data.get_testbed_data(guid)
 301                 access_config = None if guid not in self._access_config else\
 302                         self._access_config[guid]
 303                 testbed = proxy.create_testbed_instance(testbed_id,
 304                         testbed_version, access_config)
 305                 for (name, value) in data.get_attribute_data(guid):
 306                     testbed.configure(name, value)
 307                 self._testbeds[guid] = testbed
 308             else:
 309                 element_guids.append(guid)
 310         self._program_testbed_instances(element_guids, data)
 311
 312     def _program_testbed_instances(self, element_guids, data):
 313         for guid in element_guids:
 314             (testbed_guid, factory_id) = data.get_box_data(guid)
 315             testbed = self._testbeds[testbed_guid]
 316             testbed.create(guid, factory_id)
 317             for (name, value) in data.get_attribute_data(guid):
 318                 testbed.create_set(guid, name, value)
 319
 320         for guid in element_guids:
 321             (testbed_guid, factory_id) = data.get_box_data(guid)
 322             testbed = self._testbeds[testbed_guid]
 323             for (connector_type_name, other_guid, other_connector_type_name) \
 324                     in data.get_connection_data(guid):
 325                 (testbed_guid, factory_id) = data.get_box_data(guid)
 326                 (other_testbed_guid, other_factory_id) = data.get_box_data(
 327                         other_guid)
 328                 if testbed_guid == other_testbed_guid:
 329                     testbed.connect(guid, connector_type_name, other_guid,
 330                         other_connector_type_name)
 331                 else:
 332                     testbed.cross_connect(guid, connector_type_name, other_guid,
 333                         other_testbed_id, other_factory_id, other_connector_type_name)
 334             for trace_id in data.get_trace_data(guid):
 335                 testbed.add_trace(guid, trace_id)
 336             for (autoconf, address, netprefix, broadcast) in \
 337                     data.get_address_data(guid):
 338                 if address != None:
 339                     testbed.add_address(guid, address, netprefix, broadcast)
 340             for (destination, netprefix, nexthop) in data.get_route_data(guid):
 341                 testbed.add_route(guid, destination, netprefix, nexthop)
 342