sfa/nitos/nitosslices.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.nitos.nitosxrn import NitosXrn, hrn_to_nitos_slicename, xrn_to_hostname, xrn_to_channel
  11
  12 MAXINT =  2L**31-1
  13
  14 class NitosSlices:
  15
  16     def __init__(self, driver):
  17         self.driver = driver
  18
  19
  20     def get_sfa_peer(self, xrn):
  21         hrn, type = urn_to_hrn(xrn)
  22
  23         # return the authority for this hrn or None if we are the authority
  24         sfa_peer = None
  25         slice_authority = get_authority(hrn)
  26         site_authority = get_authority(slice_authority)
  27
  28         if site_authority != self.driver.hrn:
  29             sfa_peer = site_authority
  30
  31         return sfa_peer
  32
  33     def verify_slice_leases_nodes(self, slice, rspec_requested_nodes):
  34         nodes = self.driver.shell.getNodes({}, [])
  35
  36         requested_nodes = []
  37         for node in rspec_requested_nodes:
  38              requested_node = {}
  39              nitos_nodes = []
  40              nitos_nodes.extend(nodes)
  41              slice_name = hrn_to_nitos_slicename(node['slice_id'])
  42              if slice_name != slice['slice_name']:
  43                  continue
  44              hostname = xrn_to_hostname(node['component_id'])
  45              nitos_node = self.driver.filter_nitos_results(nitos_nodes, {'hostname': hostname})
  46              if not nitos_node:
  47                  continue
  48              nitos_node = nitos_node[0]
  49              # fill the requested node with nitos ids
  50              requested_node['slice_id'] = slice['slice_id']
  51              requested_node['node_id'] = nitos_node['node_id']
  52              requested_node['start_time'] = node['start_time']
  53              requested_node['end_time'] = str(int(node['duration']) * int(self.driver.testbedInfo['grain']) + int(node['start_time']))
  54              requested_nodes.append(requested_node)
  55
  56         # get actual nodes reservation data for the slice
  57         reserved_nodes = self.driver.filter_nitos_results(self.driver.shell.getReservedNodes({}, []), {'slice_id': slice['slice_id']})
  58
  59         reserved_nodes_by_id = {}
  60         for node in reserved_nodes:
  61              reserved_nodes_by_id[node['reservation_id']] = {'slice_id': node['slice_id'], \
  62                                       'node_id': node['node_id'], 'start_time': node['start_time'], \
  63                                       'end_time': node['end_time']}
  64
  65         added_nodes = []
  66         kept_nodes_id = []
  67         deleted_nodes_id = []
  68         for reservation_id in reserved_nodes_by_id:
  69              if reserved_nodes_by_id[reservation_id] not in requested_nodes:
  70                  deleted_nodes_id.append(reservation_id)
  71              else:
  72                  kept_nodes_id.append(reservation_id)
  73                  requested_nodes.remove(reserved_nodes_by_id[reservation_id])
  74         added_nodes = requested_nodes
  75
  76
  77         try:
  78             deleted=self.driver.shell.releaseNodes({'reservation_ids': deleted_nodes_id})
  79             for node in added_nodes:
  80                 added=self.driver.shell.reserveNodes({'slice_id': slice['slice_id'], 'start_time': node['start_time'], 'end_time': node['end_time'], 'nodes': [node['node_id']]})
  81
  82         except:
  83             logger.log_exc('Failed to add/remove slice leases nodes')
  84
  85         return added_nodes
  86
  87
  88     def verify_slice_leases_channels(self, slice, rspec_requested_channels):
  89         channels = self.driver.shell.getChannels({}, [])
  90
  91         requested_channels = []
  92         for channel in rspec_requested_channels:
  93              requested_channel = {}
  94              nitos_channels = []
  95              nitos_channels.extend(channels)
  96              slice_name = hrn_to_nitos_slicename(channel['slice_id'])
  97              if slice_name != slice['slice_name']:
  98                  continue
  99              channel_num = xrn_to_channel(channel['component_id'])
 100              nitos_channel = self.driver.filter_nitos_results(nitos_channels, {'channel': channel_num})[0]
 101              # fill the requested channel with nitos ids
 102              requested_channel['slice_id'] = slice['slice_id']
 103              requested_channel['channel_id'] = nitos_channel['channel_id']
 104              requested_channel['start_time'] = channel['start_time']
 105              requested_channel['end_time'] = str(int(channel['duration']) * int(self.driver.testbedInfo['grain']) + int(channel['start_time']))
 106              requested_channels.append(requested_channel)
 107
 108         # get actual channel reservation data for the slice
 109         reserved_channels = self.driver.filter_nitos_results(self.driver.shell.getReservedChannels(), {'slice_id': slice['slice_id']})
 110
 111         reserved_channels_by_id = {}
 112         for channel in reserved_channels:
 113              reserved_channels_by_id[channel['reservation_id']] = {'slice_id': channel['slice_id'], \
 114                                       'channel_id': channel['channel_id'], 'start_time': channel['start_time'], \
 115                                       'end_time': channel['end_time']}
 116
 117         added_channels = []
 118         kept_channels_id = []
 119         deleted_channels_id = []
 120         for reservation_id in reserved_channels_by_id:
 121              if reserved_channels_by_id[reservation_id] not in requested_channels:
 122                  deleted_channels_id.append(reservation_id)
 123              else:
 124                  kept_channels_id.append(reservation_id)
 125                  requested_channels.remove(reserved_channels_by_id[reservation_id])
 126         added_channels = requested_channels
 127
 128
 129         try:
 130             deleted=self.driver.shell.releaseChannels({'reservation_ids': deleted_channels_id})
 131             for channel in added_channels:
 132                 added=self.driver.shell.reserveChannels({'slice_id': slice['slice_id'], 'start_time': channel['start_time'], 'end_time': channel['end_time'], 'channels': [channel['channel_id']]})
 133
 134         except:
 135             logger.log_exc('Failed to add/remove slice leases channels')
 136
 137         return added_channels
 138
 139
 140     def free_egre_key(self):
 141         used = set()
 142         for tag in self.driver.shell.GetSliceTags({'tagname': 'egre_key'}):
 143                 used.add(int(tag['value']))
 144
 145         for i in range(1, 256):
 146             if i not in used:
 147                 key = i
 148                 break
 149         else:
 150             raise KeyError("No more EGRE keys available")
 151
 152         return str(key)
 153
 154
 155
 156     def verify_slice(self, slice_hrn, slice_record, sfa_peer, options=None):
 157         if options is None: options={}
 158         slicename = hrn_to_nitos_slicename(slice_hrn)
 159         slices = self.driver.shell.getSlices({}, [])
 160         slices = self.driver.filter_nitos_results(slices, {'slice_name': slicename})
 161         if not slices:
 162             slice = {'slice_name': slicename}
 163             # add the slice
 164             slice['slice_id'] = self.driver.shell.addSlice(slice)
 165             slice['node_ids'] = []
 166             slice['user_ids'] = []
 167         else:
 168             slice = slices[0]
 169
 170         return slice
 171
 172     def verify_users(self, slice_hrn, slice_record, users, sfa_peer, options=None):
 173         if options is None: options={}
 174         # get slice info
 175         slicename = hrn_to_nitos_slicename(slice_hrn)
 176         slices = self.driver.shell.getSlices({}, [])
 177         slice = self.driver.filter_nitos_results(slices, {'slice_name': slicename})[0]
 178         added_users = []
 179         #get users info
 180         users_info = []
 181         for user in users:
 182              user_urn = user['urn']
 183              user_hrn, type = urn_to_hrn(user_urn)
 184              username = str(user_hrn).split('.')[-1]
 185              email = user['email']
 186              # look for the user according to his username, email...
 187              nitos_users = self.driver.filter_nitos_results(self.driver.shell.getUsers(), {'username': username})
 188              if not nitos_users:
 189                  nitos_users = self.driver.filter_nitos_results(self.driver.shell.getUsers(), {'email': email})
 190
 191              if not nitos_users:
 192                  # create the user
 193                  user_id = self.driver.shell.addUser({'username': email.split('@')[0], 'email': email})
 194                  added_users.append(user_id)
 195                  # add user keys
 196                  for key in user['keys']:
 197                       self.driver.shell.addUserKey({'user_id': user_id, 'key': key, 'slice_id': slice['slice_id']})
 198                  # add the user to the slice
 199                  self.driver.shell.addUserToSlice({'slice_id': slice['slice_id'], 'user_id': user_id})
 200              else:
 201                  # check if the users are in the slice
 202                  for user in nitos_users:
 203                       if not user['user_id'] in slice['user_ids']:
 204                           self.driver.shell.addUserToSlice({'slice_id': slice['slice_id'], 'user_id': user['user_id']})
 205
 206         return added_users
 207
 208
 209     def verify_keys(self, persons, users, options=None):
 210         if options is None: options={}
 211         # existing keys
 212         key_ids = []
 213         for person in persons:
 214             key_ids.extend(person['key_ids'])
 215         keylist = self.driver.shell.GetKeys(key_ids, ['key_id', 'key'])
 216         keydict = {}
 217         for key in keylist:
 218             keydict[key['key']] = key['key_id']
 219         existing_keys = keydict.keys()
 220         persondict = {}
 221         for person in persons:
 222             persondict[person['email']] = person
 223
 224         # add new keys
 225         requested_keys = []
 226         updated_persons = []
 227         for user in users:
 228             user_keys = user.get('keys', [])
 229             updated_persons.append(user)
 230             for key_string in user_keys:
 231                 requested_keys.append(key_string)
 232                 if key_string not in existing_keys:
 233                     key = {'key': key_string, 'key_type': 'ssh'}
 234                     try:
 235                         if peer:
 236                             person = persondict[user['email']]
 237                             self.driver.shell.UnBindObjectFromPeer('person', person['person_id'], peer['shortname'])
 238                         key['key_id'] = self.driver.shell.AddPersonKey(user['email'], key)
 239                         if peer:
 240                             key_index = user_keys.index(key['key'])
 241                             remote_key_id = user['key_ids'][key_index]
 242                             self.driver.shell.BindObjectToPeer('key', key['key_id'], peer['shortname'], remote_key_id)
 243
 244                     finally:
 245                         if peer:
 246                             self.driver.shell.BindObjectToPeer('person', person['person_id'], peer['shortname'], user['person_id'])
 247
 248         # remove old keys (only if we are not appending)
 249         append = options.get('append', True)
 250         if append == False:
 251             removed_keys = set(existing_keys).difference(requested_keys)
 252             for existing_key_id in keydict:
 253                 if keydict[existing_key_id] in removed_keys:
 254                     try:
 255                         if peer:
 256                             self.driver.shell.UnBindObjectFromPeer('key', existing_key_id, peer['shortname'])
 257                         self.driver.shell.DeleteKey(existing_key_id)
 258                     except:
 259                         pass
 260
 261