2 from sfa.util.xrn import Xrn, hrn_to_urn, urn_to_hrn
3 from sfa.util.sfatime import utcparse, datetime_to_string
4 from sfa.util.sfalogging import logger
6 from sfa.rspecs.rspec import RSpec
7 from sfa.rspecs.elements.hardware_type import HardwareType
8 from sfa.rspecs.elements.node import NodeElement
9 from sfa.rspecs.elements.link import Link
10 from sfa.rspecs.elements.sliver import Sliver
11 from sfa.rspecs.elements.login import Login
12 from sfa.rspecs.elements.location import Location
13 from sfa.rspecs.elements.interface import Interface
14 from sfa.rspecs.elements.services import ServicesElement
15 from sfa.rspecs.elements.pltag import PLTag
16 from sfa.rspecs.elements.lease import Lease
17 from sfa.rspecs.elements.granularity import Granularity
18 from sfa.rspecs.version_manager import VersionManager
20 from sfa.dummy.dummyxrn import DummyXrn, hostname_to_urn, hrn_to_dummy_slicename, slicename_to_hrn
22 from sfa.storage.model import SliverAllocation
28 def __init__(self, driver):
31 def get_slice_and_slivers(self, slice_xrn):
33 Returns a dict of slivers keyed on the sliver's node_id
38 return (slice, slivers)
39 slice_urn = hrn_to_urn(slice_xrn, 'slice')
40 slice_hrn, _ = urn_to_hrn(slice_xrn)
41 slice_name = hrn_to_dummy_slicename(slice_hrn)
42 slices = self.driver.shell.GetSlices({'slice_name': slice_name})
44 return (slice, slivers)
47 # sort slivers by node id
49 if 'node_ids' in list(slice.keys()):
50 slice_nodes = self.driver.shell.GetNodes(
51 {'node_ids': slice['node_ids']})
52 for node in slice_nodes:
53 slivers[node['node_id']] = node
55 return (slice, slivers)
57 def get_nodes(self, options=None):
61 nodes = self.driver.shell.GetNodes(filter)
64 def get_slivers(self, urns, options=None):
71 xrn = DummyXrn(xrn=urn)
72 if xrn.type == 'sliver':
73 # id: slice_id-node_id
75 sliver_id_parts = xrn.get_sliver_id_parts()
76 slice_id = int(sliver_id_parts[0])
77 node_id = int(sliver_id_parts[1])
78 slice_ids.add(slice_id)
79 node_ids.append(node_id)
83 slice_names.add(xrn.dummy_slicename())
87 filter['slice_name'] = list(slice_names)
89 filter['slice_id'] = list(slice_ids)
91 slices = self.driver.shell.GetSlices(filter)
95 slice['hrn'] = DummyXrn(auth=self.driver.hrn,
96 slicename=slice['slice_name']).hrn
102 if 'user_ids' in list(slice.keys()):
103 user_ids.extend(slice['user_ids'])
105 users = self.driver.shell.GetUsers({'user_ids': user_ids})
107 # construct user key info
110 name = user['email'][0:user['email'].index('@')]
112 'login': slice['slice_name'],
113 'user_urn': Xrn('%s.%s' % (self.driver.hrn, name), type='user').urn,
116 users_list.append(user)
120 node_id for node_id in node_ids if node_id in slice['node_ids']]
121 slice['node_ids'] = node_ids
122 nodes_dict = self.get_slice_nodes(slice, options)
124 for node in list(nodes_dict.values()):
126 sliver_hrn = '%s.%s-%s' % (self.driver.hrn,
127 slice['slice_id'], node['node_id'])
128 node['sliver_id'] = Xrn(sliver_hrn, type='sliver').urn
129 node['urn'] = node['sliver_id']
130 node['services_user'] = users
134 def node_to_rspec_node(self, node, options=None):
137 rspec_node = NodeElement()
138 site = self.driver.testbedInfo
139 rspec_node['component_id'] = hostname_to_urn(
140 self.driver.hrn, site['name'], node['hostname'])
141 rspec_node['component_name'] = node['hostname']
142 rspec_node['component_manager_id'] = Xrn(
143 self.driver.hrn, 'authority+cm').get_urn()
144 rspec_node['authority_id'] = hrn_to_urn(DummyXrn.site_hrn(
145 self.driver.hrn, site['name']), 'authority+sa')
146 # distinguish between Shared and Reservable nodes
147 rspec_node['exclusive'] = 'false'
149 rspec_node['hardware_types'] = [HardwareType({'name': 'dummy-pc'}),
150 HardwareType({'name': 'pc'})]
151 if site['longitude'] and site['latitude']:
152 location = Location({'longitude': site['longitude'], 'latitude': site[
153 'latitude'], 'country': 'unknown'})
154 rspec_node['location'] = location
157 def sliver_to_rspec_node(self, sliver, sliver_allocations):
158 rspec_node = self.node_to_rspec_node(sliver)
159 rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
161 rspec_sliver = Sliver({'sliver_id': sliver['urn'],
162 'name': sliver['slice_name'],
163 'type': 'dummy-vserver',
165 rspec_node['sliver_id'] = rspec_sliver['sliver_id']
166 if sliver['urn'] in sliver_allocations:
167 rspec_node['client_id'] = sliver_allocations[
168 sliver['urn']].client_id
169 if sliver_allocations[sliver['urn']].component_id:
170 rspec_node['component_id'] = sliver_allocations[
171 sliver['urn']].component_id
172 rspec_node['slivers'] = [rspec_sliver]
174 # slivers always provide the ssh service
175 login = Login({'authentication': 'ssh-keys',
176 'hostname': sliver['hostname'],
178 'username': sliver['slice_name'],
179 'login': sliver['slice_name']
183 def get_slice_nodes(self, slice, options=None):
188 if slice and slice.get('node_ids'):
189 filter['node_ids'] = slice['node_ids']
191 # there are no nodes to look up
193 nodes = self.driver.shell.GetNodes(filter)
195 nodes_dict[node['node_id']] = node
198 def rspec_node_to_geni_sliver(self, rspec_node, sliver_allocations=None):
199 if sliver_allocations is None:
200 sliver_allocations = {}
201 if rspec_node['sliver_id'] in sliver_allocations:
202 # set sliver allocation and operational status
203 sliver_allocation = sliver_allocations[rspec_node['sliver_id']]
204 if sliver_allocation:
205 allocation_status = sliver_allocation.allocation_state
206 if allocation_status == 'geni_allocated':
207 op_status = 'geni_pending_allocation'
208 elif allocation_status == 'geni_provisioned':
209 op_status = 'geni_ready'
211 op_status = 'geni_unknown'
213 allocation_status = 'geni_unallocated'
215 allocation_status = 'geni_unallocated'
216 op_status = 'geni_failed'
218 geni_sliver = {'geni_sliver_urn': rspec_node['sliver_id'],
219 'geni_expires': rspec_node['expires'],
220 'geni_allocation_status': allocation_status,
221 'geni_operational_status': op_status,
226 def list_resources(self, version=None, options=None):
230 version_manager = VersionManager()
231 version = version_manager.get_version(version)
232 rspec_version = version_manager._get_version(
233 version.type, version.version, 'ad')
234 rspec = RSpec(version=rspec_version, user_options=options)
237 nodes = self.get_nodes(options)
240 nodes_dict[node['node_id']] = node
242 # convert nodes to rspec nodes
245 rspec_node = self.node_to_rspec_node(node)
246 rspec_nodes.append(rspec_node)
247 rspec.version.add_nodes(rspec_nodes)
251 def describe(self, urns, version=None, options=None):
254 version_manager = VersionManager()
255 version = version_manager.get_version(version)
256 rspec_version = version_manager._get_version(
257 version.type, version.version, 'manifest')
258 rspec = RSpec(version=rspec_version, user_options=options)
262 slivers = self.get_slivers(urns, options)
264 rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
266 rspec_expires = datetime_to_string(utcparse(time.time()))
267 rspec.xml.set('expires', rspec_expires)
269 # lookup the sliver allocations
271 sliver_ids = [sliver['sliver_id'] for sliver in slivers]
272 constraint = SliverAllocation.sliver_id.in_(sliver_ids)
273 sliver_allocations = self.driver.api.dbsession().query(
274 SliverAllocation).filter(constraint)
275 sliver_allocation_dict = {}
276 for sliver_allocation in sliver_allocations:
277 geni_urn = sliver_allocation.slice_urn
278 sliver_allocation_dict[
279 sliver_allocation.sliver_id] = sliver_allocation
283 for sliver in slivers:
284 nodes_dict[sliver['node_id']] = sliver
286 for sliver in slivers:
287 rspec_node = self.sliver_to_rspec_node(
288 sliver, sliver_allocation_dict)
289 rspec_nodes.append(rspec_node)
290 geni_sliver = self.rspec_node_to_geni_sliver(
291 rspec_node, sliver_allocation_dict)
292 geni_slivers.append(geni_sliver)
293 rspec.version.add_nodes(rspec_nodes)
295 return {'geni_urn': geni_urn,
296 'geni_rspec': rspec.toxml(),
297 'geni_slivers': geni_slivers}