From: Nicolas Turro Date: Wed, 28 Mar 2012 14:43:36 +0000 (+0200) Subject: Merge branch 'senslab2' of ssh://git.f-lab.fr/git/sfa into senslab2 X-Git-Tag: sfa-2.1-24~3^2~189 X-Git-Url: http://git.onelab.eu/?a=commitdiff_plain;h=79a37c7df42d5029ffe1a829d052391f618981f1;hp=ace4a403aeda781941545208b3c961a7bd702fe4;p=sfa.git Merge branch 'senslab2' of ssh://git.f-lab.fr/git/sfa into senslab2 Conflicts: sfa/senslab/slabaggregate.py --- diff --git a/sfa/rspecs/elements/versions/slabv1Node.py b/sfa/rspecs/elements/versions/slabv1Node.py new file mode 100644 index 00000000..a4eb6504 --- /dev/null +++ b/sfa/rspecs/elements/versions/slabv1Node.py @@ -0,0 +1,146 @@ +from sfa.util.plxrn import PlXrn, xrn_to_hostname +from sfa.util.xrn import Xrn +from sfa.util.xml import XpathFilter +from sfa.rspecs.elements.node import Node +from sfa.rspecs.elements.sliver import Sliver +from sfa.rspecs.elements.location import Location +from sfa.rspecs.elements.hardware_type import HardwareType +from sfa.rspecs.elements.disk_image import DiskImage +from sfa.rspecs.elements.interface import Interface +from sfa.rspecs.elements.bwlimit import BWlimit +from sfa.rspecs.elements.pltag import PLTag + +from sfa.rspecs.elements.versions.slabv1Sliver import Slabv1Sliver +import sys +class Slabv1Node: + @staticmethod + def add_nodes(xml, nodes): + + node_elems = [] + for node in nodes: + node_fields = ['component_manager_id', 'component_id', 'client_id', 'sliver_id', 'exclusive','boot_state'] + node_elem = xml.add_instance('node', node, node_fields) + node_elems.append(node_elem) + # set component name + if node.get('component_id'): + component_name = xrn_to_hostname(node['component_id']) + node_elem.set('component_name', component_name) + # set hardware types + if node.get('hardware_types'): + for hardware_type in node.get('hardware_types', []): + node_elem.add_instance('hardware_type', hardware_type, HardwareType.fields) + # set location + if node.get('location'): + node_elem.add_instance('location', node['location'], Location.fields) + # set interfaces + #if node.get('interfaces'): + #for interface in node.get('interfaces', []): + #node_elem.add_instance('interface', interface, ['component_id', 'client_id']) + # set available element + if node.get('boot_state'): + if node.get('boot_state').lower() == 'alive': + available_elem = node_elem.add_element('available', now='true') + else: + available_elem = node_elem.add_element('available', now='false') + + ## add services + #PGv2Services.add_services(node_elem, node.get('services', [])) + # add slivers + slivers = node.get('slivers', []) + if not slivers: + # we must still advertise the available sliver types + slivers = Sliver({'type': 'slab-node'}) + # we must also advertise the available initscripts + slivers['tags'] = [] + if node.get('pl_initscripts'): + for initscript in node.get('pl_initscripts', []): + slivers['tags'].append({'name': 'initscript', 'value': initscript['name']}) + Slabv1Sliver.add_slivers(node_elem, slivers) + print>>sys.stderr, "\r\n \r\n SLABV1NODE.PY \t\t addnodes node_elems[0] %s" %(node_elems[0]) + return node_elems + + @staticmethod + def get_nodes(xml, filter={}): + xpath = '//node%s | //default:node%s' % (XpathFilter.xpath(filter), XpathFilter.xpath(filter)) + node_elems = xml.xpath(xpath) + return Slabv1Node.get_node_objs(node_elems) + + @staticmethod + def get_nodes_with_slivers(xml, filter={}): + xpath = '//node[count(sliver_type)>0] | //default:node[count(default:sliver_type) > 0]' + node_elems = xml.xpath(xpath) + return Slabv1Node.get_node_objs(node_elems) + + @staticmethod + def get_node_objs(node_elems): + nodes = [] + for node_elem in node_elems: + node = Node(node_elem.attrib, node_elem) + nodes.append(node) + if 'component_id' in node_elem.attrib: + node['authority_id'] = Xrn(node_elem.attrib['component_id']).get_authority_urn() + + # get hardware types + hardware_type_elems = node_elem.xpath('./default:hardware_type | ./hardware_type') + node['hardware_types'] = [hw_type.get_instance(HardwareType) for hw_type in hardware_type_elems] + + # get location + location_elems = node_elem.xpath('./default:location | ./location') + locations = [location_elem.get_instance(Location) for location_elem in location_elems] + if len(locations) > 0: + node['location'] = locations[0] + + # get interfaces + iface_elems = node_elem.xpath('./default:interface | ./interface') + node['interfaces'] = [iface_elem.get_instance(Interface) for iface_elem in iface_elems] + + # get services + #node['services'] = PGv2Services.get_services(node_elem) + + # get slivers + node['slivers'] = Slabv1Sliver.get_slivers(node_elem) + available_elems = node_elem.xpath('./default:available | ./available') + if len(available_elems) > 0 and 'name' in available_elems[0].attrib: + if available_elems[0].attrib.get('now', '').lower() == 'true': + node['boot_state'] = 'boot' + else: + node['boot_state'] = 'disabled' + return nodes + + + @staticmethod + def add_slivers(xml, slivers): + component_ids = [] + for sliver in slivers: + filter = {} + if isinstance(sliver, str): + filter['component_id'] = '*%s*' % sliver + sliver = {} + elif 'component_id' in sliver and sliver['component_id']: + filter['component_id'] = '*%s*' % sliver['component_id'] + if not filter: + continue + nodes = Slabv1Node.get_nodes(xml, filter) + if not nodes: + continue + node = nodes[0] + Slabv1Sliver.add_slivers(node, sliver) + + @staticmethod + def remove_slivers(xml, hostnames): + for hostname in hostnames: + nodes = Slabv1Node.get_nodes(xml, {'component_id': '*%s*' % hostname}) + for node in nodes: + slivers = Slabv1Sliver.get_slivers(node.element) + for sliver in slivers: + node.element.remove(sliver.element) +if __name__ == '__main__': + from sfa.rspecs.rspec import RSpec + + r = RSpec('/tmp/slab.rspec') + r2 = RSpec(version = 'slab') + nodes = Slabv1Node.get_nodes(r.xml) + Slabv1Node.add_nodes(r2.xml.root, nodes) + + + diff --git a/sfa/rspecs/elements/versions/slabv1Sliver.py b/sfa/rspecs/elements/versions/slabv1Sliver.py new file mode 100644 index 00000000..a4c9be4c --- /dev/null +++ b/sfa/rspecs/elements/versions/slabv1Sliver.py @@ -0,0 +1,52 @@ +from sfa.rspecs.elements.element import Element +from sfa.rspecs.elements.sliver import Sliver +#from sfa.rspecs.elements.versions.pgv2DiskImage import PGv2DiskImage + +class Slabv1Sliver: + + @staticmethod + def add_slivers(xml, slivers): + if not slivers: + return + if not isinstance(slivers, list): + slivers = [slivers] + for sliver in slivers: + sliver_elem = xml.add_element('sliver_type') + if sliver.get('type'): + sliver_elem.set('name', sliver['type']) + if sliver.get('client_id'): + sliver_elem.set('client_id', sliver['client_id']) + #images = sliver.get('disk_images') + #if images and isinstance(images, list): + #Slabv1DiskImage.add_images(sliver_elem, images) + Slabv1Sliver.add_sliver_attributes(sliver_elem, sliver.get('tags', [])) + + @staticmethod + def add_sliver_attributes(xml, attributes): + if attributes: + for attribute in attributes: + if attribute['name'] == 'initscript': + xml.add_element('{%s}initscript' % xml.namespaces['planetlab'], name=attribute['value']) + elif tag['tagname'] == 'flack_info': + attrib_elem = xml.add_element('{%s}info' % self.namespaces['flack']) + attrib_dict = eval(tag['value']) + for (key, value) in attrib_dict.items(): + attrib_elem.set(key, value) + @staticmethod + def get_slivers(xml, filter={}): + xpath = './default:sliver_type | ./sliver_type' + sliver_elems = xml.xpath(xpath) + slivers = [] + for sliver_elem in sliver_elems: + sliver = Sliver(sliver_elem.attrib,sliver_elem) + if 'component_id' in xml.attrib: + sliver['component_id'] = xml.attrib['component_id'] + if 'name' in sliver_elem.attrib: + sliver['type'] = sliver_elem.attrib['name'] + #sliver['images'] = Slabv1DiskImage.get_images(sliver_elem) + slivers.append(sliver) + return slivers + + @staticmethod + def get_sliver_attributes(xml, filter={}): + return [] \ No newline at end of file diff --git a/sfa/rspecs/versions/slabv1.py b/sfa/rspecs/versions/slabv1.py new file mode 100644 index 00000000..8c1030c6 --- /dev/null +++ b/sfa/rspecs/versions/slabv1.py @@ -0,0 +1,256 @@ +from copy import deepcopy +from StringIO import StringIO +from sfa.util.xrn import Xrn, urn_to_sliver_id +from sfa.util.plxrn import hostname_to_urn, xrn_to_hostname +from sfa.rspecs.baseversion import BaseVersion + +from sfa.rspecs.elements.versions.slabv1Node import Slabv1Node +from sfa.rspecs.elements.versions.slabv1Sliver import Slabv1Sliver + +class Slabv1(BaseVersion): + #enabled = True + type = 'Slab' + content_type = 'ad' + version = '1' + #template = '' % type + + schema = 'http://senslab.info/resources/rspec/1/ad.xsd' + namespace = 'http://www.geni.net/resources/rspec/3' + extensions = { + 'flack': "http://www.protogeni.net/resources/rspec/ext/flack/1", + 'planetlab': "http://www.planet-lab.org/resources/sfa/ext/planetlab/1", + } + namespaces = dict(extensions.items() + [('default', namespace)]) + elements = [] + + # Network + def get_networks(self): + network_elems = self.xml.xpath('//network') + networks = [network_elem.get_instance(fields=['name', 'slice']) for \ + network_elem in network_elems] + return networks + + + def add_network(self, network): + network_tags = self.xml.xpath('//network[@name="%s"]' % network) + if not network_tags: + network_tag = self.xml.add_element('network', name=network) + else: + network_tag = network_tags[0] + return network_tag + + + # Nodes + + def get_nodes(self, filter=None): + return Slabv1Node.get_nodes(self.xml, filter) + + def get_nodes_with_slivers(self): + return Slabv1Node.get_nodes_with_slivers(self.xml) + + def add_nodes(self, nodes, check_for_dupes=False): + return Slabv1Node.add_nodes(self.xml, nodes) + + def merge_node(self, source_node_tag, network, no_dupes = False): + if no_dupes and self.get_node_element(node['hostname']): + # node already exists + return + network_tag = self.add_network(network) + network_tag.append(deepcopy(source_node_tag)) + + # Slivers + + def get_sliver_attributes(self, hostname, network=None): + nodes = self.get_nodes({'component_id': '*%s*' %hostname}) + attribs = [] + if nodes is not None and isinstance(nodes, list) and len(nodes) > 0: + node = nodes[0] + sliver = node.xpath('./default:sliver_type', namespaces=self.namespaces) + if sliver is not None and isinstance(sliver, list) and len(sliver) > 0: + sliver = sliver[0] + #attribs = self.attributes_list(sliver) + return attribs + + def get_slice_attributes(self, network=None): + slice_attributes = [] + nodes_with_slivers = self.get_nodes_with_slivers() + # TODO: default sliver attributes in the PG rspec? + default_ns_prefix = self.namespaces['default'] + for node in nodes_with_slivers: + sliver_attributes = self.get_sliver_attributes(node, network) + for sliver_attribute in sliver_attributes: + name=str(sliver_attribute[0]) + text =str(sliver_attribute[1]) + attribs = sliver_attribute[2] + # we currently only suppor the and attributes + if 'info' in name: + attribute = {'name': 'flack_info', 'value': str(attribs), 'node_id': node} + slice_attributes.append(attribute) + elif 'initscript' in name: + if attribs is not None and 'name' in attribs: + value = attribs['name'] + else: + value = text + attribute = {'name': 'initscript', 'value': value, 'node_id': node} + slice_attributes.append(attribute) + + return slice_attributes + + def attributes_list(self, elem): + opts = [] + if elem is not None: + for e in elem: + opts.append((e.tag, str(e.text).strip(), e.attrib)) + return opts + + def get_default_sliver_attributes(self, network=None): + return [] + + def add_default_sliver_attribute(self, name, value, network=None): + pass + + def add_slivers(self, hostnames, attributes=[], sliver_urn=None, append=False): + # all nodes hould already be present in the rspec. Remove all + # nodes that done have slivers + for hostname in hostnames: + node_elems = self.get_nodes({'component_id': '*%s*' % hostname}) + if not node_elems: + continue + node_elem = node_elems[0] + + # determine sliver types for this node + valid_sliver_types = ['slab-node', 'emulab-openvz', 'raw-pc', 'plab-vserver', 'plab-vnode'] + #valid_sliver_types = ['emulab-openvz', 'raw-pc', 'plab-vserver', 'plab-vnode'] + requested_sliver_type = None + for sliver_type in node_elem.get('slivers', []): + if sliver_type.get('type') in valid_sliver_types: + requested_sliver_type = sliver_type['type'] + + if not requested_sliver_type: + continue + sliver = {'type': requested_sliver_type, + 'pl_tags': attributes} + + # remove available element + for available_elem in node_elem.xpath('./default:available | ./available'): + node_elem.remove(available_elem) + + # remove interface elements + for interface_elem in node_elem.xpath('./default:interface | ./interface'): + node_elem.remove(interface_elem) + + # remove existing sliver_type elements + for sliver_type in node_elem.get('slivers', []): + node_elem.element.remove(sliver_type.element) + + # set the client id + node_elem.element.set('client_id', hostname) + if sliver_urn: + pass + # TODO + # set the sliver id + #slice_id = sliver_info.get('slice_id', -1) + #node_id = sliver_info.get('node_id', -1) + #sliver_id = urn_to_sliver_id(sliver_urn, slice_id, node_id) + #node_elem.set('sliver_id', sliver_id) + + # add the sliver type elemnt + Slabv1SliverType.add_slivers(node_elem.element, sliver) + + # remove all nodes without slivers + if not append: + for node_elem in self.get_nodes(): + if not node_elem['client_id']: + parent = node_elem.element.getparent() + parent.remove(node_elem.element) + + def remove_slivers(self, slivers, network=None, no_dupes=False): + Slabv1Node.remove_slivers(self.xml, slivers) + + + + # Utility + + def merge(self, in_rspec): + """ + Merge contents for specified rspec with current rspec + """ + from sfa.rspecs.rspec import RSpec + # just copy over all the child elements under the root element + if isinstance(in_rspec, basestring): + in_rspec = RSpec(in_rspec) + + nodes = in_rspec.version.get_nodes() + # protogeni rspecs need to advertise the availabel sliver types + for node in nodes: + if not node.has_key('sliver') or not node['sliver']: + node['sliver'] = {'name': 'slab-node'} + + self.add_nodes(nodes) + #self.add_links(in_rspec.version.get_links()) + + # + #rspec = RSpec(in_rspec) + #for child in rspec.xml.iterchildren(): + # self.xml.root.append(child) + + + + def cleanup(self): + # remove unncecessary elements, attributes + if self.type in ['request', 'manifest']: + # remove 'available' element from remaining node elements + self.xml.remove_element('//default:available | //available') + + +class Slabv1Ad(Slabv1): + enabled = True + content_type = 'ad' + schema = 'http://senslab.info/resources/rspec/1/ad.xsd' + #http://www.geni.net/resources/rspec/3/ad.xsd' + template = '' + +class Slabv1Request(Slabv1): + enabled = True + content_type = 'request' + schema = 'http://senslab.info/resources/rspec/1/request.xsd' + #http://www.geni.net/resources/rspec/3/request.xsd + template = '' + +class Slabv1Manifest(Slabv1): + enabled = True + content_type = 'manifest' + schema = 'http://senslab.info/resources/rspec/1/manifest.xsd' + #http://www.geni.net/resources/rspec/3/manifest.xsd + template = '' +#class Slabv1Ad(Slabv1): + #enabled = True + #content_type = 'ad' + #schema = 'http://senslab.info/resources/rspec/1/ad.xsd' + ##http://www.geni.net/resources/rspec/3/ad.xsd' + #template = '' + +#class Slabv1Request(Slabv1): + #enabled = True + #content_type = 'request' + #schema = 'http://senslab.info/resources/rspec/1/request.xsd' + ##http://www.geni.net/resources/rspec/3/request.xsd + #template = '' + +#class Slabv1Manifest(Slabv1): + #enabled = True + #content_type = 'manifest' + #schema = 'http://senslab.info/resources/rspec/1/manifest.xsd' + ##http://www.geni.net/resources/rspec/3/manifest.xsd + #template = '' + + + + +if __name__ == '__main__': + from sfa.rspecs.rspec import RSpec + from sfa.rspecs.rspec_elements import * + r = RSpec('/tmp/slab.rspec') + r.load_rspec_elements(Slabv1.elements) + r.namespaces = Slabv1.namespaces + print r.get(RSpecElements.NODE) diff --git a/sfa/senslab/slabaggregate.py b/sfa/senslab/slabaggregate.py index 7737aabc..f8ce7a33 100644 --- a/sfa/senslab/slabaggregate.py +++ b/sfa/senslab/slabaggregate.py @@ -7,7 +7,7 @@ import httplib import json -from sfa.rspecs.version_manager import VersionManager + from sfa.senslab.OARrestapi import * #from sfa.senslab.slabdriver import SlabDriver from sfa.util.config import Config @@ -167,7 +167,7 @@ class SlabAggregate: #geni_available = options.get('geni_available') #if geni_available: #filter['boot_state'] = 'boot' - print>>sys.stderr, "\r\n \r\n \t get_nodes_and_links filter %s \r\n \r\n \t slivers %s" %(filter, slivers) + #filter.update({'peer_id': None}) #nodes = self.driver.GetNodes(filter['hostname']) #print>>sys.stderr, "\r\n \r\n \t get_nodes_and_links nodes %s" %(nodes) @@ -211,21 +211,20 @@ class SlabAggregate: rspec_node['boot_state'] = node['boot_state'] if node['hostname'] in reserved_nodes: rspec_node['boot_state'] = "Reserved" - rspec_node['exclusive'] = 'true' - rspec_node['hardware_types'] = [HardwareType({'name': 'slab-sensor'})] + rspec_node['exclusive'] = 'True' + rspec_node['hardware_types'] = [HardwareType({'name': 'slab-node'})] + # only doing this because protogeni rspec needs # to advertise available initscripts - rspec_node['pl_initscripts'] = None + #rspec_node['pl_initscripts'] = None # add site/interface info to nodes. # assumes that sites, interfaces and tags have already been prepared. #site = sites_dict[node['site_id']] - #if site['longitude'] and site['latitude']: - #location = Location({'longitude': site['longitude'], 'latitude': site['latitude'], 'country': 'unknown'}) - #rspec_node['location'] = location + if node['posx'] and node['posy']: location = Location({'longitude':node['posx'], 'latitude': node['posy']}) rspec_node['location'] = location - rspec_node['interfaces'] = [] + #rspec_node['interfaces'] = [] #if_count=0 #for if_id in node['interface_ids']: #interface = Interface(interfaces[if_id]) @@ -252,28 +251,35 @@ class SlabAggregate: #service = Services({'login': login}) #rspec_node['services'] = [service] rspec_nodes.append(rspec_node) + print>>sys.stderr, "\r\n \r\n \t get_nodes_and_links options %s rspec_nodes[0] %s " %(options,rspec_nodes[0]) return (rspec_nodes) #from plc/aggregate.py def get_rspec(self, slice_xrn=None, version = None, options={}): rspec = None - version_manager = VersionManager() + version_manager = VersionManager() + version = version_manager.get_version(version) - print>>sys.stderr, " \r\n SlabAggregate \t\t get_rspec ************** version %s version_manager %s options %s \r\n" %(version,version_manager,options) - + print>>sys.stderr, " \r\n SlabAggregate \t\t get_rspec ************** version %s version.type %s version.version %s options %s \r\n" %(version,version.type,version.version,options) + if not slice_xrn: rspec_version = version_manager._get_version(version.type, version.version, 'ad') + else: rspec_version = version_manager._get_version(version.type, version.version, 'manifest') + slice, slivers = self.get_slice_and_slivers(slice_xrn) #at this point sliver my be {} if no senslab job is running for this user/slice. rspec = RSpec(version=rspec_version, user_options=options) + + #if slice and 'expires' in slice: #rspec.xml.set('expires', datetime_to_epoch(slice['expires'])) # add sliver defaults #nodes, links = self.get_nodes_and_links(slice, slivers) nodes = self.get_nodes_and_links(slice,slivers) + print>>sys.stderr, " \r\n SlabAggregate \t\t get_rspec ************** options %s rspec_version %s version_manager %s rspec.version %s \r\n" %(options, rspec_version,version_manager, rspec.version) rspec.version.add_nodes(nodes) #rspec.version.add_links(links) diff --git a/sfa/senslab/slabdriver.py b/sfa/senslab/slabdriver.py index f9c715da..3c351641 100644 --- a/sfa/senslab/slabdriver.py +++ b/sfa/senslab/slabdriver.py @@ -231,12 +231,12 @@ class SlabDriver(Driver): #print "manager options = ",options aggregate = SlabAggregate(self) origin_hrn = Credential(string=creds[0]).get_gid_caller().get_hrn() - print>>sys.stderr, " \r\n \r\n \t SLABDRIVER get_rspec origin_hrn %s" %(origin_hrn) + print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources origin_hrn %s" %(origin_hrn) options.update({'origin_hrn':origin_hrn}) - print>>sys.stderr, " \r\n \r\n \t SLABDRIVER get_rspec options %s" %(options) + print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources options %s" %(options) rspec = aggregate.get_rspec(slice_xrn=slice_urn, version=rspec_version, options=options) - + print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources rspec " # cache the result #if self.cache and not slice_hrn: #logger.debug("Slab.ListResources: stores advertisement in cache") diff --git a/sfa/senslab/slabslices.py b/sfa/senslab/slabslices.py index 57a50b81..d372eea2 100644 --- a/sfa/senslab/slabslices.py +++ b/sfa/senslab/slabslices.py @@ -9,6 +9,11 @@ from sfa.plc.vlink import VLink from sfa.util.xrn import Xrn from sfa.util.sfalogging import logger +from sqlalchemy import Column, Integer, String, DateTime +from sqlalchemy import Table, Column, MetaData, join, ForeignKey +from sfa.storage.model import RegRecord +from sfa.storage.alchemy import dbsession,engine + MAXINT = 2L**31-1 class SlabSlices: @@ -28,7 +33,77 @@ class SlabSlices: def __init__(self, driver): self.driver = driver - #def get_slivers(self, xrn, node=None): + + + def get_slivers(self, xrn, node=None): + hrn, type = urn_to_hrn(xrn) + + slice_name = hrn_to_pl_slicename(hrn) + # XX Should we just call PLCAPI.GetSliceTicket(slice_name) instead + # of doing all of this? + #return self.api.driver.GetSliceTicket(self.auth, slice_name) + + + + slice = self.driver.GetSlices(slice_filter = slice_name, filter_type = 'slice_hrn') + + + # Get user information + alchemy_person = dbsession.query(RegRecord).filter_by(record_id = slice['record_id_user']).first() + + slivers = [] + sliver_attributes = [] + + if slice['oar_job_id'] is not -1: + nodes_all = self.GetNodes({'hostname':slice['node_ids']}, + ['node_id', 'hostname','site','boot_state']) + nodeall_byhostname = dict([(n['hostname'], n) for n in nodes_all]) + nodes = slice['node_ids'] + + for node in nodes: + #for sliver_attribute in filter(lambda a: a['node_id'] == node['node_id'], slice_tags): + sliver_attribute['tagname'] = 'slab-tag' + sliver_attribute['value'] = 'slab-value' + sliver_attributes.append(sliver_attribute['tagname']) + attributes.append({'tagname': sliver_attribute['tagname'], + 'value': sliver_attribute['value']}) + + # set nodegroup slice attributes + for slice_tag in filter(lambda a: a['nodegroup_id'] in node['nodegroup_ids'], slice_tags): + # Do not set any nodegroup slice attributes for + # which there is at least one sliver attribute + # already set. + if slice_tag not in slice_tags: + attributes.append({'tagname': slice_tag['tagname'], + 'value': slice_tag['value']}) + + for slice_tag in filter(lambda a: a['node_id'] is None, slice_tags): + # Do not set any global slice attributes for + # which there is at least one sliver attribute + # already set. + if slice_tag['tagname'] not in sliver_attributes: + attributes.append({'tagname': slice_tag['tagname'], + 'value': slice_tag['value']}) + + # XXX Sanity check; though technically this should be a system invariant + # checked with an assertion + if slice['expires'] > MAXINT: slice['expires']= MAXINT + + slivers.append({ + 'hrn': hrn, + 'name': slice['name'], + 'slice_id': slice['slice_id'], + 'instantiation': slice['instantiation'], + 'expires': slice['expires'], + 'keys': keys, + 'attributes': attributes + }) + + return slivers + + + + #def get_slivers(self, xrn, node=None): #hrn, type = urn_to_hrn(xrn) #slice_name = hrn_to_pl_slicename(hrn) @@ -132,7 +207,6 @@ class SlabSlices: #}) #return slivers - def get_peer(self, xrn): hrn, type = urn_to_hrn(xrn) #Does this slice belong to a local site or a peer senslab site? diff --git a/sfa/util/sfatablesRuntime.py b/sfa/util/sfatablesRuntime.py index d1a4e6cc..a684d3e9 100644 --- a/sfa/util/sfatablesRuntime.py +++ b/sfa/util/sfatablesRuntime.py @@ -30,7 +30,6 @@ try: chain = chain.upper() rules = SFATablesRules(chain) - print>>sys.stderr, " \r\n \r\n \t\t \t sfaTablesRuntime.py run_sfatables context_callback %s chain %s rules %s " %(context_callback,chain, rules ) if rules.sorted_rule_list: contexts = rules.contexts request_context = context_callback(hrn, origin_hrn, contexts)