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.alchemy import dbsession
23 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 slice.keys():
50 slice_nodes = self.driver.shell.GetNodes({'node_ids': slice['node_ids']})
51 for node in slice_nodes:
52 slivers[node['node_id']] = node
54 return (slice, slivers)
56 def get_nodes(self, options={}):
58 nodes = self.driver.shell.GetNodes(filter)
61 def get_slivers(self, urns, options={}):
66 xrn = DummyXrn(xrn=urn)
67 if xrn.type == 'sliver':
68 # id: slice_id-node_id
70 sliver_id_parts = xrn.get_sliver_id_parts()
71 slice_id = int(sliver_id_parts[0])
72 node_id = int(sliver_id_parts[1])
73 slice_ids.add(slice_id)
74 node_ids.append(node_id)
78 slice_names.add(xrn.dummy_slicename())
82 filter['slice_name'] = list(slice_names)
84 filter['slice_id'] = list(slice_ids)
86 slices = self.driver.shell.GetSlices(filter)
90 slice['hrn'] = DummyXrn(auth=self.driver.hrn, slicename=slice['slice_name']).hrn
96 user_ids.extend(slice['user_ids'])
98 users = self.driver.shell.GetUsers({'user_ids': user_ids})
100 # construct user key info
103 name = user['email'][0:user['email'].index('@')]
105 'login': slice['slice_name'],
106 'user_urn': Xrn('%s.%s' % (self.driver.hrn, name), type='user').urn,
109 users_list.append(user)
112 node_ids = [node_id for node_id in node_ids if node_id in slice['node_ids']]
113 slice['node_ids'] = node_ids
114 nodes_dict = self.get_slice_nodes(slice, options)
116 for node in nodes_dict.values():
118 sliver_hrn = '%s.%s-%s' % (self.driver.hrn, slice['slice_id'], node['node_id'])
119 node['sliver_id'] = Xrn(sliver_hrn, type='sliver').urn
120 node['urn'] = node['sliver_id']
121 node['services_user'] = users
125 def node_to_rspec_node(self, node, options={}):
126 rspec_node = NodeElement()
127 site=self.driver.testbedInfo
128 rspec_node['component_id'] = hostname_to_urn(self.driver.hrn, site['name'], node['hostname'])
129 rspec_node['component_name'] = node['hostname']
130 rspec_node['component_manager_id'] = Xrn(self.driver.hrn, 'authority+cm').get_urn()
131 rspec_node['authority_id'] = hrn_to_urn(DummyXrn.site_hrn(self.driver.hrn, site['name']), 'authority+sa')
132 #distinguish between Shared and Reservable nodes
133 rspec_node['exclusive'] = 'false'
135 rspec_node['hardware_types'] = [HardwareType({'name': 'dummy-pc'}),
136 HardwareType({'name': 'pc'})]
137 if site['longitude'] and site['latitude']:
138 location = Location({'longitude': site['longitude'], 'latitude': site['latitude'], 'country': 'unknown'})
139 rspec_node['location'] = location
142 def sliver_to_rspec_node(self, sliver, sliver_allocations):
143 rspec_node = self.node_to_rspec_node(sliver)
144 rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
146 rspec_sliver = Sliver({'sliver_id': sliver['urn'],
147 'name': sliver['slice_name'],
148 'type': 'dummy-vserver',
150 rspec_node['sliver_id'] = rspec_sliver['sliver_id']
151 if sliver['urn'] in sliver_allocations:
152 rspec_node['client_id'] = sliver_allocations[sliver['urn']].client_id
153 if sliver_allocations[sliver['urn']].component_id:
154 rspec_node['component_id'] = sliver_allocations[sliver['urn']].component_id
155 rspec_node['slivers'] = [rspec_sliver]
157 # slivers always provide the ssh service
158 login = Login({'authentication': 'ssh-keys',
159 'hostname': sliver['hostname'],
161 'username': sliver['slice_name'],
162 'login': sliver['slice_name']
166 def get_slice_nodes(self, slice, options={}):
169 if slice and slice.get('node_ids'):
170 filter['node_ids'] = slice['node_ids']
172 # there are no nodes to look up
174 nodes = self.driver.shell.GetNodes(filter)
176 nodes_dict[node['node_id']] = node
179 def rspec_node_to_geni_sliver(self, rspec_node, sliver_allocations = {}):
180 if rspec_node['sliver_id'] in sliver_allocations:
181 # set sliver allocation and operational status
182 sliver_allocation = sliver_allocations[rspec_node['sliver_id']]
183 if sliver_allocation:
184 allocation_status = sliver_allocation.allocation_state
185 if allocation_status == 'geni_allocated':
186 op_status = 'geni_pending_allocation'
187 elif allocation_status == 'geni_provisioned':
188 op_status = 'geni_ready'
190 op_status = 'geni_unknown'
192 allocation_status = 'geni_unallocated'
194 allocation_status = 'geni_unallocated'
195 op_status = 'geni_failed'
197 geni_sliver = {'geni_sliver_urn': rspec_node['sliver_id'],
198 'geni_expires': rspec_node['expires'],
199 'geni_allocation_status' : allocation_status,
200 'geni_operational_status': op_status,
205 def list_resources(self, version = None, options={}):
207 version_manager = VersionManager()
208 version = version_manager.get_version(version)
209 rspec_version = version_manager._get_version(version.type, version.version, 'ad')
210 rspec = RSpec(version=rspec_version, user_options=options)
213 nodes = self.get_nodes(options)
216 nodes_dict[node['node_id']] = node
218 # convert nodes to rspec nodes
221 rspec_node = self.node_to_rspec_node(node)
222 rspec_nodes.append(rspec_node)
223 rspec.version.add_nodes(rspec_nodes)
227 def describe(self, urns, version=None, options={}):
228 version_manager = VersionManager()
229 version = version_manager.get_version(version)
230 rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
231 rspec = RSpec(version=rspec_version, user_options=options)
235 slivers = self.get_slivers(urns, options)
237 rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
239 rspec_expires = datetime_to_string(utcparse(time.time()))
240 rspec.xml.set('expires', rspec_expires)
242 # lookup the sliver allocations
244 sliver_ids = [sliver['sliver_id'] for sliver in slivers]
245 constraint = SliverAllocation.sliver_id.in_(sliver_ids)
246 sliver_allocations = dbsession.query(SliverAllocation).filter(constraint)
247 sliver_allocation_dict = {}
248 for sliver_allocation in sliver_allocations:
249 geni_urn = sliver_allocation.slice_urn
250 sliver_allocation_dict[sliver_allocation.sliver_id] = sliver_allocation
254 for sliver in slivers:
255 nodes_dict[sliver['node_id']] = sliver
257 for sliver in slivers:
258 rspec_node = self.sliver_to_rspec_node(sliver, sliver_allocation_dict)
259 rspec_nodes.append(rspec_node)
260 geni_sliver = self.rspec_node_to_geni_sliver(rspec_node, sliver_allocation_dict)
261 geni_slivers.append(geni_sliver)
262 rspec.version.add_nodes(rspec_nodes)
264 return {'geni_urn': geni_urn,
265 'geni_rspec': rspec.toxml(),
266 'geni_slivers': geni_slivers}