fix bug in get_rspec when trying to get the rspec for a slice that doesnt exist

[sfa.git] / geni / aggregate.py

diff --git a/geni/aggregate.py b/geni/aggregate.py
index 1db8ed1..4b9f8a3 100644 (file)
--- a/geni/aggregate.py
+++ b/geni/aggregate.py
@@ -263,8 +263,12 @@ class Aggregate(GeniServer):
         elif type in ['slice']:
             slicename = hrn_to_pl_slicename(hrn)
             slices = self.shell.GetSlices(self.auth, [slicename])
-            node_ids = slices[0]['node_ids']
-            nodes = self.shell.GetNodes(self.auth, node_ids) 
+            if not slices:
+                nodes = []
+            else:
+                slice = slices[0]     
+                node_ids = slice['node_ids']
+                nodes = self.shell.GetNodes(self.auth, node_ids) 
         
         # Filter out whitelisted nodes
         public_nodes = lambda n: n.has_key('slice_ids_whitelist') and not n['slice_ids_whitelist']
@@ -301,10 +305,11 @@ class Aggregate(GeniServer):
 
         # create the plc dict
         networks = [{'nodes': nodes,
-                     'links': linkspecs, 
                      'name': self.hrn, 
                      'start_time': start_time, 
-                     'duration': duration}] 
+                     'duration': duration}]
+        if type in ['aggregate']:
+            networks[0]['links'] = linkspecs 
         resources = {'networks': networks, 'start_time': start_time, 'duration': duration}
 
         # convert the plc dict to an rspec dict
@@ -352,26 +357,31 @@ class Aggregate(GeniServer):
        
         # Get the slice record from geni
         slice = {}
-        records = self.registry.resolve(self.cred, slice_hrn)
-        if not records:
-            raise RecordNotFound(slice_hrn)
+        records = self.registry.resolve(self.credential, slice_hrn)
             
         for record in records:
             if record.get_type() in ['slice']:
                 slice_info = record.as_dict()
                 slice = slice_info['pl_info']
+        if not slice:
+            raise RecordNotFound(slice_hrn)
+                    
  
         # Make sure slice exists at plc, if it doesnt add it
         slicename = hrn_to_pl_slicename(slice_hrn)
         slices = self.shell.GetSlices(self.auth, [slicename], ['node_ids'])
         if not slices:
-            # if site doesnt exist add it
             parts = slicename.split("_")
             login_base = parts[0]
+            # if site doesnt exist add it
             sites = self.shell.GetSites(self.auth, [login_base]) 
             if not sites:
                 authority = get_authority(slice_hrn)
-                site_record = self.registry.reolve(self.cred, authority)
+                site_records = self.registry.resolve(self.credential, authority)
+                site_record = {}
+                if not site_records:
+                    raise RecordNotFound(authority)
+                site_record = site_records[0]     
                 site_info = site_record.as_dict()
                 site = site_info['pl_info'] 
                 
@@ -381,7 +391,7 @@ class Aggregate(GeniServer):
             else:
                 site = sites[0]
                 
-            self.shell.AddSlice(self.auth, slice_info)
+            self.shell.AddSlice(self.auth, slice)
         
         # get the list of valid slice users from the registry and make 
         # they are added to the slice 
@@ -392,20 +402,30 @@ class Aggregate(GeniServer):
             person_records = self.registry.resolve(self.credential, researcher)
             for record in person_records:
                 if record.get_type() in ['user']:
-                    person_record = person_records[0]
+                    person_record = record
             if not person_record:
                 pass
-            person_dict = person_record.as_dict()['plc_info']
+            person_dict = person_record.as_dict()['pl_info']
             persons = self.shell.GetPersons(self.auth, [person_dict['email']], ['person_id', 'key_ids'])
             
             # Create the person record 
             if not persons:
                 self.shell.AddPerson(self.auth, person_dict)
-            self.shell.AddPersonToSlice(self.auth, person_dict['email'], login_base)
-            # Add this person's public keys
+                key_ids = []
+            else:
+                key_ids = persons[0]['key_ids']
+           
+            self.shell.AddPersonToSlice(self.auth, person_dict['email'], slicename)
+            
+            # Get this users local keys
+            keylist = self.shell.GetKeys(self.auth, key_ids, ['key'])
+            keys = [key['key'] for key in keylist]
+            
+            # add keys that arent already there 
             for personkey in person_dict['keys']:
-                key = {'type': 'ssh', 'key': personkey}      
-                self.shellAddPersonKey(self.auth, person_dict['email'], key)
+                if personkey not in keys:
+                    key = {'key_type': 'ssh', 'key': personkey}      
+                    self.shell.AddPersonKey(self.auth, person_dict['email'], key)
  
         # find out where this slice is currently running
         nodelist = self.shell.GetNodes(self.auth, slice['node_ids'], ['hostname'])