X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fsenslab%2Fslabdriver.py;h=0ff5149d1f2f46eb0880f9849f402e150f351693;hb=8727730a6ca0b289d1d67cc887a6459781201e52;hp=9d860638703176373ee9a63eef6392b88ac87706;hpb=2d8023dbc042230940b802803fcfa1688fbb48c6;p=sfa.git diff --git a/sfa/senslab/slabdriver.py b/sfa/senslab/slabdriver.py index 9d860638..0ff5149d 100644 --- a/sfa/senslab/slabdriver.py +++ b/sfa/senslab/slabdriver.py @@ -1,8 +1,13 @@ +import sys + from sfa.util.faults import MissingSfaInfo from sfa.util.sfalogging import logger 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 from sfa.util.plxrn import slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, hrn_to_pl_login_base @@ -11,8 +16,11 @@ from sfa.util.plxrn import slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicenam # SlabDriver should be really only about talking to the senslab testbed ## thierry : please avoid wildcard imports :) -from sfa.senslab.OARrestapi import * -from sfa.senslab.LDAapi import * +from sfa.senslab.OARrestapi import OARapi, OARrestapi +from sfa.senslab.LDAPapi import LDAPapi +from sfa.senslab.SenslabImportUsers import SenslabImportUsers +from sfa.senslab.parsing import parse_filter +from sfa.senslab.slabpostgres import SlabDB def list_to_dict(recs, key): """ @@ -28,10 +36,10 @@ def list_to_dict(recs, key): # 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 @@ -40,26 +48,133 @@ class SlabDriver (): print >>sys.stderr, "\r\n_____________ SFA SENSLAB DRIVER \r\n" # thierry - just to not break the rest of this code - #self.oar = OARapi() - #self.users = SenslabImportUsers() + + self.oar = OARapi() self.ldap = LDAPapi() + self.users = SenslabImportUsers() self.time_format = "%Y-%m-%d %H:%M:%S" + self.db = SlabDB() #self.logger=sfa_logger() - - - def GetPersons(self, person_filter=None, return_fields=None): + self.cache=None + + + + def create_sliver (self, slice_urn, slice_hrn, creds, rspec_string, users, options): + aggregate = SlabAggregate(self) + slices = SlabSlices(self) + peer = slices.get_peer(slice_hrn) + sfa_peer = slices.get_sfa_peer(slice_hrn) + slice_record=None + if users: + slice_record = users[0].get('slice_record', {}) + + # parse rspec + rspec = RSpec(rspec_string) + requested_attributes = rspec.version.get_slice_attributes() + + # ensure site record exists + site = slices.verify_site(slice_hrn, slice_record, peer, sfa_peer, options=options) + # ensure slice record exists + slice = slices.verify_slice(slice_hrn, slice_record, peer, sfa_peer, options=options) + # ensure person records exists + persons = slices.verify_persons(slice_hrn, slice, users, peer, sfa_peer, options=options) + # ensure slice attributes exists + #slices.verify_slice_attributes(slice, requested_attributes, options=options) + + # add/remove slice from nodes + requested_slivers = [node.get('component_name') for node in rspec.version.get_nodes_with_slivers()] + nodes = slices.verify_slice_nodes(slice, requested_slivers, peer) + + # add/remove links links + #slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes) + + # handle MyPLC peer association. + # only used by plc and ple. + #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 }) + + #check = False + #if person_filter and isinstance(person_filter, dict): + #for k in person_filter.keys(): + #if k in person_list[0].keys(): + #check = True + return_person_list = parse_filter(person_list,person_filter ,'persons', return_fields) - return return_person_list + if return_person_list: + print>>sys.stderr, " \r\n GetPersons person_filter %s return_fields %s return_person_list %s " %(person_filter,return_fields,return_person_list) + return return_person_list def GetNodes(self,node_filter= None, return_fields=None): self.oar.parser.SendRequest("GET_resources_full") node_dict = self.oar.parser.GetNodesFromOARParse() return_node_list = [] - print>>sys.stderr, " \r\n GetNodes node_dict %s" %(node_dict) + if not (node_filter or return_fields): return_node_list = node_dict.values() return return_node_list @@ -67,6 +182,55 @@ class SlabDriver (): return_node_list= parse_filter(node_dict.values(),node_filter ,'node', return_fields) return return_node_list + def GetSites(self, auth, site_filter = None, return_fields=None): + self.oar.parser.SendRequest("GET_resources_full") + site_dict = self.oar.parser.GetSitesFromOARParse() + return_site_list = [] + site = site_dict.values()[0] + if not (site_filter or return_fields): + return_site_list = site_dict.values() + return return_site_list + + return_site_list = parse_filter(site_dict.values(),site_filter ,'site', return_fields) + return return_site_list + + def GetSlices(self,slice_filter = None, return_fields=None): + + return_slice_list =[] + sliceslist = self.db.find('slice',columns = ['slice_hrn', 'record_id_slice','record_id_user']) + print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY GetSlices slices %s" %(sliceslist) + #slicesdict = sliceslist[0] + if not (slice_filter or return_fields): + return_slice_list = sliceslist + return return_slice_list + + return_slice_list = parse_filter(sliceslist, slice_filter,'slice', return_fields) + print >>sys.stderr, " \r\n \r\n SLABDRIVER.PY GetSlices return_slice_list %s" %(return_slice_list) + return return_slice_list + + def testbed_name (self): return "senslab2" + + # 'geni_request_rspec_versions' and 'geni_ad_rspec_versions' are mandatory + def aggregate_version (self): + version_manager = VersionManager() + ad_rspec_versions = [] + request_rspec_versions = [] + for rspec_version in version_manager.versions: + if rspec_version.content_type in ['*', 'ad']: + ad_rspec_versions.append(rspec_version.to_dict()) + if rspec_version.content_type in ['*', 'request']: + request_rspec_versions.append(rspec_version.to_dict()) + return { + 'testbed':self.testbed_name(), + 'geni_request_rspec_versions': request_rspec_versions, + 'geni_ad_rspec_versions': ad_rspec_versions, + } + + + + + + ## # Convert SFA fields to PLC fields for use when registering up updating # registry record in the PLC database @@ -123,171 +287,51 @@ class SlabDriver (): return pl_record - def fill_record_pl_info(self, records): - """ - Fill in the planetlab specific fields of a SFA record. This - involves calling the appropriate PLC method to retrieve the - database record for the object. - - PLC data is filled into the pl_info field of the record. - - @param record: record to fill in field (in/out param) - """ - # get ids by type - #print>>sys.stderr, "\r\n \r\rn \t\t >>>>>>>>>>fill_record_pl_info records %s : "%(records) - node_ids, site_ids, slice_ids = [], [], [] - person_ids, key_ids = [], [] - type_map = {'node': node_ids, 'authority': site_ids, - 'slice': slice_ids, 'user': person_ids} - - for record in records: - for type in type_map: - #print>>sys.stderr, "\r\n \t\t \t fill_record_pl_info : type %s. record['pointer'] %s "%(type,record['pointer']) - if type == record['type']: - type_map[type].append(record['pointer']) - #print>>sys.stderr, "\r\n \t\t \t fill_record_pl_info : records %s... \r\n \t\t \t fill_record_pl_info : type_map %s"%(records,type_map) - # get pl records - nodes, sites, slices, persons, keys = {}, {}, {}, {}, {} - if node_ids: - node_list = self.oar.GetNodes( node_ids) - #print>>sys.stderr, " \r\n \t\t\t BEFORE LIST_TO_DICT_NODES node_ids : %s" %(node_ids) - nodes = list_to_dict(node_list, 'node_id') - if site_ids: - site_list = self.oar.GetSites( site_ids) - sites = list_to_dict(site_list, 'site_id') - #print>>sys.stderr, " \r\n \t\t\t site_ids %s sites : %s" %(site_ids,sites) - if slice_ids: - slice_list = self.users.GetSlices( slice_ids) - slices = list_to_dict(slice_list, 'slice_id') - if person_ids: - #print>>sys.stderr, " \r\n \t\t \t fill_record_pl_info BEFORE GetPersons person_ids: %s" %(person_ids) - person_list = self.users.GetPersons( person_ids) - persons = list_to_dict(person_list, 'person_id') - #print>>sys.stderr, "\r\n fill_record_pl_info persons %s \r\n \t\t person_ids %s " %(persons, person_ids) - for person in persons: - key_ids.extend(persons[person]['key_ids']) - #print>>sys.stderr, "\r\n key_ids %s " %(key_ids) - - pl_records = {'node': nodes, 'authority': sites, - 'slice': slices, 'user': persons} - - if key_ids: - key_list = self.users.GetKeys( key_ids) - keys = list_to_dict(key_list, 'key_id') - # print>>sys.stderr, "\r\n fill_record_pl_info persons %s \r\n \t\t keys %s " %(keys) - # fill record info - for record in records: - # records with pointer==-1 do not have plc info. - # for example, the top level authority records which are - # authorities, but not PL "sites" - if record['pointer'] == -1: - continue - - for type in pl_records: - if record['type'] == type: - if record['pointer'] in pl_records[type]: - record.update(pl_records[type][record['pointer']]) - break - # fill in key info - if record['type'] == 'user': - if 'key_ids' not in record: - #print>>sys.stderr, " NO_KEY_IDS fill_record_pl_info key_ids record: %s" %(record) - logger.info("user record has no 'key_ids' - need to import ?") - else: - pubkeys = [keys[key_id]['key'] for key_id in record['key_ids'] if key_id in keys] - record['keys'] = pubkeys - - #print>>sys.stderr, "\r\n \r\rn \t\t <<<<<<<<<<<<<<<<<< fill_record_pl_info records %s : "%(records) - # fill in record hrns - records = self.fill_record_hrns(records) - - return records - - def fill_record_hrns(self, records): - """ - convert pl ids to hrns - """ - #print>>sys.stderr, "\r\n \r\rn \t\t \t >>>>>>>>>>>>>>>>>>>>>> fill_record_hrns records %s : "%(records) - # get ids - slice_ids, person_ids, site_ids, node_ids = [], [], [], [] - for record in records: - #print>>sys.stderr, "\r\n \r\rn \t\t \t record %s : "%(record) - if 'site_id' in record: - site_ids.append(record['site_id']) - if 'site_ids' in records: - site_ids.extend(record['site_ids']) - if 'person_ids' in record: - person_ids.extend(record['person_ids']) - if 'slice_ids' in record: - slice_ids.extend(record['slice_ids']) - if 'node_ids' in record: - node_ids.extend(record['node_ids']) - - # get pl records - slices, persons, sites, nodes = {}, {}, {}, {} - if site_ids: - site_list = self.oar.GetSites( site_ids, ['site_id', 'login_base']) - sites = list_to_dict(site_list, 'site_id') - #print>>sys.stderr, " \r\n \r\n \t\t ____ site_list %s \r\n \t\t____ sites %s " % (site_list,sites) - if person_ids: - person_list = self.users.GetPersons( person_ids, ['person_id', 'email']) - #print>>sys.stderr, " \r\n \r\n \t\t____ person_lists %s " %(person_list) - persons = list_to_dict(person_list, 'person_id') - if slice_ids: - slice_list = self.users.GetSlices( slice_ids, ['slice_id', 'name']) - slices = list_to_dict(slice_list, 'slice_id') - if node_ids: - node_list = self.oar.GetNodes( node_ids, ['node_id', 'hostname']) - nodes = list_to_dict(node_list, 'node_id') - - # convert ids to hrns - for record in records: + + + + def AddSliceToNodes(self, slice_name, added_nodes, slice_user=None): + print>>sys.stderr, "\r\n \r\n AddSliceToNodes slice_name %s added_nodes %s username %s" %(slice_name,added_nodes,slice_user ) + site_list = [] + nodeid_list =[] + resource = "" + reqdict = {} + reqdict['property'] ="network_address in (" + for node in added_nodes: + #Get the ID of the node : remove the root auth and put the site in a separate list + tmp = node.strip(self.root_auth+".") + l = tmp.split("_") - # get all relevant data - type = record['type'] - pointer = record['pointer'] - auth_hrn = self.hrn - login_base = '' - if pointer == -1: - continue + nodeid= (l[len(l)-1]) + reqdict['property'] += "'"+ nodeid +"', " + nodeid_list.append(nodeid) + site_list.append( l[0] ) + + reqdict['property'] = reqdict['property'][0: len( reqdict['property'])-2] +")" + reqdict['resource'] ="network_address="+ str(len(nodeid_list)) + reqdict['resource']+= ",walltime=" + str(00) + ":" + str(05) + ":" + str(00) + 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) + return + - #print>>sys.stderr, " \r\n \r\n \t\t fill_record_hrns : sites %s \r\n \t\t record %s " %(sites, record) - if 'site_id' in record: - site = sites[record['site_id']] - #print>>sys.stderr, " \r\n \r\n \t\t \t fill_record_hrns : sites %s \r\n \t\t\t site sites[record['site_id']] %s " %(sites,site) - login_base = site['login_base'] - record['site'] = ".".join([auth_hrn, login_base]) - if 'person_ids' in record: - emails = [persons[person_id]['email'] for person_id in record['person_ids'] \ - if person_id in persons] - usernames = [email.split('@')[0] for email in emails] - person_hrns = [".".join([auth_hrn, login_base, username]) for username in usernames] - #print>>sys.stderr, " \r\n \r\n \t\t ____ person_hrns : %s " %(person_hrns) - record['persons'] = person_hrns - if 'slice_ids' in record: - slicenames = [slices[slice_id]['name'] for slice_id in record['slice_ids'] \ - if slice_id in slices] - slice_hrns = [slicename_to_hrn(auth_hrn, slicename) for slicename in slicenames] - record['slices'] = slice_hrns - if 'node_ids' in record: - hostnames = [nodes[node_id]['hostname'] for node_id in record['node_ids'] \ - if node_id in nodes] - node_hrns = [hostname_to_hrn(auth_hrn, login_base, hostname) for hostname in hostnames] - record['nodes'] = node_hrns - if 'site_ids' in record: - login_bases = [sites[site_id]['login_base'] for site_id in record['site_ids'] \ - if site_id in sites] - site_hrns = [".".join([auth_hrn, lbase]) for lbase in login_bases] - record['sites'] = site_hrns - #print>>sys.stderr, "\r\n \r\rn \t\t \t <<<<<<<<<<<<<<<<<<<<<<<< fill_record_hrns records %s : "%(records) - return records + + + def DeleteSliceFromNodes(self, slice_name, deleted_nodes): + return + + def fill_record_sfa_info(self, records): def startswith(prefix, values): return [value for value in values if value.startswith(prefix)] - - SenslabUsers = SenslabImportUsers() + # get person ids person_ids = [] site_ids = [] @@ -304,7 +348,7 @@ class SlabDriver (): site_pis = {} if site_ids: pi_filter = {'|roles': ['pi'], '|site_ids': site_ids} - pi_list = SenslabUsers.GetPersons( pi_filter, ['person_id', 'site_ids']) + pi_list = self.GetPersons( pi_filter, ['person_id', 'site_ids']) #print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___ GetPersons ['person_id', 'site_ids'] pi_ilist %s" %(pi_list) for pi in pi_list: @@ -336,7 +380,7 @@ class SlabDriver (): # get the pl records pl_person_list, pl_persons = [], {} - pl_person_list = SenslabUsers.GetPersons(person_ids, ['person_id', 'roles']) + pl_person_list = self.GetPersons(person_ids, ['person_id', 'roles']) pl_persons = list_to_dict(pl_person_list, 'person_id') #print>>sys.stderr, "\r\n \r\n _fill_record_sfa_info ___ _list %s \r\n \t\t SenslabUsers.GetPersons ['person_id', 'roles'] pl_persons %s \r\n records %s" %(pl_person_list, pl_persons,records) # fill sfa info @@ -397,19 +441,43 @@ class SlabDriver (): #print>>sys.stderr, "\r\n \r\rn \t\t \t <<<<<<<<<<<<<<<<<<<<<<<< fill_record_sfa_info sfa_info %s \r\n record %s : "%(sfa_info,record) record.update(sfa_info) - + + def augment_records_with_testbed_info (self, sfa_records): + return self.fill_record_info (sfa_records) + def fill_record_info(self, records): """ - Given a SFA record, fill in the PLC specific and SFA specific + Given a SFA record, fill in the senslab specific and SFA specific fields in the record. """ - #print >>sys.stderr, "\r\n \t\t fill_record_info %s"%(records) - if not isinstance(records, list): - records = [records] + print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records) + if isinstance(records, list): + records = records[0] #print >>sys.stderr, "\r\n \t\t BEFORE fill_record_pl_info %s" %(records) - self.fill_record_pl_info(records) - #print >>sys.stderr, "\r\n \t\t after fill_record_pl_info %s" %(records) - self.fill_record_sfa_info(records) + + + if records['type'] == 'slice': + + sfatable = SfaTable() + recslice = self.db.find('slice',str(records['hrn'])) + if isinstance(recslice,list) and len(recslice) == 1: + recslice = recslice[0] + recuser = sfatable.find( recslice['record_id_user'], ['hrn']) + + print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info %s" %(recuser) + records['type'] + if isinstance(recuser,list) and len(recuser) == 1: + recuser = recuser[0] + records.update({'PI':[recuser['hrn']], + 'researcher': [recuser['hrn']], + 'name':records['hrn'], 'oar_job_id':recslice['oar_job_id'], + + 'node_ids': [], + 'person_ids':[recslice['record_id_user']]}) + + #self.fill_record_pl_info(records) + ##print >>sys.stderr, "\r\n \t\t after fill_record_pl_info %s" %(records) + #self.fill_record_sfa_info(records) #print >>sys.stderr, "\r\n \t\t after fill_record_sfa_info" def update_membership_list(self, oldRecord, record, listName, addFunc, delFunc): @@ -453,6 +521,7 @@ class SlabDriver (): delFunc(self.plauth, personId, containerId) def update_membership(self, oldRecord, record): + print >>sys.stderr, " \r\n \r\n ***SLABDRIVER.PY update_membership record ", record if record.type == "slice": self.update_membership_list(oldRecord, record, 'researcher', self.users.AddPersonToSlice,