sfa/dummy/dummyslices.py

   1 from types import StringTypes
   2 from collections import defaultdict
   3
   4 from sfa.util.sfatime import utcparse, datetime_to_epoch
   5 from sfa.util.sfalogging import logger
   6 from sfa.util.xrn import Xrn, get_leaf, get_authority, urn_to_hrn
   7
   8 from sfa.rspecs.rspec import RSpec
   9
  10 from sfa.dummy.dummyxrn import DummyXrn, hrn_to_dummy_slicename
  11
  12 MAXINT =  2L**31-1
  13
  14 class DummySlices:
  15
  16
  17     def __init__(self, driver):
  18         self.driver = driver
  19
  20     def get_slivers(self, xrn, node=None):
  21         hrn, type = urn_to_hrn(xrn)
  22
  23         slice_name = hrn_to_dummy_slicename(hrn)
  24
  25         slices = self.driver.shell.GetSlices({'slice_name': slice_name})
  26         slice = slices[0]
  27         # Build up list of users and slice attributes
  28         user_ids = slice['user_ids']
  29         # Get user information
  30         all_users_list = self.driver.shell.GetUsers({'user_id':user_ids})
  31         all_users = {}
  32         for user in all_users_list:
  33             all_users[user['user_id']] = user
  34
  35         # Build up list of keys
  36         all_keys = set()
  37         for user in all_users_list:
  38             all_keys.extend(user['keys'])
  39
  40         slivers = []
  41         for slice in slices:
  42             keys = all_keys
  43             # XXX Sanity check; though technically this should be a system invariant
  44             # checked with an assertion
  45             if slice['expires'] > MAXINT:  slice['expires']= MAXINT
  46
  47             slivers.append({
  48                 'hrn': hrn,
  49                 'name': slice['name'],
  50                 'slice_id': slice['slice_id'],
  51                 'expires': slice['expires'],
  52                 'keys': keys,
  53             })
  54
  55         return slivers
  56
  57     def get_sfa_peer(self, xrn):
  58         hrn, type = urn_to_hrn(xrn)
  59
  60         # return the authority for this hrn or None if we are the authority
  61         sfa_peer = None
  62         slice_authority = get_authority(hrn)
  63         site_authority = get_authority(slice_authority)
  64
  65         if site_authority != self.driver.hrn:
  66             sfa_peer = site_authority
  67
  68         return sfa_peer
  69
  70
  71     def verify_slice_nodes(self, slice, requested_slivers):
  72         if 'node_ids' not in slice.keys():
  73             slice['node_ids']=[]
  74         nodes = self.driver.shell.GetNodes({'node_ids': slice['node_ids']})
  75         current_slivers = [node['node_id'] for node in nodes]
  76
  77         # remove nodes not in rspec
  78         deleted_nodes = list(set(current_slivers).difference(requested_slivers))
  79
  80         # add nodes from rspec
  81         added_nodes = list(set(requested_slivers).difference(current_slivers))
  82
  83         try:
  84             self.driver.shell.AddSliceToNodes({'slice_id': slice['slice_id'], 'node_ids': added_nodes})
  85             self.driver.shell.DeleteSliceFromNodes({'slice_id': slice['slice_id'], 'node_ids': deleted_nodes})
  86
  87         except:
  88             logger.log_exc('Failed to add/remove slice from nodes')
  89         return nodes
  90
  91
  92
  93     def verify_slice(self, slice_hrn, slice_record, sfa_peer, options={}):
  94         slicename = hrn_to_dummy_slicename(slice_hrn)
  95         parts = slicename.split("_")
  96         login_base = parts[0]
  97         slices = self.driver.shell.GetSlices({'slice_name': slicename})
  98         if not slices:
  99             slice = {'slice_name': slicename}
 100             # add the slice
 101             slice['slice_id'] = self.driver.shell.AddSlice(slice)
 102             slice['node_ids'] = []
 103             slice['user_ids'] = []
 104         else:
 105             slice = slices[0]
 106             if slice_record.get('expires'):
 107                 requested_expires = int(datetime_to_epoch(utcparse(slice_record['expires'])))
 108                 if requested_expires and slice['expires'] != requested_expires:
 109                     self.driver.shell.UpdateSlice( {'slice_id': slice['slice_id'], 'fields':{'expires' : requested_expires}})
 110
 111         return slice
 112
 113     def verify_users(self, slice_hrn, slice_record, users, sfa_peer, options={}):
 114         users_by_email = {}
 115         users_dict = {}
 116         users_by_site = {}
 117         for user in users:
 118             user['urn'] = user['urn'].lower()
 119             hrn, type = urn_to_hrn(user['urn'])
 120             username = get_leaf(hrn)
 121             login_base = DummyXrn(xrn=user['urn']).dummy_login_base()
 122             user['username'] = username
 123             user['site'] = login_base
 124
 125             if 'email' in user:
 126                 user['email'] = user['email'].lower()
 127                 users_by_email[user['email']] = user
 128                 users_dict[user['email']] = user
 129             else:
 130                 users_by_site[user['site']].append(user)
 131
 132         # start building a list of existing users
 133         existing_user_ids = []
 134         existing_user_ids_filter = []
 135         if users_by_email:
 136             existing_user_ids_filter.extend(users_by_email.keys())
 137         if users_by_site:
 138             for login_base in users_by_site:
 139                 users = users_by_site[login_base]
 140                 for user in users:
 141                     existing_user_ids_filter.append(user['username']+'@geni.net')
 142         if existing_user_ids_filter:
 143             # get existing users by email
 144             existing_users = self.driver.shell.GetPersons({'email': existing_user_ids_filter},
 145                                                         ['person_id', 'key_ids', 'email'])
 146             existing_user_ids.extend([user['email'] for user in existing_users])
 147
 148         if users_by_site:
 149             # get a list of user sites (based on requeste user urns
 150             site_list = self.driver.shell.GetSites(users_by_site.keys(), \
 151                 ['site_id', 'login_base', 'person_ids'])
 152             # get all existing users at these sites
 153             sites = {}
 154             site_user_ids = []
 155             for site in site_list:
 156                 sites[site['site_id']] = site
 157                 site_user_ids.extend(site['person_ids'])
 158
 159             existing_site_persons_list = self.driver.shell.GetPersons(site_user_ids,
 160                                                                     ['person_id', 'key_ids', 'email', 'site_ids'])
 161
 162             # all requested users are either existing users or new (added) users
 163             for login_base in users_by_site:
 164                 requested_site_users = users_by_site[login_base]
 165                 for requested_user in requested_site_users:
 166                     user_found = False
 167                     for existing_user in existing_site_persons_list:
 168                         for site_id in existing_user['site_ids']:
 169                             if site_id in sites:
 170                                 site = sites[site_id]
 171                                 if login_base == site['login_base'] and \
 172                                    existing_user['email'].startswith(requested_user['username']+'@'):
 173                                     existing_user_ids.append(existing_user['email'])
 174                                     requested_user['email'] = existing_user['email']
 175                                     users_dict[existing_user['email']] = requested_user
 176                                     user_found = True
 177                                     break
 178                         if user_found:
 179                             break
 180
 181                     if user_found == False:
 182                         fake_email = requested_user['username'] + '@geni.net'
 183                         requested_user['email'] = fake_email
 184                         users_dict[fake_email] = requested_user
 185
 186         # requested slice users
 187         requested_user_ids = users_dict.keys()
 188         # existing slice users
 189         existing_slice_users_filter = {'person_id': slice_record.get('person_ids', [])}
 190         existing_slice_users = self.driver.shell.GetPersons(existing_slice_users_filter,
 191                                                           ['person_id', 'key_ids', 'email'])
 192         existing_slice_user_ids = [user['email'] for user in existing_slice_users]
 193
 194         # users to be added, removed or updated
 195         added_user_ids = set(requested_user_ids).difference(existing_user_ids)
 196         added_slice_user_ids = set(requested_user_ids).difference(existing_slice_user_ids)
 197         removed_user_ids = set(existing_slice_user_ids).difference(requested_user_ids)
 198         updated_user_ids = set(existing_slice_user_ids).intersection(requested_user_ids)
 199
 200         # Remove stale users (only if we are not appending).
 201         # Append by default.
 202         append = options.get('append', True)
 203         if append == False:
 204             for removed_user_id in removed_user_ids:
 205                 self.driver.shell.DeletePersonFromSlice(removed_user_id, slice_record['name'])
 206         # update_existing users
 207         updated_users_list = [user for user in users_dict.values() if user['email'] in \
 208           updated_user_ids]
 209         self.verify_keys(existing_slice_users, updated_users_list, options)
 210
 211         added_persons = []
 212         # add new users
 213         for added_user_id in added_user_ids:
 214             added_user = users_dict[added_user_id]
 215             hrn, type = urn_to_hrn(added_user['urn'])
 216             person = {
 217                 'first_name': added_user.get('first_name', hrn),
 218                 'last_name': added_user.get('last_name', hrn),
 219                 'email': added_user_id,
 220                 'peer_person_id': None,
 221                 'keys': [],
 222                 'key_ids': added_user.get('key_ids', []),
 223             }
 224             person['person_id'] = self.driver.shell.AddPerson(person)
 225             added_persons.append(person)
 226
 227             # enable the account
 228             self.driver.shell.UpdatePerson(person['person_id'], {'enabled': True})
 229
 230             # add person to site
 231             self.driver.shell.AddPersonToSite(added_user_id, added_user['site'])
 232
 233             for key_string in added_user.get('keys', []):
 234                 key = {'key':key_string, 'key_type':'ssh'}
 235                 key['key_id'] = self.driver.shell.AddPersonKey(person['person_id'], key)
 236                 person['keys'].append(key)
 237
 238             # add the registry record
 239 #            if sfa_peer:
 240 #                peer_dict = {'type': 'user', 'hrn': hrn, 'peer_authority': sfa_peer, \
 241 #                    'pointer': person['person_id']}
 242 #                self.registry.register_peer_object(self.credential, peer_dict)
 243
 244         for added_slice_user_id in added_slice_user_ids.union(added_user_ids):
 245             # add person to the slice
 246             self.driver.shell.AddPersonToSlice(added_slice_user_id, slice_record['name'])
 247             # if this is a peer record then it should already be bound to a peer.
 248             # no need to return worry about it getting bound later
 249
 250         return added_persons
 251
 252
 253     def verify_keys(self, old_users, new_users, options={}):
 254         # existing keys
 255         existing_keys = []
 256         for user in old_users:
 257              existing_keys.append(user['keys'])
 258         userdict = {}
 259         for user in old_users:
 260             userdict[user['email']] = user
 261
 262         # add new keys
 263         requested_keys = []
 264         updated_users = []
 265         for user in new_users:
 266             user_keys = user.get('keys', [])
 267             updated_users.append(user)
 268             for key_string in user_keys:
 269                 requested_keys.append(key_string)
 270                 if key_string not in existing_keys:
 271                     key = key_string
 272                     try:
 273                         self.driver.shell.AddUserKey({'user_id': user['user_id'], 'key':key})
 274
 275                     except:
 276                         pass
 277         # remove old keys (only if we are not appending)
 278         append = options.get('append', True)
 279         if append == False:
 280             removed_keys = set(existing_keys).difference(requested_keys)
 281             for key in removed_keys:
 282                  try:
 283                      self.driver.shell.DeleteKey({'key': key})
 284                  except:
 285                      pass
 286
 287