from sfa.server.sfaapi import SfaApi
from sfa.senslab.slabaggregate import SlabAggregate
import sfa.plc.peers as peers
-#from sfa.plc.aggregate import Aggregate
+
from sfa.senslab.slices import SlabSlices
class AggregateManager:
call_id = options.get('call_id')
if Callids().already_handled(call_id): return []
# look in cache first
- if self.caching and api.cache:
- slices = api.cache.get('slices')
- if slices:
- return slices
+ #if self.caching and api.cache:
+ #slices = api.cache.get('slices')
+ #if slices:
+ #return slices
# get data from db
slices = api.driver.GetSlices({'peer_id': None}, ['name'])
slice_urns = [hrn_to_urn(slice_hrn, 'slice') for slice_hrn in slice_hrns]
# cache the result
- if self.caching and api.cache:
- api.cache.add('slices', slice_urns)
+ #if self.caching and api.cache:
+ #api.cache.add('slices', slice_urns)
return slice_urns
version_string = version_string + "_"+options.get('info', 'default')
# look in cache first
- if self.caching and api.cache and not xrn and cached:
- rspec = api.cache.get(version_string)
- if rspec:
- api.logger.info("aggregate.ListResources: returning cached value for hrn %s"%hrn)
- return rspec
+ #if self.cache and api.cache and not xrn and cached:
+ #rspec = api.cache.get(version_string)
+ #if rspec:
+ #api.logger.info("aggregate.ListResources: returning cached value for hrn %s"%hrn)
+ #return rspec
#panos: passing user-defined options
#print "manager options = ",options
rspec = aggregate.get_rspec(slice_xrn=xrn, version=rspec_version, options=options)
# cache the result
- if self.caching and api.cache and not xrn:
- api.cache.add(version_string, rspec)
+ #if self.caching and api.cache and not xrn:
+ #api.cache.add(version_string, rspec)
return rspec
#print>>sys.stderr," \r\n End GetKeys with filter ", return_key_list
#return return_key_list
- def GetSlices( self,slice_filter=None, return_fields=None):
- return_slice_list= []
- print>>sys.stderr, "\r\n\r\n\t =======================GetSlices "
- if not (slice_filter or return_fields):
- return self.slices_list
- return_slice_list= parse_filter(self.slices_list, slice_filter,'slice', return_fields)
- return return_slice_list
+ #def GetSlices( self,slice_filter=None, return_fields=None):
+ #return_slice_list= []
+ #print>>sys.stderr, "\r\n\r\n\t =======================GetSlices "
+ #if not (slice_filter or return_fields):
+ #return self.slices_list
+ #return_slice_list= parse_filter(self.slices_list, slice_filter,'slice', return_fields)
+ #return return_slice_list
def AddSlice(self, slice_fields):
print >>sys.stderr,"\r\n \r\n \t\t_____________INIT Slabaggregate api : %s" %(api)
+ def get_slice_and_slivers(self, slice_xrn):
+ """
+ Returns a dict of slivers keyed on the sliver's node_id
+ """
+ slivers = {}
+ slice = None
+ if not slice_xrn:
+ return (slice, slivers)
+ slice_urn = hrn_to_urn(slice_xrn, 'slice')
+ slice_hrn, _ = urn_to_hrn(slice_xrn)
+ slice_name = slice_hrn
+ slices = self.driver.GetSlices(slice_name)
+ if not slices:
+ return (slice, slivers)
+ slice = slices[0]
+
+ # sort slivers by node id
+ for node_id in slice['node_ids']:
+ sliver = Sliver({'sliver_id': urn_to_sliver_id(slice_urn, slice['slice_id'], node_id),
+ 'name': slice['hrn'],
+ 'type': 'slab-vm',
+ 'tags': []})
+ slivers[node_id]= sliver
+
+ # sort sliver attributes by node id
+ #tags = self.driver.GetSliceTags({'slice_tag_id': slice['slice_tag_ids']})
+ #for tag in tags:
+ ## most likely a default/global sliver attribute (node_id == None)
+ #if tag['node_id'] not in slivers:
+ #sliver = Sliver({'sliver_id': urn_to_sliver_id(slice_urn, slice['slice_id'], ""),
+ #'name': 'slab-vm',
+ #'tags': []})
+ #slivers[tag['node_id']] = sliver
+ #slivers[tag['node_id']]['tags'].append(tag)
+ return (slice, slivers)
+
+
+
def get_nodes(self):
filtre = {}
#tags_filter = {}
rspec_nodes.append(rspec_node)
return (rspec_nodes)
+
+
#from plc/aggregate.py
def get_rspec(self, slice_xrn=None, version = None, options={}):
print>>sys.stderr, " \r\n SlabAggregate \t\t get_rspec **************\r\n"
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)
rspec = RSpec(version=rspec_version, user_options=options)
-
- nodes = self.get_nodes()
+ #if slice and 'expires' in slice:
+ #rspec.xml.set('expires', epochparse(slice['expires']))
+ # add sliver defaults
+ #nodes, links = self.get_nodes_and_links(slice, slivers)
+ nodes = self.get_nodes()
rspec.version.add_nodes(nodes)
-
- print >>sys.stderr, 'after add_nodes '
-
+
+ #rspec.version.add_links(links)
+ #default_sliver = slivers.get(None, [])
+ #if default_sliver:
+ #default_sliver_attribs = default_sliver.get('tags', [])
+ #for attrib in default_sliver_attribs:
+ #logger.info(attrib)
+ #rspec.version.add_default_sliver_attribute(attrib['tagname'], attrib['value'])
return rspec.toxml()
from sfa.util.table import SfaTable
from sfa.util.defaultdict import defaultdict
-
+from sfa.managers.driver import Driver
from sfa.rspecs.version_manager import VersionManager
from sfa.util.xrn import hrn_to_urn
# this inheritance scheme is so that the driver object can receive
# GetNodes or GetSites sorts of calls directly
# and thus minimize the differences in the managers with the pl version
-class SlabDriver ():
+class SlabDriver(Driver):
def __init__(self, config):
-
+ Driver.__init__ (self, config)
self.config=config
self.hrn = config.SFA_INTERFACE_HRN
self.time_format = "%Y-%m-%d %H:%M:%S"
self.db = SlabDB()
#self.logger=sfa_logger()
-
+ self.cache=None
+
+
+
def create_sliver (self, slice_urn, slice_hrn, creds, rspec_string, users, options):
aggregate = SlabAggregate(self)
#slices.handle_peer(site, slice, persons, peer)
return aggregate.get_rspec(slice_xrn=slice_urn, version=rspec.version)
+
+
+ def delete_sliver (self, slice_urn, slice_hrn, creds, options):
+
+ slices = self.GetSlices({'slice_hrn': slice_hrn})
+ if not slices:
+ return 1
+ slice = slices[0]
+
+ # determine if this is a peer slice
+ # xxx I wonder if this would not need to use PlSlices.get_peer instead
+ # in which case plc.peers could be deprecated as this here
+ # is the only/last call to this last method in plc.peers
+ peer = peers.get_peer(self, slice_hrn)
+ try:
+ if peer:
+ self.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
+ self.DeleteSliceFromNodes(slice_hrn, slice['node_ids'])
+ finally:
+ if peer:
+ self.BindObjectToPeer('slice', slice['slice_id'], peer, slice['peer_slice_id'])
+ return 1
+
+
+
+ # first 2 args are None in case of resource discovery
+ def list_resources (self, slice_urn, slice_hrn, creds, options):
+ #cached_requested = options.get('cached', True)
+
+ version_manager = VersionManager()
+ # get the rspec's return format from options
+ rspec_version = version_manager.get_version(options.get('geni_rspec_version'))
+ version_string = "rspec_%s" % (rspec_version)
+
+ #panos adding the info option to the caching key (can be improved)
+ if options.get('info'):
+ version_string = version_string + "_"+options.get('info', 'default')
+
+ # look in cache first
+ #if cached_requested and self.cache and not slice_hrn:
+ #rspec = self.cache.get(version_string)
+ #if rspec:
+ #logger.debug("SlabDriver.ListResources: returning cached advertisement")
+ #return rspec
+
+ #panos: passing user-defined options
+ #print "manager options = ",options
+ aggregate = SlabAggregate(self)
+ rspec = aggregate.get_rspec(slice_xrn=slice_urn, version=rspec_version,
+ options=options)
+
+ # cache the result
+ #if self.cache and not slice_hrn:
+ #logger.debug("Slab.ListResources: stores advertisement in cache")
+ #self.cache.add(version_string, rspec)
+
+ return rspec
+
def GetPersons(self, person_filter=None, return_fields=None):
person_list = self.ldap.ldapFind({'authority': self.root_auth })
reqdict['script_path'] = "/bin/sleep "
print>>sys.stderr, "\r\n \r\n AddSliceToNodes reqdict %s \r\n site_list %s" %(reqdict,site_list)
- OAR = OARrestapi()
- answer = OAR.POSTRequestToOARRestAPI('POST_job',reqdict,slice_user)
- print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s " %(answer)
- self.db.update('slice',['oar_job_id'], [answer['id']], 'slice_hrn', slice_name)
+ #OAR = OARrestapi()
+ #answer = OAR.POSTRequestToOARRestAPI('POST_job',reqdict,slice_user)
+ #print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s " %(answer)
+ #self.db.update('slice',['oar_job_id'], [answer['id']], 'slice_hrn', slice_name)
return
git://git.onelab.eu / sfa.git / commitdiff