use person_dict as it's the same thing with person_record

[sfa.git] / sfa / plc / slices.py

diff --git a/sfa/plc/slices.py b/sfa/plc/slices.py
index a74687e..21cf41f 100644 (file)
--- a/sfa/plc/slices.py
+++ b/sfa/plc/slices.py
@@ -19,7 +19,7 @@ from sfa.server.registry import Registries
 
 class Slices(SimpleStorage):
 
-    def __init__(self, api, ttl = .5):
+    def __init__(self, api, ttl = .5, caller_cred=None):
         self.api = api
         self.ttl = ttl
         self.threshold = None
@@ -30,6 +30,7 @@ class Slices(SimpleStorage):
         SimpleStorage.__init__(self, self.slices_file)
         self.policy = Policy(self.api)    
         self.load()
+       self.caller_cred=caller_cred
 
 
     def get_peer(self, hrn):
@@ -138,7 +139,7 @@ class Slices(SimpleStorage):
         aggregates = Aggregates(self.api)
         for aggregate in aggregates:
             try:
-                aggregates[aggregate].delete_slice(credential, hrn)
+                aggregates[aggregate].delete_slice(credential, hrn, caller_cred=self.caller_cred)
             except:
                 print >> log, "Error calling list nodes at aggregate %s" % aggregate
                 traceback.print_exc(log)
@@ -168,44 +169,47 @@ class Slices(SimpleStorage):
         peer = self.get_peer(hrn)
 
         spec = Rspec(rspec)
-        # Get the slice record from geni
+        # Get the slice record from sfa
         slice = {}
         slice_record = None
         registries = Registries(self.api)
         registry = registries[self.api.hrn]
         credential = self.api.getCredential()
-        records = registry.resolve(credential, hrn)
-        for record in records:
+        slice_records = registry.resolve(credential, hrn)
+        for record in slice_records:
             if record.get_type() in ['slice']:
                 slice_record = record.as_dict()
         if not slice_record:
-            raise RecordNotFound(hrn)   
-
+            raise RecordNotFound(hrn)  
+
+        # Get the slice's site record
+        authority = get_authority(hrn)
+        site_records = registry.resolve(credential, get_authority(hrn))
+        site = {}
+        for site_record in site_records:
+            if site_record.get_type() in ['authority']:
+                site = site_record.as_dict()
+        if not site:
+            raise RecordNotFound(hrn)
+        remote_site_id = site.pop('site_id')
+            
         # Make sure slice exists at plc, if it doesnt add it
         slicename = hrn_to_pl_slicename(hrn)
-        slices = self.api.plshell.GetSlices(self.api.plauth, [slicename], ['slice_id', 'node_ids'])
+        slices = self.api.plshell.GetSlices(self.api.plauth, [slicename], ['slice_id', 'node_ids', 'site_id'] )
+        parts = slicename.split("_")
+        login_base = parts[0]
+        # if site doesnt exist add it
+        sites = self.api.plshell.GetSites(self.api.plauth, [login_base])
         if not slices:
-            parts = slicename.split("_")
-            login_base = parts[0]
-            # if site doesnt exist add it
-            sites = self.api.plshell.GetSites(self.api.plauth, [login_base])
             if not sites:
-                authority = get_authority(hrn)
-                site_records = registry.resolve(credential, authority)
-                site_record = {}
-                if not site_records:
-                    raise RecordNotFound(authority)
-                site_record = site_records[0]
-                site = site_record.as_dict()
-                
-                 # add the site
-                remote_site_id = site.pop('site_id')
+                # add the site
                 site_id = self.api.plshell.AddSite(self.api.plauth, site)
                 # this belongs to a peer 
                 if peer:
                     self.api.plshell.BindObjectToPeer(self.api.plauth, 'site', site_id, peer, remote_site_id)
             else:
-                site = sites[0]
+                site_id = sites[0]['site_id']
+                remote_site_id = sites[0]['peer_site_id']
             
             # create slice object
             slice_fields = {}
@@ -224,7 +228,9 @@ class Slices(SimpleStorage):
             slice['node_ids'] = []
         else:
             slice = slices[0]
-            slice_id = slice['slice_id']    
+            slice_id = slice['slice_id']
+            site_id = slice['site_id']    
+            remote_site_id = sites[0]['peer_site_id']
         # get the list of valid slice users from the registry and make 
         # they are added to the slice 
         researchers = record.get('researcher', [])
@@ -252,7 +258,7 @@ class Slices(SimpleStorage):
 
                 self.api.plshell.UpdatePerson(self.api.plauth, person_id, {'enabled' : True})
                 if peer:
-                    self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_record['pointer'])
+                    self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
                 key_ids = []
             else:
                 person_id = persons[0]['person_id'] 
@@ -262,16 +268,20 @@ class Slices(SimpleStorage):
             # an error
             if peer:
                 self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'person', person_id, peer)
-            self.api.plshell.AddPersonToSlice(self.api.plauth, person_dict['email'], slicename)   
+                self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'site', site_id,  peer)
+
+            self.api.plshell.AddPersonToSlice(self.api.plauth, person_dict['email'], slicename)
+            self.api.plshell.AddPersonToSite(self.api.plauth, person_dict['email'], site_id)   
             if peer:
-               self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_record['pointer'])
+                self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
+                self.api.plshell.BindObjectToPeer(self.api.plauth, 'site', site_id, peer, remote_site_id) 
 
             # Get this users local keys
             keylist = self.api.plshell.GetKeys(self.api.plauth, key_ids, ['key'])
             keys = [key['key'] for key in keylist]
 
             # add keys that arent already there 
-           key_ids=person_record['key_ids']
+            key_ids=person_dict['key_ids']
             for personkey in person_dict['keys']:
                 if personkey not in keys:
                     key = {'key_type': 'ssh', 'key': personkey}
@@ -279,7 +289,7 @@ class Slices(SimpleStorage):
                         self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'person', person_id, peer)
                     key_id=self.api.plshell.AddPersonKey(self.api.plauth, person_dict['email'], key)
                     if peer:
-                        self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_record['pointer'])
+                        self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer'])
                         self.api.plshell.BindObjectToPeer(self.api.plauth, 'key', key_id, peer, key_ids.pop(0))
 
         # find out where this slice is currently running
@@ -339,9 +349,9 @@ class Slices(SimpleStorage):
             try:
                 # send the whloe rspec to the local aggregate
                 if aggregate in [self.api.hrn]:
-                    aggregates[aggregate].create_slice(credential, hrn, rspec)
+                    aggregates[aggregate].create_slice(credential, hrn, rspec, caller_cred=self.caller_cred)
                 else:
-                    aggregates[aggregate].create_slice(credential, hrn, rspecs[aggregate])
+                    aggregates[aggregate].create_slice(credential, hrn, rspecs[aggregate], caller_cred=self.caller_cred)
             except:
                 print >> log, "Error creating slice %(hrn)s at aggregate %(aggregate)s" % locals()
                 traceback.print_exc()