1 from collections import defaultdict
3 from sfa.util.sfatime import utcparse, datetime_to_epoch
4 from sfa.util.sfalogging import logger
5 from sfa.util.xrn import Xrn, get_leaf, get_authority, urn_to_hrn
7 from sfa.rspecs.rspec import RSpec
9 from sfa.nitos.nitosxrn import NitosXrn, hrn_to_nitos_slicename, xrn_to_hostname, xrn_to_channel
16 def __init__(self, driver):
19 def get_sfa_peer(self, xrn):
20 hrn, type = urn_to_hrn(xrn)
22 # return the authority for this hrn or None if we are the authority
24 slice_authority = get_authority(hrn)
25 site_authority = get_authority(slice_authority)
27 if site_authority != self.driver.hrn:
28 sfa_peer = site_authority
32 def verify_slice_leases_nodes(self, slice, rspec_requested_nodes):
33 nodes = self.driver.shell.getNodes({}, [])
36 for node in rspec_requested_nodes:
39 nitos_nodes.extend(nodes)
40 slice_name = hrn_to_nitos_slicename(node['slice_id'])
41 if slice_name != slice['slice_name']:
43 hostname = xrn_to_hostname(node['component_id'])
44 nitos_node = self.driver.filter_nitos_results(
45 nitos_nodes, {'hostname': hostname})
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(
54 node['duration']) * int(self.driver.testbedInfo['grain']) + int(node['start_time']))
55 requested_nodes.append(requested_node)
57 # get actual nodes reservation data for the slice
58 reserved_nodes = self.driver.filter_nitos_results(
59 self.driver.shell.getReservedNodes({}, []), {'slice_id': slice['slice_id']})
61 reserved_nodes_by_id = {}
62 for node in reserved_nodes:
63 reserved_nodes_by_id[node['reservation_id']] = {'slice_id': node['slice_id'],
64 'node_id': node['node_id'], 'start_time': node['start_time'],
65 'end_time': node['end_time']}
70 for reservation_id in reserved_nodes_by_id:
71 if reserved_nodes_by_id[reservation_id] not in requested_nodes:
72 deleted_nodes_id.append(reservation_id)
74 kept_nodes_id.append(reservation_id)
75 requested_nodes.remove(reserved_nodes_by_id[reservation_id])
76 added_nodes = requested_nodes
79 deleted = self.driver.shell.releaseNodes(
80 {'reservation_ids': deleted_nodes_id})
81 for node in added_nodes:
82 added = self.driver.shell.reserveNodes({'slice_id': slice['slice_id'], 'start_time': node[
83 'start_time'], 'end_time': node['end_time'], 'nodes': [node['node_id']]})
86 logger.log_exc('Failed to add/remove slice leases nodes')
90 def verify_slice_leases_channels(self, slice, rspec_requested_channels):
91 channels = self.driver.shell.getChannels({}, [])
93 requested_channels = []
94 for channel in rspec_requested_channels:
95 requested_channel = {}
97 nitos_channels.extend(channels)
98 slice_name = hrn_to_nitos_slicename(channel['slice_id'])
99 if slice_name != slice['slice_name']:
101 channel_num = xrn_to_channel(channel['component_id'])
102 nitos_channel = self.driver.filter_nitos_results(
103 nitos_channels, {'channel': channel_num})[0]
104 # fill the requested channel with nitos ids
105 requested_channel['slice_id'] = slice['slice_id']
106 requested_channel['channel_id'] = nitos_channel['channel_id']
107 requested_channel['start_time'] = channel['start_time']
108 requested_channel['end_time'] = str(int(
109 channel['duration']) * int(self.driver.testbedInfo['grain']) + int(channel['start_time']))
110 requested_channels.append(requested_channel)
112 # get actual channel reservation data for the slice
113 reserved_channels = self.driver.filter_nitos_results(
114 self.driver.shell.getReservedChannels(), {'slice_id': slice['slice_id']})
116 reserved_channels_by_id = {}
117 for channel in reserved_channels:
118 reserved_channels_by_id[channel['reservation_id']] = {'slice_id': channel['slice_id'],
119 'channel_id': channel['channel_id'], 'start_time': channel['start_time'],
120 'end_time': channel['end_time']}
123 kept_channels_id = []
124 deleted_channels_id = []
125 for reservation_id in reserved_channels_by_id:
126 if reserved_channels_by_id[reservation_id] not in requested_channels:
127 deleted_channels_id.append(reservation_id)
129 kept_channels_id.append(reservation_id)
130 requested_channels.remove(
131 reserved_channels_by_id[reservation_id])
132 added_channels = requested_channels
135 deleted = self.driver.shell.releaseChannels(
136 {'reservation_ids': deleted_channels_id})
137 for channel in added_channels:
138 added = self.driver.shell.reserveChannels({'slice_id': slice['slice_id'], 'start_time': channel[
139 'start_time'], 'end_time': channel['end_time'], 'channels': [channel['channel_id']]})
142 logger.log_exc('Failed to add/remove slice leases channels')
144 return added_channels
146 def free_egre_key(self):
148 for tag in self.driver.shell.GetSliceTags({'tagname': 'egre_key'}):
149 used.add(int(tag['value']))
151 for i in range(1, 256):
156 raise KeyError("No more EGRE keys available")
160 def verify_slice(self, slice_hrn, slice_record, sfa_peer, options=None):
163 slicename = hrn_to_nitos_slicename(slice_hrn)
164 slices = self.driver.shell.getSlices({}, [])
165 slices = self.driver.filter_nitos_results(
166 slices, {'slice_name': slicename})
168 slice = {'slice_name': slicename}
170 slice['slice_id'] = self.driver.shell.addSlice(slice)
171 slice['node_ids'] = []
172 slice['user_ids'] = []
178 def verify_users(self, slice_hrn, slice_record, users, sfa_peer, options=None):
182 slicename = hrn_to_nitos_slicename(slice_hrn)
183 slices = self.driver.shell.getSlices({}, [])
184 slice = self.driver.filter_nitos_results(
185 slices, {'slice_name': slicename})[0]
190 user_urn = user['urn']
191 user_hrn, type = urn_to_hrn(user_urn)
192 username = str(user_hrn).split('.')[-1]
193 email = user['email']
194 # look for the user according to his username, email...
195 nitos_users = self.driver.filter_nitos_results(
196 self.driver.shell.getUsers(), {'username': username})
198 nitos_users = self.driver.filter_nitos_results(
199 self.driver.shell.getUsers(), {'email': email})
203 user_id = self.driver.shell.addUser(
204 {'username': email.split('@')[0], 'email': email})
205 added_users.append(user_id)
207 for key in user['keys']:
208 self.driver.shell.addUserKey(
209 {'user_id': user_id, 'key': key, 'slice_id': slice['slice_id']})
210 # add the user to the slice
211 self.driver.shell.addUserToSlice(
212 {'slice_id': slice['slice_id'], 'user_id': user_id})
214 # check if the users are in the slice
215 for user in nitos_users:
216 if not user['user_id'] in slice['user_ids']:
217 self.driver.shell.addUserToSlice(
218 {'slice_id': slice['slice_id'], 'user_id': user['user_id']})
222 def verify_keys(self, persons, users, options=None):
227 for person in persons:
228 key_ids.extend(person['key_ids'])
229 keylist = self.driver.shell.GetKeys(key_ids, ['key_id', 'key'])
232 keydict[key['key']] = key['key_id']
233 existing_keys = keydict.keys()
235 for person in persons:
236 persondict[person['email']] = person
242 user_keys = user.get('keys', [])
243 updated_persons.append(user)
244 for key_string in user_keys:
245 requested_keys.append(key_string)
246 if key_string not in existing_keys:
247 key = {'key': key_string, 'key_type': 'ssh'}
250 person = persondict[user['email']]
251 self.driver.shell.UnBindObjectFromPeer(
252 'person', person['person_id'], peer['shortname'])
253 key['key_id'] = self.driver.shell.AddPersonKey(
256 key_index = user_keys.index(key['key'])
257 remote_key_id = user['key_ids'][key_index]
258 self.driver.shell.BindObjectToPeer('key', key['key_id'], peer[
259 'shortname'], remote_key_id)
263 self.driver.shell.BindObjectToPeer('person', person['person_id'], peer[
264 'shortname'], user['person_id'])
266 # remove old keys (only if we are not appending)
267 append = options.get('append', True)
269 removed_keys = set(existing_keys).difference(requested_keys)
270 for existing_key_id in keydict:
271 if keydict[existing_key_id] in removed_keys:
274 self.driver.shell.UnBindObjectFromPeer(
275 'key', existing_key_id, peer['shortname'])
276 self.driver.shell.DeleteKey(existing_key_id)