version_manager = VersionManager()
ad_rspec_versions = []
request_rspec_versions = []
+ cred_types = [{'geni_type': 'geni_sfa', 'geni_version': str(i)} for i in range(4)[-2:]]
for rspec_version in version_manager.versions:
if rspec_version.content_type in ['*', 'ad']:
ad_rspec_versions.append(rspec_version.to_dict())
version_more = {
'interface':'slicemgr',
'sfa': 2,
- 'geni_api': 2,
- 'geni_api_versions': {'2': 'http://%s:%s' % (api.config.SFA_SM_HOST, api.config.SFA_SM_PORT)},
+ 'geni_api': 3,
+ 'geni_api_versions': {'3': 'http://%s:%s' % (api.config.SFA_SM_HOST, api.config.SFA_SM_PORT)},
'hrn' : xrn.get_hrn(),
'urn' : xrn.get_urn(),
'peers': peers,
- 'geni_request_rspec_versions': request_rspec_versions,
- 'geni_ad_rspec_versions': ad_rspec_versions,
+ 'geni_single_allocation': 0, # Accept operations that act on as subset of slivers in a given state.
+ 'geni_allocate': 'geni_many',# Multiple slivers can exist and be incrementally added, including those which connect or overlap in some way.
+ 'geni_credential_types': cred_types,
}
sm_version=version_core(version_more)
# local aggregate if present needs to have localhost resolved
if 'sfa' in version.keys():
forward_options['rspec_version'] = version_manager.get_version('SFA 1').to_dict()
else:
- forward_options['rspec_version'] = version_manager.get_version('ProtoGENI 2').to_dict()
+ forward_options['rspec_version'] = version_manager.get_version('GENI 3').to_dict()
+ forward_options['geni_rspec_version'] = {'type': 'geni', 'version': '3.0'}
rspec = server.ListResources(credential, forward_options)
return {"aggregate": aggregate, "rspec": rspec, "elapsed": time.time()-tStart, "status": "success"}
except Exception, e:
# look in cache first
cached_requested = options.get('cached', True)
- if not xrn and self.cache and cached_request:
+ if not xrn and self.cache and cached_requested:
rspec = self.cache.get(version_string)
if rspec:
api.logger.debug("SliceManager.ListResources returns cached advertisement")
# get the callers hrn
valid_cred = api.auth.checkCredentials(creds, 'listnodes', hrn)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
# attempt to use delegated credential first
cred = api.getDelegatedCredential(creds)
return rspec.toxml()
- def CreateSliver(self, api, xrn, creds, rspec_str, users, options):
+ def Allocate(self, api, xrn, creds, rspec_str, expiration, options):
call_id = options.get('call_id')
if Callids().already_handled(call_id): return ""
version_manager = VersionManager()
- def _CreateSliver(aggregate, server, xrn, credential, rspec, users, options):
+ def _Allocate(aggregate, server, xrn, credential, rspec, options):
tStart = time.time()
try:
# Need to call GetVersion at an aggregate to determine the supported
# rspec type/format beofre calling CreateSliver at an Aggregate.
- server_version = api.get_cached_server_version(server)
- requested_users = users
- if 'sfa' not in server_version and 'geni_api' in server_version:
+ #server_version = api.get_cached_server_version(server)
+ #if 'sfa' not in server_version and 'geni_api' in server_version:
# sfa aggregtes support both sfa and pg rspecs, no need to convert
# if aggregate supports sfa rspecs. otherwise convert to pg rspec
- rspec = RSpec(RSpecConverter.to_pg_rspec(rspec, 'request'))
- filter = {'component_manager_id': server_version['urn']}
- rspec.filter(filter)
- rspec = rspec.toxml()
- requested_users = sfa_to_pg_users_arg(users)
- rspec = server.CreateSliver(xrn, credential, rspec, requested_users, options)
- return {"aggregate": aggregate, "rspec": rspec, "elapsed": time.time()-tStart, "status": "success"}
+ #rspec = RSpec(RSpecConverter.to_pg_rspec(rspec, 'request'))
+ #filter = {'component_manager_id': server_version['urn']}
+ #rspec.filter(filter)
+ #rspec = rspec.toxml()
+ result = server.Allocate(xrn, credential, rspec, options)
+ return {"aggregate": aggregate, "result": result, "elapsed": time.time()-tStart, "status": "success"}
except:
- logger.log_exc('Something wrong in _CreateSliver with URL %s'%server.url)
+ logger.log_exc('Something wrong in _Allocate with URL %s'%server.url)
return {"aggregate": aggregate, "elapsed": time.time()-tStart, "status": "exception", "exc_info": sys.exc_info()}
# Validate the RSpec against PlanetLab's schema --disabled for now
# get the callers hrn
hrn, type = urn_to_hrn(xrn)
valid_cred = api.auth.checkCredentials(creds, 'createsliver', hrn)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
threads = ThreadManager()
for aggregate in api.aggregates:
# prevent infinite loop. Dont send request back to caller
interface = api.aggregates[aggregate]
server = api.server_proxy(interface, cred)
# Just send entire RSpec to each aggregate
- threads.run(_CreateSliver, aggregate, server, xrn, [cred], rspec.toxml(), users, options)
+ threads.run(_Allocate, aggregate, server, xrn, [cred], rspec.toxml(), options)
results = threads.get_results()
manifest_version = version_manager._get_version(rspec.version.type, rspec.version.version, 'manifest')
result_rspec = RSpec(version=manifest_version)
+ geni_urn = None
+ geni_slivers = []
+
+ for result in results:
+ self.add_slicemgr_stat(result_rspec, "Allocate", result["aggregate"], result["elapsed"],
+ result["status"], result.get("exc_info",None))
+ if result["status"]=="success":
+ try:
+ res = result['result']['value']
+ geni_urn = res['geni_urn']
+ result_rspec.version.merge(ReturnValue.get_value(res['geni_rspec']))
+ geni_slivers.extend(res['geni_slivers'])
+ except:
+ api.logger.log_exc("SM.Allocate: Failed to merge aggregate rspec")
+ return {
+ 'geni_urn': geni_urn,
+ 'geni_rspec': result_rspec.toxml(),
+ 'geni_slivers': geni_slivers
+ }
+
+
+ def Provision(self, api, xrn, creds, options):
+ call_id = options.get('call_id')
+ if Callids().already_handled(call_id): return ""
+
+ version_manager = VersionManager()
+ def _Provision(aggregate, server, xrn, credential, options):
+ tStart = time.time()
+ try:
+ # Need to call GetVersion at an aggregate to determine the supported
+ # rspec type/format beofre calling CreateSliver at an Aggregate.
+ server_version = api.get_cached_server_version(server)
+ result = server.Provision(xrn, credential, options)
+ return {"aggregate": aggregate, "result": result, "elapsed": time.time()-tStart, "status": "success"}
+ except:
+ logger.log_exc('Something wrong in _Allocate with URL %s'%server.url)
+ return {"aggregate": aggregate, "elapsed": time.time()-tStart, "status": "exception", "exc_info": sys.exc_info()}
+
+ # attempt to use delegated credential first
+ cred = api.getDelegatedCredential(creds)
+ if not cred:
+ cred = api.getCredential()
+
+ # get the callers hrn
+ valid_cred = api.auth.checkCredentials(creds, 'createsliver', xrn)[0]
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
+ threads = ThreadManager()
+ for aggregate in api.aggregates:
+ # prevent infinite loop. Dont send request back to caller
+ # unless the caller is the aggregate's SM
+ if caller_hrn == aggregate and aggregate != api.hrn:
+ continue
+ interface = api.aggregates[aggregate]
+ server = api.server_proxy(interface, cred)
+ # Just send entire RSpec to each aggregate
+ threads.run(_Provision, aggregate, server, xrn, [cred], options)
+
+ results = threads.get_results()
+ manifest_version = version_manager._get_version('GENI', '3', 'manifest')
+ result_rspec = RSpec(version=manifest_version)
+ geni_slivers = []
+ geni_urn = None
for result in results:
- self.add_slicemgr_stat(result_rspec, "CreateSliver", result["aggregate"], result["elapsed"],
+ self.add_slicemgr_stat(result_rspec, "Provision", result["aggregate"], result["elapsed"],
result["status"], result.get("exc_info",None))
if result["status"]=="success":
try:
- result_rspec.version.merge(ReturnValue.get_value(result["rspec"]))
+ res = result['result']['value']
+ geni_urn = res['geni_urn']
+ result_rspec.version.merge(ReturnValue.get_value(res['geni_rspec']))
+ geni_slivers.extend(res['geni_slivers'])
except:
- api.logger.log_exc("SM.CreateSliver: Failed to merge aggregate rspec")
- return result_rspec.toxml()
+ api.logger.log_exc("SM.Provision: Failed to merge aggregate rspec")
+ return {
+ 'geni_urn': geni_urn,
+ 'geni_rspec': result_rspec.toxml(),
+ 'geni_slivers': geni_slivers
+ }
+
+
- def RenewSliver(self, api, xrn, creds, expiration_time, options):
+ def Renew(self, api, xrn, creds, expiration_time, options):
call_id = options.get('call_id')
if Callids().already_handled(call_id): return True
- def _RenewSliver(server, xrn, creds, expiration_time, options):
- return server.RenewSliver(xrn, creds, expiration_time, options)
-
- (hrn, type) = urn_to_hrn(xrn)
+ def _Renew(aggregate, server, xrn, creds, expiration_time, options):
+ try:
+ result=server.Renew(xrn, creds, expiration_time, options)
+ if type(result)!=dict:
+ result = {'code': {'geni_code': 0}, 'value': result}
+ result['aggregate'] = aggregate
+ return result
+ except:
+ logger.log_exc('Something wrong in _RenewSliver with URL %s'%server.url)
+ return {'aggregate': aggregate, 'exc_info': traceback.format_exc(),
+ 'code': {'geni_code': -1},
+ 'value': False, 'output': ""}
+
# get the callers hrn
- valid_cred = api.auth.checkCredentials(creds, 'renewsliver', hrn)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
-
+ valid_cred = api.auth.checkCredentials(creds, 'renewsliver', xrn)[0]
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
+
# attempt to use delegated credential first
cred = api.getDelegatedCredential(creds)
if not cred:
- cred = api.getCredential()
+ cred = api.getCredential(minimumExpiration=31*86400)
threads = ThreadManager()
for aggregate in api.aggregates:
# prevent infinite loop. Dont send request back to caller
continue
interface = api.aggregates[aggregate]
server = api.server_proxy(interface, cred)
- threads.run(_RenewSliver, server, xrn, [cred], expiration_time, options)
- # 'and' the results
- results = [ReturnValue.get_value(result) for result in threads.get_results()]
- return reduce (lambda x,y: x and y, results , True)
-
- def DeleteSliver(self, api, xrn, creds, options):
- call_id = options.get('call_id')
+ threads.run(_RenewSliver, aggregate, server, xrn, [cred], expiration_time, options)
+
+ results = threads.get_results()
+
+ geni_code = 0
+ geni_output = ",".join([x.get('output',"") for x in results])
+ geni_value = reduce (lambda x,y: x and y, [result.get('value',False) for result in results], True)
+ for agg_result in results:
+ agg_geni_code = agg_result['code'].get('geni_code',0)
+ if agg_geni_code:
+ geni_code = agg_geni_code
+
+ results = {'aggregates': results, 'code': {'geni_code': geni_code}, 'value': geni_value, 'output': geni_output}
+
+ return results
+
+ def Delete(self, api, xrn, creds, options):
+ call_id = options.get('call_id')
if Callids().already_handled(call_id): return ""
- def _DeleteSliver(server, xrn, creds, options):
- return server.DeleteSliver(xrn, creds, options)
+ def _Delete(server, xrn, creds, options):
+ return server.Delete(xrn, creds, options)
(hrn, type) = urn_to_hrn(xrn)
# get the callers hrn
valid_cred = api.auth.checkCredentials(creds, 'deletesliver', hrn)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
-
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
+
# attempt to use delegated credential first
cred = api.getDelegatedCredential(creds)
if not cred:
# first draft at a merging SliverStatus
- def SliverStatus(self, api, slice_xrn, creds, options):
- def _SliverStatus(server, xrn, creds, options):
- return server.SliverStatus(xrn, creds, options)
+ def Status(self, api, slice_xrn, creds, options):
+ def _Status(server, xrn, creds, options):
+ return server.Status(xrn, creds, options)
call_id = options.get('call_id')
if Callids().already_handled(call_id): return {}
for aggregate in api.aggregates:
interface = api.aggregates[aggregate]
server = api.server_proxy(interface, cred)
- threads.run (_SliverStatus, server, slice_xrn, [cred], options)
+ threads.run (_Status, server, slice_xrn, [cred], options)
results = [ReturnValue.get_value(result) for result in threads.get_results()]
# get rid of any void result - e.g. when call_id was hit, where by convention we return {}
- results = [ result for result in results if result and result['geni_resources']]
+ results = [ result for result in results if result and result['geni_slivers']]
# do not try to combine if there's no result
if not results : return {}
# otherwise let's merge stuff
- overall = {}
-
- # mmh, it is expected that all results carry the same urn
- overall['geni_urn'] = results[0]['geni_urn']
- overall['pl_login'] = results[0]['pl_login']
- # append all geni_resources
- overall['geni_resources'] = \
- reduce (lambda x,y: x+y, [ result['geni_resources'] for result in results] , [])
- overall['status'] = 'unknown'
- if overall['geni_resources']:
- overall['status'] = 'ready'
-
- return overall
-
+ geni_slivers = []
+ geni_urn = None
+ for result in results:
+ try:
+ geni_urn = result['geni_urn']
+ geni_slivers.extend(result['result']['geni_slivers'])
+ except:
+ api.logger.log_exc("SM.Provision: Failed to merge aggregate rspec")
+ return {
+ 'geni_urn': geni_urn,
+ 'geni_slivers': geni_slivers
+ }
+
+
+ def Describe(self, api, xrns, creds, options):
+ def _Describe(server, xrn, creds, options):
+ return server.Describe(xrn, creds, options)
+
+ call_id = options.get('call_id')
+ if Callids().already_handled(call_id): return {}
+ # attempt to use delegated credential first
+ cred = api.getDelegatedCredential(creds)
+ if not cred:
+ cred = api.getCredential()
+ threads = ThreadManager()
+ for aggregate in api.aggregates:
+ interface = api.aggregates[aggregate]
+ server = api.server_proxy(interface, cred)
+ threads.run (_Describe, server, slice_xrn, [cred], options)
+ results = [ReturnValue.get_value(result) for result in threads.get_results()]
+
+ # get rid of any void result - e.g. when call_id was hit, where by convention we return {}
+ results = [ result for result in results if result and result.get('geni_urn')]
+
+ # do not try to combine if there's no result
+ if not results : return {}
+
+ # otherwise let's merge stuff
+ manifest_version = version_manager._get_version('GENI', '3', 'manifest')
+ result_rspec = RSpec(version=manifest_version)
+ geni_slivers = []
+ geni_urn = None
+ for result in results:
+ try:
+ geni_urn = result['geni_urn']
+ result_rspec.version.merge(ReturnValue.get_value(result['result']['geni_rspec']))
+ geni_slivers.extend(result['result']['geni_slivers'])
+ except:
+ api.logger.log_exc("SM.Provision: Failed to merge aggregate rspec")
+ return {
+ 'geni_urn': geni_urn,
+ 'geni_rspec': result_rspec.toxml(),
+ 'geni_slivers': geni_slivers
+ }
+
def ListSlices(self, api, creds, options):
call_id = options.get('call_id')
if Callids().already_handled(call_id): return []
# get the callers hrn
valid_cred = api.auth.checkCredentials(creds, 'listslices', None)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
# attempt to use delegated credential first
cred= api.getDelegatedCredential(creds)
# get the callers hrn
valid_cred = api.auth.checkCredentials(creds, 'getticket', slice_hrn)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
# attempt to use delegated credential first
cred = api.getDelegatedCredential(creds)
# get the callers hrn
valid_cred = api.auth.checkCredentials(creds, 'startslice', hrn)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
# attempt to use delegated credential first
cred = api.getDelegatedCredential(creds)
threads.get_results()
return 1
- def stop_slice(self, api, xrn, creds):
- hrn, type = urn_to_hrn(xrn)
-
+ def Shutdown(self, api, xrn, creds, options={}):
+ xrn = Xrn(xrn)
# get the callers hrn
- valid_cred = api.auth.checkCredentials(creds, 'stopslice', hrn)[0]
- caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
+ valid_cred = api.auth.checkCredentials(creds, 'stopslice', xrn.hrn)[0]
+ caller_hrn = Credential(cred=valid_cred).get_gid_caller().get_hrn()
# attempt to use delegated credential first
cred = api.getDelegatedCredential(creds)
continue
interface = api.aggregates[aggregate]
server = api.server_proxy(interface, cred)
- threads.run(server.Stop, xrn, cred)
+ threads.run(server.Shutdown, xrn.urn, cred)
threads.get_results()
return 1
- def reset_slice(self, api, xrn):
- """
- Not implemented
- """
- return 1
-
- def shutdown(self, api, xrn, creds):
- """
- Not implemented
- """
- return 1
-
- def status(self, api, xrn, creds):
- """
- Not implemented
- """
- return 1
-
git://git.onelab.eu / sfa.git / blobdiff