+
+
+ def delete_sliver (self, slice_urn, slice_hrn, creds, options):
+
+ slices = self.GetSlices(slice_filter= slice_hrn, filter_type = '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)
+ 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)
+ options.update({'origin_hrn':origin_hrn})
+ print>>sys.stderr, " \r\n \r\n \t SLABDRIVER get_rspec options %s" %(options)
+ 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 list_slices (self, creds, options):
+ # look in cache first
+ #if self.cache:
+ #slices = self.cache.get('slices')
+ #if slices:
+ #logger.debug("PlDriver.list_slices returns from cache")
+ #return slices
+
+ # get data from db
+ print>>sys.stderr, " \r\n \t\t SLABDRIVER.PY list_slices"
+ slices = self.GetSlices()
+ slice_hrns = [slicename_to_hrn(self.hrn, slice['slice_hrn']) for slice in slices]
+ slice_urns = [hrn_to_urn(slice_hrn, 'slice') for slice_hrn in slice_hrns]
+
+ # cache the result
+ #if self.cache:
+ #logger.debug ("SlabDriver.list_slices stores value in cache")
+ #self.cache.add('slices', slice_urns)
+
+ return slice_urns
+
+ #No site or node register supported
+ def register (self, sfa_record, hrn, pub_key):
+ type = sfa_record['type']
+ slab_record = self.sfa_fields_to_slab_fields(type, hrn, sfa_record)
+
+ #if type == 'authority':
+ #sites = self.shell.GetSites([slab_record['login_base']])
+ #if not sites:
+ #pointer = self.shell.AddSite(slab_record)
+ #else:
+ #pointer = sites[0]['site_id']
+
+ if type == 'slice':
+ acceptable_fields=['url', 'instantiation', 'name', 'description']
+ for key in slab_record.keys():
+ if key not in acceptable_fields:
+ slab_record.pop(key)
+ print>>sys.stderr, " \r\n \t\t SLABDRIVER.PY register"
+ slices = self.GetSlices(slice_filter =slab_record['hrn'], filter_type = 'slice_hrn')
+ if not slices:
+ pointer = self.AddSlice(slab_record)
+ else:
+ pointer = slices[0]['slice_id']
+
+ elif type == 'user':
+ persons = self.GetPersons([sfa_record['hrn']])
+ if not persons:
+ pointer = self.AddPerson(dict(sfa_record))
+ #add in LDAP
+ else:
+ pointer = persons[0]['person_id']
+
+ #Does this make sense to senslab ?
+ #if 'enabled' in sfa_record and sfa_record['enabled']:
+ #self.UpdatePerson(pointer, {'enabled': sfa_record['enabled']})
+
+ # add this person to the site only if she is being added for the first
+ # time by sfa and doesont already exist in plc
+ if not persons or not persons[0]['site_ids']:
+ login_base = get_leaf(sfa_record['authority'])
+ self.AddPersonToSite(pointer, login_base)
+
+ # What roles should this user have?
+ self.AddRoleToPerson('user', pointer)
+ # Add the user's key
+ if pub_key:
+ self.AddPersonKey(pointer, {'key_type' : 'ssh', 'key' : pub_key})
+
+ #No node adding outside OAR
+ #elif type == 'node':
+ #login_base = hrn_to_slab_login_base(sfa_record['authority'])
+ #nodes = self.GetNodes([slab_record['hostname']])
+ #if not nodes:
+ #pointer = self.AddNode(login_base, slab_record)
+ #else:
+ #pointer = nodes[0]['node_id']
+
+ return pointer
+
+ #No site or node record update allowed
+ def update (self, old_sfa_record, new_sfa_record, hrn, new_key):
+ pointer = old_sfa_record['pointer']
+ type = old_sfa_record['type']
+
+ # new_key implemented for users only
+ if new_key and type not in [ 'user' ]:
+ raise UnknownSfaType(type)
+
+ #if (type == "authority"):
+ #self.shell.UpdateSite(pointer, new_sfa_record)
+
+ if type == "slice":
+ slab_record=self.sfa_fields_to_slab_fields(type, hrn, new_sfa_record)
+ if 'name' in slab_record:
+ slab_record.pop('name')
+ self.UpdateSlice(pointer, slab_record)
+
+ elif type == "user":
+ update_fields = {}
+ all_fields = new_sfa_record
+ for key in all_fields.keys():
+ if key in ['first_name', 'last_name', 'title', 'email',
+ 'password', 'phone', 'url', 'bio', 'accepted_aup',
+ 'enabled']:
+ update_fields[key] = all_fields[key]
+ self.UpdatePerson(pointer, update_fields)
+
+ if new_key:
+ # must check this key against the previous one if it exists
+ persons = self.GetPersons([pointer], ['key_ids'])
+ person = persons[0]
+ keys = person['key_ids']
+ keys = self.GetKeys(person['key_ids'])
+
+ # Delete all stale keys
+ key_exists = False
+ for key in keys:
+ if new_key != key['key']:
+ self.DeleteKey(key['key_id'])
+ else:
+ key_exists = True
+ if not key_exists:
+ self.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key})
+
+ #elif type == "node":
+ #self.UpdateNode(pointer, new_sfa_record)
+
+ return True
+
+
+ def remove (self, sfa_record):
+ type=sfa_record['type']
+ hrn=sfa_record['hrn']
+ record_id= sfa_record['record_id']
+ if type == 'user':
+ username = hrn.split(".")[len(hrn.split(".")) -1]
+ #get user in ldap
+ persons = self.GetPersons(username)
+ # only delete this person if he has site ids. if he doesnt, it probably means
+ # he was just removed from a site, not actually deleted
+ if persons and persons[0]['site_ids']:
+ self.DeletePerson(username)
+ elif type == 'slice':
+ if self.GetSlices(slice_filter = hrn, filter_type = 'slice_hrn'):
+ self.DeleteSlice(hrn)
+
+ #elif type == 'authority':
+ #if self.GetSites(pointer):
+ #self.DeleteSite(pointer)
+
+ return True
+
+ def GetPeers (self,auth = None, peer_filter=None, return_fields=None):
+
+ existing_records = {}
+ existing_hrns_by_types= {}
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers auth = %s, peer_filter %s, return_field %s " %(auth , peer_filter, return_fields)
+ all_records = dbsession.query(RegRecord).filter(RegRecord.type.like('%authority%')).all()
+ for record in all_records:
+ existing_records[record.hrn] = record
+ if record.type not in existing_hrns_by_types:
+ existing_hrns_by_types[record.type] = [record.hrn]
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers \t NOT IN existing_hrns_by_types %s " %( existing_hrns_by_types)
+ else:
+
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers \t INNN type %s hrn %s " %( record.type,record.hrn )
+ existing_hrns_by_types.update({record.type:(existing_hrns_by_types[record.type].append(record.hrn))})
+
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers existing_hrns_by_types %s " %( existing_hrns_by_types)
+ records_list= []
+
+ try:
+ for hrn in existing_hrns_by_types['authority+sa']:
+ records_list.append(existing_records[hrn])
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers records_list %s " %(records_list)
+
+ except:
+ pass
+
+ if not peer_filter and not return_fields:
+ return records_list
+ return_records = parse_filter(records_list,peer_filter, 'peers', return_fields)
+
+ return return_records
+
+