source: fedd/federation/topdl.py @ cedf721

axis_examplecompt_changesinfo-ops
Last change on this file since cedf721 was 9252414, checked in by Ted Faber <faber@…>, 14 years ago

Add helper for access controlers to extract topology.

Fixes #5

  • Property mode set to 100644
File size: 28.6 KB
Line 
1#!/usr/local/bin/python
2
3import re
4import xml.parsers.expat
5from xml.sax.saxutils import escape
6from base64 import b64encode
7from string import join
8
9from fedid import fedid as fedid_class
10
11class base:
12    @staticmethod
13    def init_class(c, arg):
14        if isinstance(arg, dict):
15            try:
16                return c(**arg)
17            except:
18                print "%s" % arg
19                raise
20        elif isinstance(arg, c):
21            return arg
22        else:
23            return None
24
25    @staticmethod
26    def make_list(a):
27        if isinstance(a, basestring) or isinstance(a, dict): return [ a ]
28        elif getattr(a, '__iter__', None): return a
29        else: return [ a ]
30
31    @staticmethod
32    def init_string(s):
33        """
34        Force a string coercion for everything but a None.
35        """
36        if s is not None: return "%s" % s
37        else: return None
38
39    def remove_attribute(self, key):
40        to_del = None
41        attrs = getattr(self, 'attribute', [])
42        for i, a in enumerate(attrs):
43            if a.attribute == key:
44                to_del = i
45                break
46       
47        if to_del: del attrs[i]
48
49    def get_attribute(self, key):
50        rv = None
51        attrs = getattr(self, 'attribute', None)
52        if attrs:
53            for a in attrs:
54                if a.attribute == key:
55                    rv = a.value
56                    break
57        return rv
58
59    def set_attribute(self, key, value):
60        attrs = getattr(self, 'attribute', None)
61        if attrs is None:
62            return
63        for a in attrs:
64            if a.attribute == key: 
65                a.value = value
66                break
67        else:
68            attrs.append(Attribute(key, value))
69
70class ConsistencyError(RuntimeError): pass
71class NamespaceError(RuntimeError): pass
72
73class Attribute(base):
74    def __init__(self, attribute, value):
75        self.attribute = self.init_string(attribute)
76        self.value = self.init_string(value)
77
78    def clone(self):
79        return Attribute(attribute=self.attribute, value=self.value)
80
81    def to_dict(self):
82        return { 'attribute': self.attribute, 'value': self.value }
83    def to_xml(self):
84        return "<attribute>%s</attribute><value>%s</value>" % \
85                (escape(self.attribute), escape(self.value))
86
87class Capacity(base):
88    def __init__(self, rate, kind):
89        self.rate = float(rate)
90        self.kind = self.init_string(kind)
91
92    def clone(self):
93        return Capacity(rate=self.rate, kind=self.kind)
94
95    def to_dict(self):
96        return { 'rate': float(self.rate), 'kind': self.kind }
97
98    def to_xml(self):
99        return "<rate>%f</rate><kind>%s</kind>" % (self.rate, self.kind)
100
101class Latency(base):
102    def __init__(self, time, kind):
103        self.time = float(time)
104        self.kind = self.init_string(kind)
105
106    def clone(self):
107        return Latency(time=self.time, kind=self.kind)
108
109    def to_dict(self):
110        return { 'time': float(self.time), 'kind': self.kind }
111
112    def to_xml(self):
113        return "<time>%f</time><kind>%s</kind>" % (self.time, self.kind)
114
115class Substrate(base):
116    def __init__(self, name, capacity=None, latency=None, attribute=[]):
117        self.name = self.init_string(name)
118        self.capacity = self.init_class(Capacity, capacity)
119        self.latency = self.init_class(Latency, latency)
120        self.attribute = [ self.init_class(Attribute, a) \
121                for a in self.make_list(attribute) ]
122        self.interfaces = [ ]
123
124    def clone(self):
125        if self.capacity: c = self.capacity.clone()
126        else: c = None
127
128        if self.latency: l = self.latency.clone()
129        else: l = None
130
131        return Substrate(name=self.name,
132                capacity=c,
133                latency=l,
134                attribute = [a.clone() for a in self.attribute])
135
136    def to_dict(self):
137        rv = { 'name': self.name }
138        if self.capacity:
139            rv['capacity'] = self.capacity.to_dict()
140        if self.latency:
141            rv['latency'] = self.latency.to_dict()
142        if self.attribute:
143            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
144        return rv
145
146    def to_xml(self):
147        rv = "<name>%s</name>" % escape(self.name)
148        if self.capacity is not None:
149            rv += "<capacity>%s</capacity>" % self.capacity.to_xml()
150        if self.latency is not None:
151            rv += "<latency>%s</latency>" % self.latency.to_xml()
152       
153        if self.attribute:
154            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
155                    for a in self.attribute], "")
156        return rv
157
158class CPU(base):
159    def __init__(self, type, attribute=[]):
160        self.type = self.init_string(type)
161        self.attribute = [ self.init_class(Attribute, a) for a in \
162                self.make_list(attribute) ]
163
164    def clone(self):
165        return CPU(type=self.type,
166                attribute = [a.clone() for a in self.attribute])
167
168    def to_dict(self):
169        rv = { 'type': self.type}
170        if self.attribute:
171            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
172        return rv
173
174    def to_xml(self):
175        rv = "<type>%s</type>" % escape(self.type)
176        if self.attribute:
177            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
178                    for a in self.attribute], "")
179        return rv
180
181
182class Storage(base):
183    def __init__(self, amount, persistence, attribute=[]):
184        self.amount = float(amount)
185        self.presistence = self.init_string(persistence)
186        self.attribute = [ self.init_class(Attribute, a) \
187                for a in self.make_list(attribute) ]
188
189    def clone(self):
190        return Storage(amount=self.amount, persistence=self.persistence, 
191                attribute = [a.clone() for a in self.attribute])
192
193    def to_dict(self):
194        rv = { 'amount': float(self.amount), 'persistence': self.persistence }
195        if self.attribute:
196            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
197        return rv
198
199    def to_xml(self):
200        rv = "<amount>%f</amount><persistence>%s</persistence>" % \
201                (self.amount, escape(self.persistence))
202        if self.attribute:
203            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
204                    for a in self.attribute], "")
205        return rv
206
207
208class OperatingSystem(base):
209    def __init__(self, name=None, version=None, distribution=None,
210            distributionversion=None, attribute=[]):
211        self.name = self.init_string(name)
212        self.version = self.init_string(version)
213        self.distribution = self.init_string(distribution)
214        self.distributionversion = self.init_string(distributionversion)
215        self.attribute = [ self.init_class(Attribute, a) \
216                for a in self.make_list(attribute) ]
217
218    def clone(self):
219        return OperatingSystem(name=self.name,
220                version=self.version,
221                distribution=self.distribution,
222                distributionversion=self.distributionversion,
223                attribute = [ a.clone() for a in self.attribute])
224
225    def to_dict(self):
226        rv = { }
227        if self.name: rv['name'] = self.name
228        if self.version: rv['version'] = self.version
229        if self.distribution: rv['distribution'] = self.distribution
230        if self.distributionversion: 
231            rv['distributionversion'] = self.distributionversion
232        if self.attribute:
233            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
234        return rv
235
236    def to_xml(self):
237        rv = ""
238        if self.name: rv += "<name>%s</name>" % escape(self.name)
239        if self.version: rv += "<version>%s</version>" % escape(self.version)
240        if self.distribution: 
241            rv += "<distribution>%s</distribution>" % escape(self.distribution)
242        if self.distributionversion: 
243            rv += "<distributionversion>%s</distributionversion>" % \
244                    escape(self.distributionversion)
245       
246        if self.attribute:
247            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
248                    for a in self.attribute], "")
249        return rv
250
251
252class Software(base):
253    def __init__(self, location, install=None, attribute=[]):
254        self.location = self.init_string(location)
255        self.install = self.init_string(install)
256        self.attribute = [ self.init_class(Attribute, a)\
257                for a in self.make_list(attribute) ]
258
259    def clone(self):
260        return Software(location=self.location, install=self.install, 
261                attribute=[a.clone() for a in self.attribute])
262
263    def to_dict(self):
264        rv = { 'location': self.location }
265        if self.install: rv['install'] = self.install
266        if self.attribute:
267            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
268        return rv
269
270    def to_xml(self):
271        rv = "<location>%s</location>" % escape(self.location)
272        if self.install: rv += "<install>%s</install>" % self.install
273        if self.attribute:
274            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
275                    for a in self.attribute], "")
276        return rv
277
278
279class Interface(base):
280    def __init__(self, substrate, name=None, capacity=None, latency=None,
281            attribute=[], element=None):
282        self.name = self.init_string(name)
283
284        self.substrate = self.make_list(substrate)
285        self.capacity = self.init_class(Capacity, capacity)
286        self.latency = self.init_class(Latency, latency)
287        self.attribute = [ self.init_class(Attribute, a) \
288                for a in self.make_list(attribute) ]
289        self.element = element
290        self.subs = [ ]
291
292    def clone(self):
293        if self.capacity: c = self.capacity.clone()
294        else: c = None
295
296        if self.latency: l = self.latency.clone()
297        else: l = None
298
299        return Interface(substrate=[s for s in self.substrate], name=self.name,
300                capacity=c, latency=l,
301                attribute = [ a.clone() for a in self.attribute])
302
303    def to_dict(self):
304        rv = { 'substrate': self.substrate, 'name': self.name }
305        if self.capacity:
306            rv['capacity'] = self.capacity.to_dict()
307        if self.latency:
308            rv['latency'] = self.latency.to_dict()
309        if self.attribute:
310            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
311        return rv
312
313    def to_xml(self):
314        rv = join(["<substrate>%s</substrate>" % escape(s) \
315                for s in self.substrate], "")
316        rv += "<name>%s</name>" % self.name
317        if self.capacity:
318            rv += "<capacity>%s</capacity>" % self.capacity.to_xml()
319        if self.latency:
320            rv += "<latency>%s</latency>" % self.latency.to_xml()
321        if self.attribute:
322            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
323                    for a in self.attribute], "")
324        return rv
325
326
327class ID(base):
328    def __init__(self, fedid=None, uuid=None, uri=None, localname=None,
329            kerberosUsername=None):
330        self.fedid=fedid_class(hexstr="%s" % fedid)
331        self.uuid = self.init_string(uuid)
332        self.uri = self.init_string(uri)
333        self.localname =self.init_string( localname)
334        self.kerberosUsername = self.init_string(kerberosUsername)
335
336    def clone(self):
337        return ID(self.fedid, self.uuid, self.uri, self.localname,
338                self.kerberosUsername)
339
340    def to_dict(self):
341        rv = { }
342        if self.fedid: rv['fedid'] = self.fedid
343        if self.uuid: rv['uuid'] = self.uuid
344        if self.uri: rv['uri'] = self.uri
345        if self.localname: rv['localname'] = self.localname
346        if self.kerberosUsername: rv['kerberosUsername'] = self.kerberosUsername
347        return rv
348
349    def to_xml(self):
350        if self.uuid: rv = "<uuid>%s</uuid>" % b64encode(self.uuid)
351        elif self.fedid: rv = "<fedid>%s</fedid>" % b64encode(self.fedid)
352        elif self.uri: rv = "<uri>%s</uri>" % escape(self.uri)
353        elif self.localname: 
354            rv = "<localname>%s</localname>" % escape(self.localname)
355        elif self.kerberosUsername: 
356            rv = "<kerberosUsername>%s</kerberosUsername>" % \
357                    escape(self.kerberosUsername)
358        return rv
359
360class Computer(base):
361    def __init__(self, name, cpu=[], os=[], software=[], storage=[],
362            interface=[], attribute=[]):
363        def assign_element(i):
364            i.element = self
365
366        self.name = self.init_string(name)
367        self.cpu = [ self.init_class(CPU, c)  for c in self.make_list(cpu) ]
368        self.os = [ self.init_class(OperatingSystem, c) \
369                for c in self.make_list(os) ]
370        self.software = [ self.init_class(Software, c) \
371                for c in self.make_list(software) ]
372        self.storage = [ self.init_class(Storage, c) \
373                for c in self.make_list(storage) ]
374        self.interface = [ self.init_class(Interface, c) \
375                for c in self.make_list(interface) ]
376        self.attribute = [ self.init_class(Attribute, a) \
377                for a in self.make_list(attribute) ]
378        map(assign_element, self.interface)
379
380    def clone(self):
381        # Copy the list of names
382        return Computer(name=self.name,
383                cpu=[x.clone() for x in self.cpu],
384                os=[x.clone() for x in self.os],
385                software=[x.clone() for x in self.software],
386                storage=[x.clone() for x in self.storage],
387                interface=[x.clone() for x in self.interface],
388                attribute=[x.clone() for x in self.attribute])
389
390    def to_dict(self):
391        rv = { }
392        if self.name:
393            rv['name'] = self.name
394        if self.cpu:
395            rv['cpu'] = [ c.to_dict() for  c in self.cpu ]
396        if self.os:
397            rv['os'] = [ o.to_dict() for o in self.os ]
398        if self.software:
399            rv['software'] = [ s.to_dict() for s in self.software ]
400        if self.storage:
401            rv['storage'] = [ s.to_dict for s in self.storage ]
402        if self.interface:
403            rv['interface'] = [ i.to_dict() for i in self.interface ]
404        if self.attribute:
405            rv['attribute'] = [ i.to_dict() for i in self.attribute ]
406        return { 'computer': rv }
407
408    def to_xml(self):
409        rv = "<name>%s</name>" % escape(self.name)
410        if self.cpu:
411            rv += join(["<cpu>%s</cpu>" % c.to_xml() for c in self.cpu], "")
412        if self.os:
413            rv += join(["<os>%s</os>" % o.to_xml() for o in self.os], "")
414        if self.software:
415            rv += join(["<software>%s</software>" % s.to_xml() \
416                    for s in self.software], "")
417        if self.storage:
418            rv += join(["<stroage>%s</stroage>" % s.to_xml() \
419                    for s in self.stroage], "")
420        if self.interface:
421            rv += join(["<interface>%s</interface>" % i.to_xml() 
422                for i in self.interface], "")
423        if self.attribute:
424            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
425                    for a in self.attribute], "")
426        return "<computer>%s</computer>" % rv
427
428
429
430class Testbed(base):
431    def __init__(self, uri, type, interface=[], attribute=[]):
432        self.uri = self.init_string(uri)
433        self.type = self.init_string(type)
434        self.interface = [ self.init_class(Interface, c) \
435                for c in self.make_list(interface) ]
436        self.attribute = [ self.init_class(Attribute, c) \
437                for c in self.make_list(attribute) ]
438
439    def clone(self):
440        return Testbed(self.uri, self.type,
441                interface=[i.clone() for i in self.interface],
442                attribute=[a.cone() for a in self.attribute])
443
444    def to_dict(self):
445        rv = { }
446        if self.uri: rv['uri'] = self.uri
447        if self.type: rv['type'] = self.type
448        if self.interface:
449            rv['interface'] = [ i.to_dict() for i in self.interface]
450        if self.attribute:
451            rv['attribute'] = [ a.to_dict() for a in self.attribute]
452        return { 'testbed': rv }
453
454    def to_xml(self):
455        rv = "<uri>%s</uri><type>%s</type>" % \
456                (escape(self.uri), escape(self.type))
457        if self.interface:
458            rv += join(["<interface>%s</interface>" % i.to_xml() 
459                for i in self.interface], "")
460        if self.attribute:
461            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
462                    for a in self.attribute], "")
463        return "<testbed>%s</testbed>" % rv
464
465       
466
467class Segment(base):
468    def __init__(self, id, type, uri, interface=[], attribute=[]):
469        self.id = self.init_class(ID, id)
470        self.type = self.init_string(type)
471        self.uri = self.init_string(uri)
472        self.interface = [ self.init_class(Interface, c) \
473                for c in self.make_list(interface) ]
474        self.attribute = [ self.init_class(Attribute, c) \
475                for c in self.make_list(attribute) ]
476
477    def clone(self):
478        return Segment(self.id.clone(), self.type, self.uri, 
479                interface=[i.clone() for i in self.interface], 
480                attribute=[a.clone() for a in self.attribute])
481
482    def to_dict(self):
483        rv = { }
484        if self.id: rv['id'] = self.id.to_dict()
485        if self.type: rv['type'] = self.type
486        if self.uri: rv['uri'] = self.uri
487        if self.interface:
488            rv['interface'] = [ i.to_dict() for i in self.interface ]
489        if self.attribute:
490            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
491        return { 'segment': rv }
492
493    def to_xml(self):
494        rv = "<id>%s</id><uri>%s</uri><type>%s</type>" % \
495                (id.to_xml(), escape(self.uri), escape(self.type))
496        if self.interface:
497            rv += join(["<interface>%s</interface>" % i.to_xml() 
498                for i in self.interface], "")
499        if self.attribute:
500            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
501                    for a in self.attribute], "")
502        return "<segment>%s</segment>" % rv
503
504class Other(base):
505    def __init__(self, interface=[], attribute=[]):
506        self.interface = [ self.init_class(Interface, c) \
507                for c in self.make_list(interface) ]
508        self.attribute = [ self.init_class(Attribute, c) \
509                for c in self.make_list(attribute) ]
510
511    def clone(self):
512        return Other(interface=[i.clone() for i in self.interface], 
513                attribute=[a.clone() for a in attribute])
514
515    def to_dict(self):
516        rv = {}
517        if self.interface:
518            rv['interface'] = [ i.to_dict() for i in self.interface ]
519        if self.attribute:
520            rv['attribute'] = [ a.to_dict() for a in self.attribute ]
521        return {'other': rv }
522
523    def to_xml(self):
524        rv = ""
525        if self.interface:
526            rv += join(["<interface>%s</interface>" % i.to_xml() 
527                for i in self.interface], "")
528        if self.attribute:
529            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
530                    for a in self.attribute], "")
531        return "<other>%s</other>" % rv
532
533class Topology(base):
534    version = "1.0"
535    @staticmethod
536    def init_element(e):
537        """
538        e should be of the form { typename: args } where args is a dict full of
539        the right parameters to initialize the element.  e should have only one
540        key, but we walk e's keys in an arbitrary order and instantiate the
541        first key we know how to.
542        """
543        classmap = {
544                'computer': Computer,
545                'testbed': Testbed,
546                'segment': Segment,
547                'other': Other,
548            }
549
550        if isinstance(e, dict):
551            for k in e.keys():
552                cl = classmap.get(k, None)
553                if cl: return cl(**e[k])
554        else:
555            return e
556
557    def __init__(self, substrates=[], elements=[], attribute=[], 
558            version=None):
559
560        if version is None: self.version = Topology.version
561        else: self.version = version
562
563        self.substrates = [ self.init_class(Substrate, s) \
564                for s in self.make_list(substrates) ]
565        self.elements = [ self.init_element(e) \
566                for e in self.make_list(elements) ]
567        self.attribute = [ self.init_class(Attribute, c) \
568                for c in self.make_list(attribute) ]
569        self.incorporate_elements()
570
571    @staticmethod
572    def name_element_interfaces(e):
573        names = set([i.name for i in e.interface if i.name])
574        inum = 0
575        for i in [ i for i in e.interface if not i.name]:
576            while inum < 1000:
577                n = "inf%03d" % inum
578                inum += 1
579                if n not in names:
580                    i.name = n
581                    break
582            else:
583                raise NamespaceError("Cannot make new interface name")
584
585
586
587    def name_interfaces(self):
588        """
589        For any interface without a name attribute, assign a unique one within
590        its element.
591        """
592
593        for e in self.elements:
594            self.name_element_interfaces(e)
595
596
597    def incorporate_elements(self):
598
599        # Could to this init in one gulp, but we want to look for duplicate
600        # substrate names
601        substrate_map = { }
602        for s in self.substrates:
603            s.interfaces = [ ]
604            if not substrate_map.has_key(s.name):
605                substrate_map[s.name] = s
606            else:
607                raise ConsistencyError("Duplicate substrate name %s" % s.name)
608
609        for e in self.elements:
610            self.name_element_interfaces(e)
611            for i in e.interface:
612                i.element = e
613                i.subs = [ ]
614                for sn in i.substrate:
615                    # NB, interfaces have substrate names in their substrate
616                    # attribute.
617                    if substrate_map.has_key(sn):
618                        sub = substrate_map[sn]
619                        i.subs.append(sub)
620                        sub.interfaces.append(i)
621                    else:
622                        raise ConsistencyError("No such substrate for %s" % sn)
623
624    def clone(self):
625        return Topology(substrates=[s.clone() for s in self.substrates], 
626                elements=[e.clone() for e in self.elements],
627                attribute=[a.clone() for a in self.attribute],
628                version=self.version)
629
630
631    def make_indices(self):
632        sub_index = dict([(s.name, s) for s in self.substrates])
633        elem_index = dict([(n, e) for e in self.elements for n in e.name])
634
635    def to_dict(self):
636        rv = { }
637        rv['version'] = self.version
638        if self.substrates:
639            rv['substrates'] = [ s.to_dict() for s in self.substrates ]
640        if self.elements:
641            rv['elements'] = [ s.to_dict() for s in self.elements ]
642        if self.attribute:
643            rv['attribute'] = [ s.to_dict() for s in self.attribute]
644        return rv
645
646    def to_xml(self):
647        rv = "<version>%s</version>" % escape(self.version)
648        if self.substrates:
649            rv += join(["<substrates>%s</substrates>" % s.to_xml() \
650                    for s in self.substrates], "")
651        if self.elements:
652            rv += join(["<elements>%s</elements>" % e.to_xml() \
653                    for e in self.elements], "")
654        if self.attribute:
655            rv += join(["<attribute>%s</attribute>" % a.to_xml() \
656                    for a in self.attribute], "")
657        return rv
658
659
660def topology_from_xml(string=None, file=None, filename=None, top="topology"):
661    class parser:
662        def __init__(self, top):
663            self.stack = [ ]
664            self.chars = ""
665            self.key = ""
666            self.have_chars = False
667            self.current = { }
668            self.in_cdata = False
669            self.in_top = False
670            self.top = top
671       
672        def start_element(self, name, attrs):
673            self.chars = ""
674            self.have_chars = False
675            self.key = str(name)
676
677            if name == self.top:
678                self.in_top = True
679
680            if self.in_top:
681                self.stack.append((self.current, self.key))
682                self.current = { }
683
684        def end_element(self, name):
685            if self.in_top:
686                if self.have_chars:
687                    self.chars = self.chars.strip()
688                    if len(self.chars) >0:
689                        addit = self.chars
690                    else:
691                        addit = self.current
692                else:
693                    addit = self.current
694
695                parent, key = self.stack.pop()
696                if parent.has_key(key):
697                    if isinstance(parent[key], list):
698                        parent[key].append(addit)
699                    else:
700                        parent[key] = [parent[key], addit]
701                else:
702                    parent[key] = addit
703                self.current = parent
704                self.key = key
705
706            self.chars = ""
707            self.have_chars = False
708
709            if name == self.top:
710                self.in_top= False
711
712        def char_data(self, data):
713            if self.in_top:
714                self.have_chars = True
715                self.chars += data
716
717    p = parser(top=top)
718    xp = xml.parsers.expat.ParserCreate()
719
720    xp.StartElementHandler = p.start_element
721    xp.EndElementHandler = p.end_element
722    xp.CharacterDataHandler = p.char_data
723
724    num_set = len([ x for x in (string, filename, file)\
725            if x is not None ])
726
727    if num_set != 1:
728        raise RuntimeError("Exactly one one of file, filename and string " + \
729                "must be set")
730    elif filename:
731        f = open(filename, "r")
732        xp.ParseFile(f)
733        f.close()
734    elif file:
735        xp.ParseFile(file)
736    elif string:
737        xp.Parse(string, isfinal=True)
738    else:
739        return None
740
741    return Topology(**p.current[top])
742
743def topology_from_startsegment(req):
744    """
745    Generate a topology from a StartSegment request to an access controller.
746    This is a little helper to avoid some gross looking syntax.  It accepts
747    either a request enclosed in the StartSegmentRequestBody, or one with that
748    outer dict removed.
749    """
750
751    if 'StartSegmentRequestBody' in req: r = req['StartSegmentRequestBody']
752    else: r = req
753   
754    if 'segmentdescription' in r and \
755            'topdldescription' in r['segmentdescription']:
756        return Topology(**r['segmentdescription']['topdldescription'])
757    else:
758        return None
759
760def topology_to_xml(t, top=None):
761    """
762    Print the topology as XML, recursively using the internal classes to_xml()
763    methods.
764    """
765
766    if top: return "<%s>%s</%s>" % (top, t.to_xml(), top)
767    else: return t.to_xml()
768
769def topology_to_vtopo(t):
770    nodes = [ ]
771    lans = [ ]
772
773    for eidx, e in enumerate(t.elements):
774        if e.name: name = e.name
775        else: name = "unnamed_node%d" % eidx
776       
777        ips = [ ]
778        for idx, i in enumerate(e.interface):
779            ip = i.get_attribute('ip4_address')
780            ips.append(ip)
781            port = "%s:%d" % (name, idx)
782            for idx, s in enumerate(i.subs):
783                bw = 100000
784                delay = 0.0
785                if s.capacity:
786                    bw = s.capacity.rate
787                if i.capacity:
788                    bw = i.capacity.rate
789
790                if s.latency:
791                    delay = s.latency.time
792                if i.latency:
793                    bw = i.latency.time
794
795                lans.append({
796                    'member': port,
797                    'vname': s.name,
798                    'ip': ip,
799                    'vnode': name,
800                    'delay': delay,
801                    'bandwidth': bw,
802                    })
803        nodes.append({
804            'ips': ":".join(ips),
805            'vname': name,
806            })
807
808    return { 'node': nodes, 'lan': lans }
809
810def to_tcl_name(n):
811    t = re.sub('-(\d+)', '(\\1)', n)
812    return t
813
814def generate_portal_command_filter(cmd, add_filter=None):
815    def rv(e):
816        s =""
817        if isinstance(e, Computer):
818            gw = e.get_attribute('portal')
819            if add_filter and callable(add_filter):
820                add = add_filter(e)
821            else:
822                add = True
823            if gw and add:
824                s = "%s ${%s}\n" % (cmd, to_tcl_name(e.name))
825        return s
826    return rv
827
828def generate_portal_image_filter(image):
829    def rv(e):
830        s =""
831        if isinstance(e, Computer):
832            gw = e.get_attribute('portal')
833            if gw:
834                s = "tb-set-node-os ${%s} %s\n" % (to_tcl_name(e.name), image)
835        return s
836    return rv
837
838def generate_portal_hardware_filter(type):
839    def rv(e):
840        s =""
841        if isinstance(e, Computer):
842            gw = e.get_attribute('portal')
843            if gw:
844                s = "tb-set-hardware ${%s} %s\n" % (to_tcl_name(e.name), type)
845        return s
846    return rv
847
848
849def topology_to_ns2(t, filters=[], routing="Manual"):
850    out = """
851set ns [new Simulator]
852source tb_compat.tcl
853
854"""
855
856    for e in t.elements:
857        rpms = ""
858        tarfiles = ""
859        if isinstance(e, Computer):
860            name = to_tcl_name(e.name)
861            out += "set %s [$ns node]\n" % name
862            if e.os and len(e.os) == 1:
863                osid = e.os[0].get_attribute('osid')
864                if osid:
865                    out += "tb-set-node-os ${%s} %s\n" % (name, osid)
866            hw = e.get_attribute('type')
867            if hw:
868                out += "tb-set-hardware ${%s} %s\n" % (name, hw)
869            for s in e.software:
870                if s.install:
871                    tarfiles += "%s %s " % (s.install, s.location)
872                else:
873                    rpms += "%s " % s.location
874            if rpms:
875                out += "tb-set-node-rpms ${%s} %s\n" % (name, rpms)
876            if tarfiles:
877                out += "tb-set-node-tarfiles ${%s} %s\n" % (name, tarfiles)
878            startcmd = e.get_attribute('startup')
879            if startcmd:
880                out+= 'tb-set-node-startcmd ${%s} "%s"\n' % (name, startcmd)
881            for f in filters:
882                out += f(e)
883            out+= "\n"
884   
885    for idx, s in enumerate(t.substrates):
886        loss = s.get_attribute('loss')
887        if s.latency: delay = s.latency.time
888        else: delay = 0
889
890        if s.capacity: rate = s.capacity.rate
891        else: rate = 100000
892        name = to_tcl_name(s.name or "sub%d" % idx)
893
894        if len(s.interfaces) > 2:
895            # Lan
896            members = [ to_tcl_name("${%s}") % i.element.name \
897                    for i in s.interfaces]
898            out += 'set %s [$ns make-lan "%s" %fkb %fms ]\n' % \
899                    (name, " ".join([to_tcl_name(m) for m in members]),
900                            rate, delay)
901            if loss:
902                "tb-set-lan-loss ${%s} %f\n" % (name, float(loss))
903
904            for i in s.interfaces:
905                e = i.element
906                ip = i.get_attribute("ip4_address")
907                if ip:
908                    out += "tb-set-ip-lan ${%s} ${%s} %s\n" % \
909                            (to_tcl_name(e.name), name, ip)
910                if i.capacity and i.capacity.rate != rate:
911                    out += "tb-set-node-lan-bandwidth ${%s} ${%s} %fkb\n" % \
912                            (to_tcl_name(e.name), name, i.capacity.rate)
913                if i.latency and i.latency.time != delay:
914                    out += "tb-set-node-lan-delay ${%s} ${%s} %fms\n" % \
915                            (to_tcl_name(e.name), name, i.latency.time)
916                iloss = i.get_attribute('loss')
917                if loss and iloss != loss :
918                    out += "tb-set-node-lan-loss ${%s} ${%s} %f\n" % \
919                            (to_tcl_name(e.name), name, float(loss))
920            out+= "\n"
921        elif len(s.interfaces) == 2:
922            f = s.interfaces[0]
923            t = s.interfaces[1]
924
925            out += "set %s [$ns duplex-link ${%s} ${%s} %fkb %fms DropTail]\n" %\
926                    (name, to_tcl_name(f.element.name), 
927                            to_tcl_name(t.element.name), rate, delay)
928            if loss:
929                out += "tb-set-link-loss ${%s} %f\n" % (name, float(loss))
930
931            for i in s.interfaces:
932                lloss = i.get_attribute("loss")
933                cap_override = i.capacity and \
934                        i.capacity.rate != rate
935                delay_override = i.latency and \
936                        i.latency.time != delay
937                loss_override = lloss and lloss != loss
938                if cap_override or delay_override or loss_override:
939                    if i.capacity: cap = i.capacity.rate
940                    else: cap = rate
941
942                    if i.latency: delay = i.latency.time
943
944                    if lloss: loss = lloss
945                    else: loss = loss or 0.0
946
947                    out += "tb-set-link-simplex-params ${%s} ${%s} %fms %fkb %f\n"\
948                            % (name, to_tcl_name(i.element.name),
949                                    delay, cap, loss)
950                ip = i.get_attribute('ip4_address')
951                if ip:
952                    out += "tb-set-ip-link ${%s} ${%s} %s\n" % \
953                            (to_tcl_name(i.element.name), name, ip)
954            out+= "\n"
955        for f in filters:
956            out+= f(s)
957    out+="$ns rtproto %s" % routing
958    out+="""
959$ns run
960"""
961    return out
962
963def topology_to_rspec(t, filters=[]):
964    out = '<?xml version="1.0" encoding="UTF-8"?>\n' + \
965        '<rspec xmlns="http://www.protogeni.net/resources/rspec/0.1"\n' + \
966        '\txmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"\n' + \
967        '\txsi:schemaLocation="http://www.protogeni.net/resources/rspec/0.1 '+ \
968        'http://www.protogeni.net/resources/rspec/0.1/request.xsd"\n' + \
969        '\ttype="request" >\n'
970
971    ifname = { }
972    ifnode = { }
973
974    for e in [e for e in t.elements if isinstance(e, Computer)]:
975        name = e.name
976        virt_type = e.get_attribute("virtualization_type") or "emulab-vnode"
977        exclusive = e.get_attribute("exclusive") or "1"
978        hw = e.get_attribute("type") or "pc";
979        slots = e.get_attribute("slots") or "1";
980        startup = e.get_attribute("startup")
981
982        extras = ""
983        if startup: extras += '\t\tstartup_command="%s"\n' % startup
984        out += '\t<node virtual_id="%s"\n\t\tvirtualization_type="%s"\n' % \
985                (name, virt_type)
986        out += '\t\texclusive="%s"' % exclusive
987        if extras: out += '\n%s' % extras
988        out += '>\n'
989        out += '\t\t<node_type type_name="%s" slots="%s"/>\n' % (hw, slots)
990        for i, ii in enumerate(e.interface):
991            out += '\t\t<interface virtual_id="%s"/>\n' % ii.name
992            ifnode[ii] = name
993        for f in filters:
994            out += f(e)
995        out += '\t</node>\n'
996
997    for i, s in enumerate(t.substrates):
998        if len(s.interfaces) == 0: 
999            continue
1000        out += '\t<link virtual_id="%s" link_type="ethernet">\n' % s.name
1001        if s.capacity and s.capacity.kind == "max":
1002            bwout = True
1003            out += '\t\t<bandwidth>%d</bandwidth>\n' % s.capacity.rate
1004        else:
1005            bwout = False
1006        if s.latency and s.latency.kind == "max":
1007            out += '\t\t<latency>%d</latency>\n' % s.latency.time
1008        elif bwout:
1009            out += '\t\t<latency>0</latency>\n'
1010        for ii in s.interfaces:
1011            out += ('\t\t<interface_ref virtual_node_id="%s" ' + \
1012                    'virtual_interface_id="%s"/>\n') % (ifnode[ii], ii.name)
1013        for f in filters:
1014            out += f(s)
1015        out += '\t</link>\n'
1016    out += '</rspec>\n'
1017    return out
1018
Note: See TracBrowser for help on using the repository browser.