X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fplanetlab%2Fpldriver.py;h=d16b23a666186e317fa70ca8e83975875551acd6;hb=82d0355774b73966cbe0c838c611808dfd2f1c7a;hp=248bab16b87b3dc6a5d96a1e0e4205802251f3ac;hpb=fc2a216091686513bcd89006108b3b43a0527be8;p=sfa.git

diff --git a/sfa/planetlab/pldriver.py b/sfa/planetlab/pldriver.py
index 248bab16..d16b23a6 100644
--- a/sfa/planetlab/pldriver.py
+++ b/sfa/planetlab/pldriver.py
@@ -1,7 +1,8 @@
 import datetime
 #
 from sfa.util.faults import MissingSfaInfo, UnknownSfaType, \
-    RecordNotFound, SfaNotImplemented, SliverDoesNotExist, SearchFailed
+    RecordNotFound, SfaNotImplemented, SliverDoesNotExist, SearchFailed, \
+    UnsupportedOperation, Forbidden 
 from sfa.util.sfalogging import logger
 from sfa.util.defaultdict import defaultdict
 from sfa.util.sfatime import utcparse, datetime_to_string, datetime_to_epoch
@@ -9,8 +10,8 @@ from sfa.util.xrn import Xrn, hrn_to_urn, get_leaf
 from sfa.util.cache import Cache
 
 # one would think the driver should not need to mess with the SFA db, but..
-from sfa.storage.alchemy import dbsession
 from sfa.storage.model import RegRecord, SliverAllocation
+from sfa.trust.credential import Credential
 
 # used to be used in get_ticket
 #from sfa.trust.sfaticket import SfaTicket
@@ -20,10 +21,9 @@ from sfa.rspecs.rspec import RSpec
 # the driver interface, mostly provides default behaviours
 from sfa.managers.driver import Driver
 from sfa.planetlab.plshell import PlShell
-import sfa.planetlab.peers as peers
 from sfa.planetlab.plaggregate import PlAggregate
 from sfa.planetlab.plslices import PlSlices
-from sfa.planetlab.plxrn import PlXrn, slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, xrn_to_hostname
+from sfa.planetlab.plxrn import PlXrn, slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, top_auth, hash_loginbase
 
 
 def list_to_dict(recs, key):
@@ -43,15 +43,67 @@ class PlDriver (Driver):
     # the cache instance is a class member so it survives across incoming requests
     cache = None
 
-    def __init__ (self, config):
-        Driver.__init__ (self, config)
+    def __init__ (self, api):
+        Driver.__init__ (self, api)
+        config=api.config
         self.shell = PlShell (config)
         self.cache=None
         if config.SFA_AGGREGATE_CACHING:
             if PlDriver.cache is None:
                 PlDriver.cache = Cache()
             self.cache = PlDriver.cache
+
+    def sliver_to_slice_xrn(self, xrn):
+        sliver_id_parts = Xrn(xrn).get_sliver_id_parts()
+        filter = {'peer_id': None}
+        try:
+            filter['slice_id'] = int(sliver_id_parts[0])
+        except ValueError:
+            filter['name'] = sliver_id_parts[0] 
+        slices = self.shell.GetSlices(filter,['hrn'])
+        if not slices:
+            raise Forbidden("Unable to locate slice record for sliver:  %s" % xrn)
+        slice = slices[0]
+        slice_xrn = slice['hrn']
+        return slice_xrn 
  
+    def check_sliver_credentials(self, creds, urns):
+        # build list of cred object hrns
+        slice_cred_names = []
+        for cred in creds:
+            slice_cred_hrn = Credential(cred=cred).get_gid_object().get_hrn() 
+            top_auth_hrn = top_auth(slice_cred_hrn)
+            site_hrn = '.'.join(slice_cred_hrn.split('.')[:-1])
+            slice_part = slice_cred_hrn.split('.')[-1]
+            if top_auth_hrn == self.hrn:
+                login_base = slice_cred_hrn.split('.')[-2][:12]
+            else:
+                login_base = hash_loginbase(site_hrn)
+
+            slicename = '_'.join([login_base, slice_part])   
+            slice_cred_names.append(slicename) 
+
+        # look up slice name of slivers listed in urns arg
+        slice_ids = []
+        for urn in urns:
+            sliver_id_parts = Xrn(xrn=urn).get_sliver_id_parts()
+            try:
+                slice_ids.append(int(sliver_id_parts[0]))
+            except ValueError: 
+                pass
+
+        if not slice_ids:
+             raise Forbidden("sliver urn not provided")
+
+        slices = self.shell.GetSlices(slice_ids)
+        sliver_names = [slice['name'] for slice in slices]
+
+        # make sure we have a credential for every specified sliver ierd
+        for sliver_name in sliver_names:
+            if sliver_name not in slice_cred_names:
+                msg = "Valid credential not found for target: %s" % sliver_name
+                raise Forbidden(msg)
+
     ########################################
     ########## registry oriented
     ########################################
@@ -65,12 +117,13 @@ class PlDriver (Driver):
         pl_record = self.sfa_fields_to_pl_fields(type, hrn, sfa_record)
 
         if type == 'authority':
-            sites = self.shell.GetSites([pl_record['login_base']])
+            sites = self.shell.GetSites({'peer_id': None, 'login_base': pl_record['login_base']})
             if not sites:
                 # xxx when a site gets registered through SFA we need to set its max_slices
                 if 'max_slices' not in pl_record:
                     pl_record['max_slices']=2
                 pointer = self.shell.AddSite(pl_record)
+                self.shell.SetSiteHrn(int(pointer), hrn)
             else:
                 pointer = sites[0]['site_id']
 
@@ -79,28 +132,35 @@ class PlDriver (Driver):
             for key in pl_record.keys():
                 if key not in acceptable_fields:
                     pl_record.pop(key)
-            slices = self.shell.GetSlices([pl_record['name']])
+            slices = self.shell.GetSlices({'peer_id': None, 'name': pl_record['name']})
             if not slices:
+                 if not pl_record.get('url', None) or not pl_record.get('description', None):
+                     pl_record['url'] = hrn
+                     pl_record['description'] = hrn
+
                  pointer = self.shell.AddSlice(pl_record)
+                 self.shell.SetSliceHrn(int(pointer), hrn)
             else:
                  pointer = slices[0]['slice_id']
 
         elif type == 'user':
-            persons = self.shell.GetPersons({'email':sfa_record['email']})
+            persons = self.shell.GetPersons({'peer_id': None, 'email': sfa_record['email']})
             if not persons:
                 for key in ['first_name','last_name']:
                     if key not in sfa_record: sfa_record[key]='*from*sfa*'
-                pointer = self.shell.AddPerson(dict(sfa_record))
+                # AddPerson does not allow everything to be set
+                can_add = ['first_name', 'last_name', 'title','email', 'password', 'phone', 'url', 'bio']
+                add_person_dict=dict ( [ (k,sfa_record[k]) for k in sfa_record if k in can_add ] )
+                pointer = self.shell.AddPerson(add_person_dict)
+                self.shell.SetPersonHrn(int(pointer), hrn)
             else:
                 pointer = persons[0]['person_id']
     
-            if 'enabled' in sfa_record and sfa_record['enabled']:
-                self.shell.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.shell.AddPersonToSite(pointer, login_base)
+            # enable the person's account
+            self.shell.UpdatePerson(pointer, {'enabled': True})
+            # add this person to the site
+            login_base = get_leaf(sfa_record['authority'])
+            self.shell.AddPersonToSite(pointer, login_base)
     
             # What roles should this user have?
             roles=[]
@@ -117,10 +177,11 @@ class PlDriver (Driver):
                 self.shell.AddPersonKey(pointer, {'key_type' : 'ssh', 'key' : pub_key})
 
         elif type == 'node':
-            login_base = PlXrn(xrn=sfa_record['authority'],type='node').pl_login_base()
-            nodes = self.shell.GetNodes([pl_record['hostname']])
+            login_base = PlXrn(xrn=sfa_record['authority'],type='authority').pl_login_base()
+            nodes = self.shell.GetNodes({'peer_id': None, 'hostname': pl_record['hostname']})
             if not nodes:
                 pointer = self.shell.AddNode(login_base, pl_record)
+                self.shell.SetNodeHrn(int(pointer), hrn)
             else:
                 pointer = nodes[0]['node_id']
     
@@ -131,6 +192,7 @@ class PlDriver (Driver):
     def update (self, old_sfa_record, new_sfa_record, hrn, new_key):
         pointer = old_sfa_record['pointer']
         type = old_sfa_record['type']
+        new_key_pointer = None
 
         # new_key implemented for users only
         if new_key and type not in [ 'user' ]:
@@ -138,12 +200,14 @@ class PlDriver (Driver):
 
         if (type == "authority"):
             self.shell.UpdateSite(pointer, new_sfa_record)
+            self.shell.SetSiteHrn(pointer, hrn)
     
         elif type == "slice":
             pl_record=self.sfa_fields_to_pl_fields(type, hrn, new_sfa_record)
             if 'name' in pl_record:
                 pl_record.pop('name')
                 self.shell.UpdateSlice(pointer, pl_record)
+                self.shell.SetSliceHrn(pointer, hrn)
     
         elif type == "user":
             # SMBAKER: UpdatePerson only allows a limited set of fields to be
@@ -161,28 +225,28 @@ class PlDriver (Driver):
             if 'email' in update_fields and not update_fields['email']:
                 del update_fields['email']
             self.shell.UpdatePerson(pointer, update_fields)
+            self.shell.SetPersonHrn(pointer, hrn)
     
             if new_key:
                 # must check this key against the previous one if it exists
-                persons = self.shell.GetPersons([pointer], ['key_ids'])
+                persons = self.shell.GetPersons({'peer_id': None, 'person_id': pointer}, ['key_ids'])
                 person = persons[0]
                 keys = person['key_ids']
                 keys = self.shell.GetKeys(person['key_ids'])
                 
-                # Delete all stale keys
                 key_exists = False
                 for key in keys:
-                    if new_key != key['key']:
-                        self.shell.DeleteKey(key['key_id'])
-                    else:
+                    if new_key == key['key']:
                         key_exists = True
+                        new_key_pointer = key['key_id']
+                        break
                 if not key_exists:
-                    self.shell.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key})
+                    new_key_pointer = self.shell.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key})
     
         elif type == "node":
             self.shell.UpdateNode(pointer, new_sfa_record)
 
-        return True
+        return (pointer, new_key_pointer)
         
 
     ##########
@@ -190,19 +254,19 @@ class PlDriver (Driver):
         type=sfa_record['type']
         pointer=sfa_record['pointer']
         if type == 'user':
-            persons = self.shell.GetPersons(pointer)
+            persons = self.shell.GetPersons({'peer_id': None, 'person_id': pointer})
             # 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.shell.DeletePerson(pointer)
         elif type == 'slice':
-            if self.shell.GetSlices(pointer):
+            if self.shell.GetSlices({'peer_id': None, 'slice_id': pointer}):
                 self.shell.DeleteSlice(pointer)
         elif type == 'node':
-            if self.shell.GetNodes(pointer):
+            if self.shell.GetNodes({'peer_id': None, 'node_id': pointer}):
                 self.shell.DeleteNode(pointer)
         elif type == 'authority':
-            if self.shell.GetSites(pointer):
+            if self.shell.GetSites({'peer_id': None, 'site_id': pointer}):
                 self.shell.DeleteSite(pointer)
 
         return True
@@ -295,16 +359,16 @@ class PlDriver (Driver):
         # get pl records
         nodes, sites, slices, persons, keys = {}, {}, {}, {}, {}
         if node_ids:
-            node_list = self.shell.GetNodes(node_ids)
+            node_list = self.shell.GetNodes({'peer_id': None, 'node_id': node_ids})
             nodes = list_to_dict(node_list, 'node_id')
         if site_ids:
-            site_list = self.shell.GetSites(site_ids)
+            site_list = self.shell.GetSites({'peer_id': None, 'site_id': site_ids})
             sites = list_to_dict(site_list, 'site_id')
         if slice_ids:
-            slice_list = self.shell.GetSlices(slice_ids)
+            slice_list = self.shell.GetSlices({'peer_id': None, 'slice_id': slice_ids})
             slices = list_to_dict(slice_list, 'slice_id')
         if person_ids:
-            person_list = self.shell.GetPersons(person_ids)
+            person_list = self.shell.GetPersons({'peer_id': None, 'person_id': person_ids})
             persons = list_to_dict(person_list, 'person_id')
             for person in persons:
                 key_ids.extend(persons[person]['key_ids'])
@@ -361,16 +425,16 @@ class PlDriver (Driver):
         # get pl records
         slices, persons, sites, nodes = {}, {}, {}, {}
         if site_ids:
-            site_list = self.shell.GetSites(site_ids, ['site_id', 'login_base'])
+            site_list = self.shell.GetSites({'peer_id': None, 'site_id': site_ids}, ['site_id', 'login_base'])
             sites = list_to_dict(site_list, 'site_id')
         if person_ids:
-            person_list = self.shell.GetPersons(person_ids, ['person_id', 'email'])
+            person_list = self.shell.GetPersons({'peer_id': None, 'person_id': person_ids}, ['person_id', 'email'])
             persons = list_to_dict(person_list, 'person_id')
         if slice_ids:
-            slice_list = self.shell.GetSlices(slice_ids, ['slice_id', 'name'])
+            slice_list = self.shell.GetSlices({'peer_id': None, 'slice_id': slice_ids}, ['slice_id', 'name'])
             slices = list_to_dict(slice_list, 'slice_id')       
         if node_ids:
-            node_list = self.shell.GetNodes(node_ids, ['node_id', 'hostname'])
+            node_list = self.shell.GetNodes({'peer_id': None, 'node_id': node_ids}, ['node_id', 'hostname'])
             nodes = list_to_dict(node_list, 'node_id')
        
         # convert ids to hrns
@@ -434,7 +498,7 @@ class PlDriver (Driver):
         # and store them in a dictionary keyed on site_id 
         site_pis = {}
         if site_ids:
-            pi_filter = {'|roles': ['pi'], '|site_ids': site_ids} 
+            pi_filter = {'peer_id': None, '|roles': ['pi'], '|site_ids': site_ids} 
             pi_list = self.shell.GetPersons(pi_filter, ['person_id', 'site_ids'])
             for pi in pi_list:
                 # we will need the pi's hrns also
@@ -454,7 +518,7 @@ class PlDriver (Driver):
         
         # get the registry records
         person_list, persons = [], {}
-        person_list = dbsession.query (RegRecord).filter(RegRecord.pointer.in_(person_ids))
+        person_list = self.api.dbsession().query (RegRecord).filter(RegRecord.pointer.in_(person_ids))
         # create a hrns keyed on the sfa record's pointer.
         # Its possible for multiple records to have the same pointer so
         # the dict's value will be a list of hrns.
@@ -545,7 +609,7 @@ class PlDriver (Driver):
         elif subject_type == 'authority' and target_type == 'user' and relation_name == 'pi':
             # due to the plcapi limitations this means essentially adding pi role to all people in the list
             # it's tricky to remove any pi role here, although it might be desirable
-            persons = self.shell.GetPersons (target_ids)
+            persons = self.shell.GetPersons ({'peer_id': None, 'person_id': target_ids})
             for person in persons: 
                 if 'pi' not in person['roles']:
                     self.shell.AddRoleToPerson('pi',person['person_id'])
@@ -563,28 +627,34 @@ class PlDriver (Driver):
         return {}
 
     # first 2 args are None in case of resource discovery
-    def list_resources (self, version=None, options={}):
+    def list_resources (self, version=None, options=None):
+        if options is None: options={}
         aggregate = PlAggregate(self)
         rspec =  aggregate.list_resources(version=version, options=options)
         return rspec
 
-    def describe(self, urns, version, options={}, allocation_status=None):
+    def describe(self, urns, version, options=None):
+        if options is None: options={}
         aggregate = PlAggregate(self)
         return aggregate.describe(urns, version=version, options=options)
     
-    def status (self, urns, options={}):
+    def status (self, urns, options=None):
+        if options is None: options={}
         aggregate = PlAggregate(self)
-        desc =  aggregate.describe(urns)
-        return desc['geni_slivers']
+        desc =  aggregate.describe(urns, version='GENI 3')
+        status = {'geni_urn': desc['geni_urn'],
+                  'geni_slivers': desc['geni_slivers']}
+        return status
 
-    def allocate (self, urn, rspec_string, options={}):
+    def allocate (self, urn, rspec_string, expiration, options=None):
+        if options is None: options={}
         xrn = Xrn(urn)
         aggregate = PlAggregate(self)
         slices = PlSlices(self)
-        peer = slices.get_peer(xrn.get_hrn())
         sfa_peer = slices.get_sfa_peer(xrn.get_hrn())
         slice_record=None    
         users = options.get('geni_users', [])
+
         if users:
             slice_record = users[0].get('slice_record', {})
     
@@ -593,164 +663,154 @@ class PlDriver (Driver):
         requested_attributes = rspec.version.get_slice_attributes()
         
         # ensure site record exists
-        site = slices.verify_site(xrn.hrn, slice_record, peer, sfa_peer, options=options)
+        site = slices.verify_site(xrn.hrn, slice_record, sfa_peer, options=options)
         # ensure slice record exists
-        slice = slices.verify_slice(xrn.hrn, slice_record, peer, sfa_peer, options=options)
+        slice = slices.verify_slice(xrn.hrn, slice_record, sfa_peer, expiration=expiration, options=options)
         # ensure person records exists
-        persons = slices.verify_persons(xrn.hrn, slice, users, peer, sfa_peer, options=options)
+        persons = slices.verify_persons(xrn.hrn, slice, users, sfa_peer, options=options)
         # ensure slice attributes exists
         slices.verify_slice_attributes(slice, requested_attributes, options=options)
-        
+       
         # add/remove slice from nodes
-        requested_slivers = []
-        for node in rspec.version.get_nodes_with_slivers():
-            hostname = None
-            if node.get('component_name'):
-                hostname = node.get('component_name').strip()
-            elif node.get('component_id'):
-                hostname = xrn_to_hostname(node.get('component_id').strip())
-            if hostname:
-                requested_slivers.append(hostname)
-        nodes = slices.verify_slice_nodes(slice, requested_slivers, peer)
-
-        # update all sliver allocation states setting then to geni_allocated   
-        sliver_state_updated = {}
-        for node in nodes:
-            sliver_hrn = '%s.%s-%s' % (self.hrn, slice['slice_id'], node['node_id'])
-            sliver_id = Xrn(sliver_hrn, type='sliver').urn
-            sliver_state_updated[sliver_id] = False 
-
-        constraint = SliverAllocation.sliver_id.in_(sliver_state_updated.keys())
-        cur_sliver_allocations = dbsession.query(SliverAllocation).filter(constraint)
-        for sliver_allocation in cur_sliver_allocations:
-            sliver_allocation.allocation_state = 'geni_allocated'
-            sliver_state_updated[sliver_allocation.sliver_id] = True
-        dbsession.commit()
-
-        # Some states may not have been updated becuase no sliver allocation state record 
-        # exists for the sliver. Insert new allocation records for these slivers and set 
-        # it to geni_allocated.
-        for (sliver_id, state_updated) in sliver_state_updated.items():
-            if state_updated == False:
-                record = SliverAllocation(sliver_id=sliver_id, allocation_state='geni_allocated')
-                dbsession.add(record)
-        dbsession.commit()  
-   
+        request_nodes = rspec.version.get_nodes_with_slivers()
+        nodes = slices.verify_slice_nodes(urn, slice, request_nodes)
+         
         # add/remove links links 
         slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
 
         # add/remove leases
-        requested_leases = []
-        kept_leases = []
-        for lease in rspec.version.get_leases():
-            requested_lease = {}
-            if not lease.get('lease_id'):
-               requested_lease['hostname'] = xrn_to_hostname(lease.get('component_id').strip())
-               requested_lease['start_time'] = lease.get('start_time')
-               requested_lease['duration'] = lease.get('duration')
-            else:
-               kept_leases.append(int(lease['lease_id']))
-            if requested_lease.get('hostname'):
-                requested_leases.append(requested_lease)
-
-        leases = slices.verify_slice_leases(slice, requested_leases, kept_leases, peer)
-        # handle MyPLC peer association.
-        # only used by plc and ple.
-        slices.handle_peer(site, slice, persons, peer)
-        
+        rspec_requested_leases = rspec.version.get_leases()
+        leases = slices.verify_slice_leases(slice, rspec_requested_leases)
+
         return aggregate.describe([xrn.get_urn()], version=rspec.version)
 
-    def provision(self, urns, options={}):
-        # update sliver allocation states and set them to geni_provisioned
+    def provision(self, urns, options=None):
+        if options is None: options={}
+        # update users
+        slices = PlSlices(self)
         aggregate = PlAggregate(self)
         slivers = aggregate.get_slivers(urns)
-        sliver_ids = [sliver['sliver_id'] for sliver in slivers]
-        constraint = SliverAllocation.sliver_id.in_(sliver_ids)
-        cur_sliver_allocations = dbsession.query(SliverAllocation).filter(constraint)
-        for sliver_allocation in cur_sliver_allocations:
-            sliver_allocation.allocation_state = 'geni_provisioned'
-        dbsession.commit()
-     
-        return self.describe(urns, None, options=options)
-
-    def delete(self, urns, options={}):
-
+        if not slivers:
+            sliver_id_parts = Xrn(urns[0]).get_sliver_id_parts()
+            # allow to be called with an empty rspec, meaning flush reservations
+            if sliver_id_parts:
+                filter = {}
+                try:
+                    filter['slice_id'] = int(sliver_id_parts[0])
+                except ValueError:
+                    filter['name'] = sliver_id_parts[0]
+                slices = self.shell.GetSlices(filter,['hrn'])
+                if not slices:
+                    raise Forbidden("Unable to locate slice record for sliver:  %s" % xrn)
+                slice = slices[0]
+                slice_urn = hrn_to_urn(slice['hrn'], type='slice')
+                urns = [slice_urn]          
+        else:    
+            slice_id = slivers[0]['slice_id']
+            slice_hrn = self.shell.GetSliceHrn(slice_id)
+            slice = self.shell.GetSlices({'slice_id': slice_id})[0]
+            slice['hrn'] = slice_hrn
+            sfa_peer = slices.get_sfa_peer(slice['hrn'])
+            users = options.get('geni_users', [])
+            persons = slices.verify_persons(slice['hrn'], slice, users, sfa_peer, options=options)
+            # update sliver allocation states and set them to geni_provisioned
+            sliver_ids = [sliver['sliver_id'] for sliver in slivers]
+            dbsession=self.api.dbsession()
+            SliverAllocation.set_allocations(sliver_ids, 'geni_provisioned',dbsession)
+
+        version_manager = VersionManager()
+        rspec_version = version_manager.get_version(options['geni_rspec_version']) 
+        return self.describe(urns, rspec_version, options=options)
+
+    def delete(self, urns, options=None):
+        if options is None: options={}
+        # collect sliver ids so we can update sliver allocation states after
+        # we remove the slivers.
         aggregate = PlAggregate(self)
         slivers = aggregate.get_slivers(urns)
-        slice_id = slivers[0]['slice_id'] 
-        node_ids = []
-        sliver_ids = []
-        for sliver in slivers:
-            node_ids.append(sliver['node_id'])
-            sliver_ids.append(sliver['sliver_id']) 
-
-        # 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
-        slice_hrn = PlXrn(auth=self.hrn, slicename=slivers[0]['name']).get_hrn()     
-        peer = peers.get_peer(self, slice_hrn)
-        try:
-            if peer:
-                self.shell.UnBindObjectFromPeer('slice', slice_id, peer)
- 
-            self.shell.DeleteSliceFromNodes(slice_id, node_ids)
- 
-            # update slivera allocation states
-            constraint = SliverAllocation.sliver_id.in_(sliver_ids)
-            cur_sliver_allocations = dbsession.query(SliverAllocation).filter(constraint)
-            for sliver_allocation in cur_sliver_allocations:
-                dbsession.delete(sliver_allocation)
-            dbsession.commit()
-        finally:
-            if peer:
-                self.shell.BindObjectToPeer('slice', slice_id, peer, slice['peer_slice_id'])
+        if slivers:
+            slice_id = slivers[0]['slice_id'] 
+            slice_name = slivers[0]['name']
+            node_ids = []
+            sliver_ids = []
+            for sliver in slivers:
+                node_ids.append(sliver['node_id'])
+                sliver_ids.append(sliver['sliver_id']) 
+
+            # leases
+            leases = self.shell.GetLeases({'name': slice_name, 'node_id': node_ids})
+            leases_ids = [lease['lease_id'] for lease in leases ]
+
+            slice_hrn = self.shell.GetSliceHrn(int(slice_id))
+            try:
+                self.shell.DeleteSliceFromNodes(slice_id, node_ids)
+                if len(leases_ids) > 0:
+                    self.shell.DeleteLeases(leases_ids)
+     
+                # delete sliver allocation states
+                dbsession=self.api.dbsession()
+                SliverAllocation.delete_allocations(sliver_ids,dbsession)
+            finally:
+                pass
 
         # prepare return struct
         geni_slivers = []
-        for node_id in node_ids:
-            sliver_hrn = '%s.%s-%s' % (self.hrn, slice_id, node_id)
+        for sliver in slivers:
             geni_slivers.append(
-                {'geni_sliver_urn': Xrn(sliver_hrn, type='sliver').urn,
+                {'geni_sliver_urn': sliver['sliver_id'],
                  'geni_allocation_status': 'geni_unallocated',
-                 'geni_expires': datetime_to_string(utcparse(slivers[0]['expires']))})  
+                 'geni_expires': datetime_to_string(utcparse(sliver['expires']))})  
         return geni_slivers
-    
-    def renew (self, urns, expiration_time, options={}):
-        # we can only renew slices, not individual slivers. ignore sliver
-        # ids in the urn 
-        names = []
-        for urn in urns:
-            xrn = PlXrn(xrn=urn, type='slice')
-            names.append(xrn.pl_slicename())
-        slices = self.shell.GetSlices(names, ['slice_id'])
-        if not slices:
+
+    def renew (self, urns, expiration_time, options=None):
+        if options is None: options={}
+        aggregate = PlAggregate(self)
+        slivers = aggregate.get_slivers(urns)
+        if not slivers:
             raise SearchFailed(urns)
-        slice = slices[0]
+        slice = slivers[0]
         requested_time = utcparse(expiration_time)
         record = {'expires': int(datetime_to_epoch(requested_time))}
-        try:
-            self.shell.UpdateSlice(slice['slice_id'], record)
-            return True
-        except:
-            return False
+        self.shell.UpdateSlice(slice['slice_id'], record)
+        description = self.describe(urns, 'GENI 3', options)
+        return description['geni_slivers']
+            
 
-    def perform_operational_action (self, urns, action, options={}):
+    def perform_operational_action (self, urns, action, options=None):
+        if options is None: options={}
         # MyPLC doesn't support operational actions. Lets pretend like it
         # supports start, but reject everything else.
         action = action.lower()
-        if action == 'geni_start':
-            pass
-        else:
+        if action not in ['geni_start']:
             raise UnsupportedOperation(action)
-        description = self.describe(urns, None, options)
-        return description['geni_slivers']
+
+        # fault if sliver is not full allocated (operational status is geni_pending_allocation)
+        description = self.describe(urns, 'GENI 3', options)
+        for sliver in description['geni_slivers']:
+            if sliver['geni_operational_status'] == 'geni_pending_allocation':
+                raise UnsupportedOperation(action, "Sliver must be fully allocated (operational status is not geni_pending_allocation)")
+        #
+        # Perform Operational Action Here
+        #
+
+        geni_slivers = self.describe(urns, 'GENI 3', options)['geni_slivers']
+        return geni_slivers
 
     # set the 'enabled' tag to 0
-    def shutdown (self, xrn, options={}):
-        xrn = PlXrn(xrn=xrn, type='slice')
-        slicename = xrn.pl_slicename()
-        slices = self.shell.GetSlices({'name': slicename}, ['slice_id'])
+    def shutdown (self, xrn, options=None):
+        if options is None: options={}
+        hrn, _ = urn_to_hrn(xrn)
+        top_auth_hrn = top_auth(hrn)
+        site_hrn = '.'.join(hrn.split('.')[:-1])
+        slice_part = hrn.split('.')[-1]
+        if top_auth_hrn == self.hrn:
+            login_base = slice_hrn.split('.')[-2][:12]
+        else:
+            login_base = hash_loginbase(site_hrn)
+
+        slicename = '_'.join([login_base, slice_part])
+
+        slices = self.shell.GetSlices({'peer_id': None, 'name': slicename}, ['slice_id'])
         if not slices:
             raise RecordNotFound(slice_hrn)
         slice_id = slices[0]['slice_id']