test support added
[nepi.git] / src / nepi / core / design.py
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3
4 """
5 Experiment design API
6 """
7
8 from nepi.core.attributes import AttributesMap, Attribute
9 from nepi.core.metadata import Metadata
10 from nepi.util import validation
11 from nepi.util.constants import AF_INET, AF_INET6
12 from nepi.util.guid import GuidGenerator
13 from nepi.util.graphical_info import GraphicalInfo
14 from nepi.util.parser._xml import XmlExperimentParser
15 import sys
16
17 class ConnectorType(object):
18     def __init__(self, testbed_id, factory_id, name, help, max = -1, min = 0):
19         super(ConnectorType, self).__init__()
20         if max == -1:
21             max = sys.maxint
22         elif max <= 0:
23                 raise RuntimeError(
24              "The maximum number of connections allowed need to be more than 0")
25         if min < 0:
26             raise RuntimeError(
27              "The minimum number of connections allowed needs to be at least 0")
28         # connector_type_id -- univoquely identifies a connector type 
29         # across testbeds
30         self._connector_type_id = (testbed_id.lower(), factory_id.lower(), 
31                 name.lower())
32         # name -- display name for the connector type
33         self._name = name
34         # help -- help text
35         self._help = help
36         # max -- maximum amount of connections that this type support, 
37         # -1 for no limit
38         self._max = max
39         # min -- minimum amount of connections required by this type of connector
40         self._min = min
41         # allowed_connections -- keys in the dictionary correspond to the 
42         # connector_type_id for possible connections. The value indicates if
43         # the connection is allowed accros different testbed instances
44         self._allowed_connections = dict()
45
46     @property
47     def connector_type_id(self):
48         return self._connector_type_id
49
50     @property
51     def help(self):
52         return self._help
53
54     @property
55     def name(self):
56         return self._name
57
58     @property
59     def max(self):
60         return self._max
61
62     @property
63     def min(self):
64         return self._min
65
66     def add_allowed_connection(self, testbed_id, factory_id, name, can_cross):
67         self._allowed_connections[(testbed_id.lower(), 
68             factory_id.lower(), name.lower())] = can_cross
69
70     def can_connect(self, connector_type_id, testbed_guid1, testbed_guid2):
71         if not connector_type_id in self._allowed_connections.keys():
72             return False
73         can_cross = self._allowed_connections[connector_type_id]
74         return can_cross or (testbed_guid1 == testbed_guid2)
75
76 class Connector(object):
77     """A Connector sepcifies the connection points in an Object"""
78     def __init__(self, box, connector_type):
79         super(Connector, self).__init__()
80         self._box = box
81         self._connector_type = connector_type
82         self._connections = list()
83
84     @property
85     def box(self):
86         return self._box
87
88     @property
89     def connector_type(self):
90         return self._connector_type
91
92     @property
93     def connections(self):
94         return self._connections
95
96     def is_full(self):
97         """Return True if the connector has the maximum number of connections
98         """
99         return len(self.connections) == self.connector_type.max
100
101     def is_complete(self):
102         """Return True if the connector has the minimum number of connections
103         """
104         return len(self.connections) >= self.connector_type.min
105
106     def is_connected(self, connector):
107         return connector in self._connections
108
109     def connect(self, connector):
110         if not self.can_connect(connector) or not connector.can_connect(self):
111             raise RuntimeError("Could not connect.")
112         self._connections.append(connector)
113         connector._connections.append(self)
114
115     def disconnect(self, connector):
116         if connector not in self._connections or\
117                 self not in connector._connections:
118                 raise RuntimeError("Could not disconnect.")
119         self._connections.remove(connector)
120         connector._connections.remove(self)
121
122     def can_connect(self, connector):
123         if self.is_full() or connector.is_full():
124             return False
125         if self.is_connected(connector):
126             return False
127         connector_type_id = connector.connector_type.connector_type_id
128         testbed_guid1 = self.box.testbed_guid
129         testbed_guid2 = connector.box.testbed_guid
130         return self.connector_type.can_connect(connector_type_id, 
131                 testbed_guid1, testbed_guid2)
132
133     def destroy(self):
134         for connector in self.connections:
135             self.disconnect(connector)
136         self._box = self._connectors = None
137
138 class Trace(AttributesMap):
139     def __init__(self, trace_id, help, enabled = False):
140         super(Trace, self).__init__()
141         self._trace_id = trace_id
142         self._help = help       
143         self.enabled = enabled
144     
145     @property
146     def trace_id(self):
147         return self._trace_id
148
149     @property
150     def help(self):
151         return self._help
152
153 class Address(AttributesMap):
154     def __init__(self, family):
155         super(Address, self).__init__()
156         self.add_attribute(name = "AutoConfigure", 
157                 help = "If set, this address will automatically be assigned", 
158                 type = Attribute.BOOL,
159                 value = False,
160                 validation_function = validation.is_bool)
161         self.add_attribute(name = "Family",
162                 help = "Address family type: AF_INET, AFT_INET6", 
163                 type = Attribute.INTEGER, 
164                 value = family,
165                 readonly = True)
166         address_validation = validation.is_ip4_address if family == AF_INET \
167                         else validation.is_ip6_address
168         self.add_attribute(name = "Address",
169                 help = "Address number", 
170                 type = Attribute.STRING,
171                 validation_function = address_validation)
172         prefix_range = (0, 32) if family == AF_INET else (0, 128)
173         self.add_attribute(name = "NetPrefix",
174                 help = "Network prefix for the address", 
175                 type = Attribute.INTEGER, 
176                 range = prefix_range,
177                 value = 24 if family == AF_INET else 64,
178                 validation_function = validation.is_integer)
179         if family == AF_INET:
180             self.add_attribute(name = "Broadcast",
181                     help = "Broadcast address", 
182                     type = Attribute.STRING,
183                     validation_function = validation.is_ip4_address)
184                 
185 class Route(AttributesMap):
186     def __init__(self, family):
187         super(Route, self).__init__()
188         self.add_attribute(name = "Family",
189                 help = "Address family type: AF_INET, AFT_INET6", 
190                 type = Attribute.INTEGER, 
191                 value = family,
192                 readonly = True)
193         address_validation = validation.is_ip4_address if family == AF_INET \
194                         else validation.is_ip6_address
195         self.add_attribute(name = "Destination", 
196                 help = "Network destintation",
197                 type = Attribute.STRING, 
198                 validation_function = address_validation)
199         prefix_range = (0, 32) if family == AF_INET else (0, 128)
200         self.add_attribute(name = "NetPrefix",
201                 help = "Network destination prefix", 
202                 type = Attribute.INTEGER, 
203                 prefix_range = prefix_range,
204                 validation_function = validation.is_integer)
205         self.add_attribute(name = "NextHop",
206                 help = "Address for the next hop", 
207                 type = Attribute.STRING,
208                 validation_function = address_validation)
209
210 class Box(AttributesMap):
211     def __init__(self, guid, factory, testbed_guid, container = None):
212         super(Box, self).__init__()
213         # guid -- global unique identifier
214         self._guid = guid
215         # factory_id -- factory identifier or name
216         self._factory_id = factory.factory_id
217         # testbed_guid -- parent testbed guid
218         self._testbed_guid = testbed_guid
219         # container -- boxes can be nested inside other 'container' boxes
220         self._container = container
221         # traces -- list of available traces for the box
222         self._traces = dict()
223         # connectors -- list of available connectors for the box
224         self._connectors = dict()
225         # factory_attributes -- factory attributes for box construction
226         self._factory_attributes = list()
227         # graphical_info -- GUI position information
228         self.graphical_info = GraphicalInfo(str(self._guid))
229
230         for connector_type in factory.connector_types:
231             connector = Connector(self, connector_type)
232             self._connectors[connector_type.name] = connector
233         for trace in factory.traces:
234             tr = Trace(trace.trace_id, trace.help, trace.enabled)
235             self._traces[trace.trace_id] = tr
236         for attr in factory.box_attributes:
237             self.add_attribute(attr.name, attr.help, attr.type, attr.value, 
238                     attr.range, attr.allowed, attr.readonly, attr.visible, 
239                     attr.validation_function)
240         for attr in factory.attributes:
241             self._factory_attributes.append(attr)
242
243     @property
244     def guid(self):
245         return self._guid
246
247     @property
248     def factory_id(self):
249         return self._factory_id
250
251     @property
252     def testbed_guid(self):
253         return self._testbed_guid
254
255     @property
256     def container(self):
257         return self._container
258
259     @property
260     def connectors(self):
261         return self._connectors.values()
262
263     @property
264     def traces(self):
265         return self._traces.values()
266
267     @property
268     def factory_attributes(self):
269         return self._factory_attributes
270
271     @property
272     def addresses(self):
273         return []
274
275     @property
276     def routes(self):
277         return []
278
279     def connector(self, name):
280         return self._connectors[name]
281
282     def trace(self, trace_id):
283         return self._traces[trace_id]
284
285     def destroy(self):
286         super(Box, self).destroy()
287         for c in self.connectors:
288             c.destroy()         
289         for t in self.traces:
290             t.destroy()
291         self._connectors = self._traces = self._factory_attributes = None
292
293 class AddressableBox(Box):
294     def __init__(self, guid, factory, testbed_guid, container = None):
295         super(AddressableBox, self).__init__(guid, factory, testbed_guid, 
296                 container)
297         self._family = factory.get_attribute_value("Family")
298         # maximum number of addresses this box can have
299         self._max_addresses = factory.get_attribute_value("MaxAddresses")
300         self._addresses = list()
301
302     @property
303     def addresses(self):
304         return self._addresses
305
306     @property
307     def max_addresses(self):
308         return self._max_addresses
309
310     def add_address(self):
311         if len(self._addresses) == self.max_addresses:
312             raise RuntimeError("Maximun number of addresses for this box reached.")
313         address = Address(family = self._family)
314         self._addresses.append(address)
315         return address
316
317     def delete_address(self, address):
318         self._addresses.remove(address)
319         del address
320
321     def destroy(self):
322         super(AddressableBox, self).destroy()
323         for address in self.addresses:
324             self.delete_address(address)
325         self._addresses = None
326
327 class RoutingTableBox(Box):
328     def __init__(self, guid, factory, container = None):
329         super(RoutingTableBox, self).__init__(guid, factory, container)
330         self._routes = list()
331
332     @property
333     def routes(self):
334         return self._routes
335
336     def add_route(self, family):
337         route = Route(family = family)
338         self._routes.append(route)
339         return route
340
341     def delete_route(self, route):
342         self._route.remove(route)
343         del route
344
345     def destroy(self):
346         super(RoutingTableBox, self).destroy()
347         for route in self.routes:
348             self.delete_route(route)
349         self._route = None
350
351 class Factory(AttributesMap):
352     def __init__(self, factory_id, allow_addresses = False, 
353             allow_routes = False, Help = None, category = None):
354         super(Factory, self).__init__()
355         self._factory_id = factory_id
356         self._allow_addresses = (allow_addresses == True)
357         self._allow_routes = (allow_routes == True)
358         self._help = help
359         self._category = category
360         self._connector_types = list()
361         self._traces = list()
362         self._box_attributes = list()
363
364     @property
365     def factory_id(self):
366         return self._factory_id
367
368     @property
369     def allow_addresses(self):
370         return self._allow_addresses
371
372     @property
373     def allow_routes(self):
374         return self._allow_routes
375
376     @property
377     def help(self):
378         return self._help
379
380     @property
381     def category(self):
382         return self._category
383
384     @property
385     def connector_types(self):
386         return self._connector_types
387
388     @property
389     def traces(self):
390         return self._traces
391
392     @property
393     def box_attributes(self):
394         return self._box_attributes
395
396     def add_connector_type(self, connector_type):
397         self._connector_types.append(connector_type)
398
399     def add_trace(self, trace_id, help, enabled = False):
400         trace = Trace(trace_id, help, enabled)
401         self._traces.append(trace)
402
403     def add_box_attribute(self, name, help, type, value = None, range = None,
404         allowed = None, readonly = False, visible = True, 
405         validation_function = None):
406         attribute = Attribute(name, help, type, value, range, allowed, readonly,
407                 visible, validation_function)
408         self._box_attributes.append(attribute)
409
410     def create(self, guid, testbed_description):
411         if self._allow_addresses:
412             return AddressableBox(guid, self, testbed_description.guid)
413         elif self._allow_routes:
414             return RoutingTableBox(guid, self, testbed_description.guid)
415         else:
416             return Box(guid, self, testbed_description.guid)
417
418     def destroy(self):
419         super(Factory, self).destroy()
420         self._connector_types = None
421
422 class FactoriesProvider(object):
423     def __init__(self, testbed_id, testbed_version):
424         super(FactoriesProvider, self).__init__()
425         self._testbed_id = testbed_id
426         self._testbed_version = testbed_version
427         self._factories = dict()
428
429         metadata = Metadata(testbed_id, testbed_version) 
430         for factory in metadata.build_design_factories():
431             self.add_factory(factory)
432
433     @property
434     def testbed_id(self):
435         return self._testbed_id
436
437     @property
438     def testbed_version(self):
439         return self._testbed_version
440
441     @property
442     def factories(self):
443         return self._factories.values()
444
445     def factory(self, factory_id):
446         return self._factories[factory_id]
447
448     def add_factory(self, factory):
449         self._factories[factory.factory_id] = factory
450
451     def remove_factory(self, factory_id):
452         del self._factories[factory_id]
453
454 class TestbedDescription(AttributesMap):
455     def __init__(self, guid_generator, provider):
456         super(TestbedDescription, self).__init__()
457         self._guid_generator = guid_generator
458         self._guid = guid_generator.next()
459         self._provider = provider
460         self._boxes = dict()
461         self.graphical_info = GraphicalInfo(str(self._guid))
462
463     @property
464     def guid(self):
465         return self._guid
466
467     @property
468     def provider(self):
469         return self._provider
470
471     @property
472     def boxes(self):
473         return self._boxes.values()
474
475     def box(self, guid):
476         return self._boxes[guid] if guid in self._boxes else None
477
478     def create(self, factory_id):
479         guid = self._guid_generator.next()
480         factory = self._provider.factory(factory_id)
481         box = factory.create(guid, self)
482         self._boxes[guid] = box
483         return box
484
485     def delete(self, guid):
486         box = self._boxes[guid]
487         del self._boxes[guid]
488         box.destroy()
489
490     def destroy(self):
491         for guid, box in self._boxes.iteritems():
492             box.destroy()
493         self._boxes = None
494
495 class ExperimentDescription(object):
496     def __init__(self, guid = 0):
497         self._guid_generator = GuidGenerator(guid)
498         self._testbed_descriptions = dict()
499
500     @property
501     def testbed_descriptions(self):
502         return self._testbed_descriptions.values()
503
504     def to_xml(self):
505         parser = XmlExperimentParser()
506         return parser.to_xml(self)
507
508     def from_xml(self, xml):
509         parser = XmlExperimentParser()
510         parser.from_xml(self, xml)
511
512     def testbed_description(self, guid):
513         return self._testbed_descriptions[guid] \
514                 if guid in self._testbed_descriptions else None
515
516     def box(self, guid):
517         for testbed_description in self._testbed_descriptions.values():
518             box = testbed_description.box(guid)
519             if box: return box
520         return None
521
522     def add_testbed_description(self, provider):
523         testbed_description = TestbedDescription(self._guid_generator, 
524                 provider)
525         guid = testbed_description.guid
526         self._testbed_descriptions[guid] = testbed_description
527         return testbed_description
528
529     def remove_testbed_description(self, testbed_description):
530         guid = testbed_description.guid
531         del self._testbed_descriptions[guid]
532
533     def destroy(self):
534         for testbed_description in self.testbed_descriptions:
535             testbed_description.destroy()
536
537 # TODO: When the experiment xml is passed to the controller to execute it
538 # NetReferences in the xml need to be solved
539 #
540 #targets = re.findall(r"%target:(.*?)%", command)
541 #for target in targets:
542 #   try:
543 #      (family, address, port) = resolve_netref(target, AF_INET, 
544 #          self.server.experiment )
545 #      command = command.replace("%%target:%s%%" % target, address.address)
546 #   except:
547 #       continue
548