def date_repr (self,fields):
if not isinstance(fields,list): fields=[fields]
for field in fields:
value=getattr(self,field,None)
if isinstance (value,datetime):
return datetime_to_string (value)
elif isinstance (value,(int,float)):
return datetime_to_string(utcparse(value))
# fallback
return "** undef_datetime **"
def date_repr (self,fields):
if not isinstance(fields,list): fields=[fields]
for field in fields:
value=getattr(self,field,None)
if isinstance (value,datetime):
return datetime_to_string (value)
elif isinstance (value,(int,float)):
return datetime_to_string(utcparse(value))
# fallback
return "** undef_datetime **"
def sliver_status(self, slice_urn, slice_hrn):
# find out where this slice is currently running
slice_name = hrn_to_dummy_slicename(slice_hrn)
slice = self.shell.GetSlices({"slice_name": slice_name})
if len(slices) == 0:
raise SliverDoesNotExist("%s (used %s as slicename internally)" % (slice_hrn, slicename))
# report about the local nodes only
nodes = self.shell.GetNodes({"node_ids": slice["node_ids"]})
if len(nodes) == 0:
raise SliverDoesNotExist("You have not allocated any slivers here")
# get login info
user = {}
keys = []
if slice["user_ids"]:
users = self.shell.GetUsers({"user_ids": slice["user_ids"]})
for user in users:
keys.extend(user["keys"])
user.update(
{"urn": slice_urn, "login": slice["slice_name"], "protocol": ["ssh"], "port": ["22"], "keys": keys}
)
result = {}
top_level_status = "unknown"
if nodes:
top_level_status = "ready"
result["geni_urn"] = slice_urn
result["dummy_login"] = slice["slice_name"]
result["dummy_expires"] = datetime_to_string(utcparse(slice["expires"]))
result["geni_expires"] = datetime_to_string(utcparse(slice["expires"]))
resources = []
for node in nodes:
res = {}
res["dummy_hostname"] = node["hostname"]
res["geni_expires"] = datetime_to_string(utcparse(slice["expires"]))
sliver_id = Xrn(slice_urn, type="slice", id=node["node_id"], authority=self.hrn).urn
res["geni_urn"] = sliver_id
res["geni_status"] = "ready"
res["geni_error"] = ""
res["users"] = [users]
resources.append(res)
result["geni_status"] = top_level_status
result["geni_resources"] = resources
return result
def describe(self, urns, version=None, options={}):
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type,
version.version,
'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# get slivers
geni_slivers = []
slivers = self.get_slivers(urns, options)
if slivers:
rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
else:
rspec_expires = datetime_to_string(utcparse(time.time()))
rspec.xml.set('expires', rspec_expires)
# lookup the sliver allocations
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
sliver_allocations = self.driver.api.dbsession().query(
SliverAllocation).filter(constraint)
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
sliver_allocation_dict[
sliver_allocation.sliver_id] = sliver_allocation
# add slivers
nodes_dict = {}
for sliver in slivers:
nodes_dict[sliver['node_id']] = sliver
rspec_nodes = []
for sliver in slivers:
rspec_node = self.sliver_to_rspec_node(sliver,
sliver_allocation_dict)
rspec_nodes.append(rspec_node)
geni_sliver = self.rspec_node_to_geni_sliver(
rspec_node, sliver_allocation_dict)
geni_slivers.append(geni_sliver)
rspec.version.add_nodes(rspec_nodes)
return {
'geni_urn': geni_urn,
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers
}
def describe(self, urns, version=None, options={}):
# update nova connection
tenant_name = OSXrn(xrn=urns[0], type='slice').get_tenant_name()
self.driver.shell.nova_manager.connect(tenant=tenant_name)
instances = self.get_instances(urns)
# lookup the sliver allocations
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
sliver_allocations = self.driver.api.dbsession().query(SliverAllocation).filter(constraint)
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
sliver_allocation_dict[sliver_allocation.sliver_id] = sliver_allocation
geni_slivers = []
rspec_nodes = []
for instance in instances:
rspec_nodes.append(self.instance_to_rspec_node(instance))
geni_sliver = self.instance_to_geni_sliver(instance, sliver_sllocation_dict)
geni_slivers.append(geni_sliver)
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
rspec.xml.set('expires', datetime_to_string(utcparse(time.time())))
rspec.version.add_nodes(rspec_nodes)
result = {'geni_urn': Xrn(urns[0]).get_urn(),
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers}
return result
def instance_to_geni_sliver(self, instance, sliver_allocations = {}):
sliver_hrn = '%s.%s' % (self.driver.hrn, instance.id)
sliver_id = Xrn(sliver_hrn, type='sliver').urn
# set sliver allocation and operational status
sliver_allocation = sliver_allocations[sliver_id]
if sliver_allocation:
allocation_status = sliver_allocation.allocation_state
if allocation_status == 'geni_allocated':
op_status = 'geni_pending_allocation'
elif allocation_status == 'geni_provisioned':
state = instance.state.lower()
if state == 'active':
op_status = 'geni_ready'
elif state == 'building':
op_status = 'geni_notready'
elif state == 'failed':
op_status =' geni_failed'
else:
op_status = 'geni_unknown'
else:
allocation_status = 'geni_unallocated'
# required fields
geni_sliver = {'geni_sliver_urn': sliver_id,
'geni_expires': None,
'geni_allocation_status': allocation_status,
'geni_operational_status': op_status,
'geni_error': None,
'plos_created_at': datetime_to_string(utcparse(instance.created)),
'plos_sliver_type': self.shell.nova_manager.flavors.find(id=instance.flavor['id']).name,
}
return geni_sliver
def sliver_to_rspec_node(self, sliver, sliver_allocations):
rspec_node = self.node_to_rspec_node(sliver)
rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
# add sliver info
rspec_sliver = Sliver({
'sliver_id': sliver['urn'],
'name': sliver['slice_name'],
'type': 'unigetestbed-vserver',
'tags': []
})
rspec_node['sliver_id'] = rspec_sliver['sliver_id']
if sliver['urn'] in sliver_allocations:
rspec_node['client_id'] = sliver_allocations[
sliver['urn']].client_id
if sliver_allocations[sliver['urn']].component_id:
rspec_node['component_id'] = sliver_allocations[
sliver['urn']].component_id
rspec_node['slivers'] = [rspec_sliver]
# slivers always provide the ssh service
login = Login({
'authentication': 'ssh-keys',
'hostname': sliver['hostname'],
'port': '22',
'username': sliver['slice_name'],
'login': sliver['slice_name']
})
return rspec_node
def get_rspec(self, slice_xrn=None, version = None, options={}):
version_manager = VersionManager()
version = version_manager.get_version(version)
if not slice_xrn:
rspec_version = version_manager._get_version(version.type, version.version, 'ad')
else:
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
slice, slivers = self.get_slice_and_slivers(slice_xrn)
rspec = RSpec(version=rspec_version, user_options=options)
if slice and 'expires' in slice:
rspec.xml.set('expires', datetime_to_string(utcparse(slice['expires'])))
nodes = self.get_nodes(slice_xrn, slice, slivers, options)
rspec.version.add_nodes(nodes)
# add sliver defaults
default_sliver = slivers.get(None, [])
if default_sliver:
default_sliver_attribs = default_sliver.get('tags', [])
for attrib in default_sliver_attribs:
logger.info(attrib)
rspec.version.add_default_sliver_attribute(attrib['tagname'], attrib['value'])
return rspec.toxml()
def sliver_to_rspec_node(self, sliver, sites, interfaces, node_tags, \
pl_initscripts, sliver_allocations):
# get the granularity in second for the reservation system
grain = self.driver.shell.GetLeaseGranularity()
rspec_node = self.node_to_rspec_node(sliver, sites, interfaces, node_tags, pl_initscripts, grain)
# xxx how to retrieve site['login_base']
rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
# remove interfaces from manifest
rspec_node['interfaces'] = []
# add sliver info
rspec_sliver = Sliver({'sliver_id': sliver['urn'],
'name': sliver['name'],
'type': 'plab-vserver',
'tags': []})
rspec_node['sliver_id'] = rspec_sliver['sliver_id']
if sliver['urn'] in sliver_allocations:
rspec_node['client_id'] = sliver_allocations[sliver['urn']].client_id
if sliver_allocations[sliver['urn']].component_id:
rspec_node['component_id'] = sliver_allocations[sliver['urn']].component_id
rspec_node['slivers'] = [rspec_sliver]
# slivers always provide the ssh service
login = Login({'authentication': 'ssh-keys',
'hostname': sliver['hostname'],
'port':'22',
'username': sliver['name'],
'login': sliver['name']
})
service = ServicesElement({'login': login,
'services_user': sliver['services_user']})
rspec_node['services'] = [service]
return rspec_node
def delete(self, urns, options={}):
# collect sliver ids so we can update sliver allocation states after
# we remove the slivers.
aggregate = unigetestbedAggregate(self)
slivers = aggregate.get_slivers(urns)
if slivers:
slice_id = slivers[0]['slice_id']
node_ids = []
sliver_ids = []
for sliver in slivers:
node_ids.append(sliver['node_id'])
sliver_ids.append(sliver['sliver_id'])
# determine if this is a peer slice
# xxx I wonder if this would not need to use PlSlices.get_peer instead
# in which case plc.peers could be deprecated as this here
# is the only/last call to this last method in plc.peers
slice_hrn = unigetestbedXrn(auth=self.hrn, slicename=slivers[0]['slice_name']).get_hrn()
try:
self.shell.DeleteSliceFromNodes({'slice_id': slice_id, 'node_ids': node_ids})
# delete sliver allocation states
dbsession=self.api.dbsession()
SliverAllocation.delete_allocations(sliver_ids,dbsession)
finally:
pass
# prepare return struct
geni_slivers = []
for sliver in slivers:
geni_slivers.append(
{'geni_sliver_urn': sliver['sliver_id'],
'geni_allocation_status': 'geni_unallocated',
'geni_expires': datetime_to_string(utcparse(sliver['expires']))})
return geni_slivers
def describe(self, urns, version=None, options=None):
if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# Update connection for the current user
xrn = Xrn(urns[0], type='slice')
user_name = xrn.get_authority_hrn() + '.' + xrn.leaf.split('-')[0]
tenant_name = OSXrn(xrn=urns[0], type='slice').get_hrn()
self.driver.shell.compute_manager.connect(username=user_name, tenant=tenant_name, password=user_name)
# For delay to collect instance info
time.sleep(3)
# Get instances from the Openstack
instances = self.get_instances(xrn)
# Add sliver(s) from instance(s)
geni_slivers = []
rspec.xml.set( 'expires', datetime_to_string(utcparse(time.time())) )
rspec_nodes = []
for instance in instances:
rspec_nodes.append(self.instance_to_rspec_node(instance))
geni_sliver = self.instance_to_geni_sliver(instance)
geni_slivers.append(geni_sliver)
rspec.version.add_nodes(rspec_nodes)
result = { 'geni_urn': xrn.get_urn(),
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers }
return result
def call(self, xrn, creds, rspec, options):
xrn = Xrn(xrn, type='slice')
self.api.logger.info("interface: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, xrn.get_hrn(), self.name))
(speaking_for, _) = urn_to_hrn(options.get('geni_speaking_for'))
# Find the valid credentials
valid_creds = self.api.auth.checkCredentials(creds, 'createsliver', xrn.get_hrn(), speaking_for_hrn=speaking_for)
# use the expiration from the first valid credential to determine when
# the slivers should expire.
expiration = datetime_to_string(Credential(cred=valid_creds[0]).expiration)
# make sure request is not empty
slivers = RSpec(rspec).version.get_nodes_with_slivers()
if not slivers:
raise InvalidRSpec("Missing <sliver_type> or <sliver> element. Request rspec must explicitly allocate slivers")
# flter rspec through sfatables
if self.api.interface in ['aggregate']:
chain_name = 'INCOMING'
elif self.api.interface in ['slicemgr']:
chain_name = 'FORWARD-INCOMING'
self.api.logger.debug("Allocate: sfatables on chain %s"%chain_name)
origin_hrn = Credential(cred=valid_creds[0]).get_gid_caller().get_hrn()
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, xrn, self.name))
rspec = run_sfatables(chain_name, xrn.get_hrn(), origin_hrn, rspec)
slivers = RSpec(rspec).version.get_nodes_with_slivers()
if not slivers:
raise SfatablesRejected(slice_xrn)
result = self.api.manager.Allocate(self.api, xrn.get_urn(), creds, rspec, expiration, options)
return result
def describe(self, urns, version=None, options=None):
if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# get slivers
geni_slivers = []
slivers = self.get_slivers(urns, options)
if slivers:
rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
else:
rspec_expires = datetime_to_string(utcparse(time.time()))
rspec.xml.set('expires', rspec_expires)
# lookup the sliver allocations
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
sliver_allocations = self.driver.api.dbsession().query(SliverAllocation).filter(constraint)
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
sliver_allocation_dict[sliver_allocation.sliver_id] = sliver_allocation
# add slivers
nodes_dict = {}
for sliver in slivers:
nodes_dict[sliver['node_id']] = sliver
rspec_nodes = []
for sliver in slivers:
rspec_node = self.sliver_to_rspec_node(sliver, sliver_allocation_dict)
rspec_nodes.append(rspec_node)
geni_sliver = self.rspec_node_to_geni_sliver(rspec_node, sliver_allocation_dict)
geni_slivers.append(geni_sliver)
rspec.version.add_nodes(rspec_nodes)
return {'geni_urn': geni_urn,
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers}
def sliver_to_rspec_node(self, sliver, sliver_allocations):
"""Used by describe to format node information into a rspec compliant
structure.
Creates a node rspec compliant structure by calling node_to_rspec_node.
Adds slivers, if any, to rspec node structure. Returns the updated
rspec node struct.
:param sliver: sliver dictionary. Contains keys: urn, slice_id, hostname
and slice_name.
:type sliver: dictionary
:param sliver_allocations: dictionary of slivers
:type sliver_allocations: dict
:returns: Node dictionary with all necessary data.
.. seealso:: node_to_rspec_node
"""
rspec_node = self.node_to_rspec_node(sliver)
rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
# add sliver info
logger.debug("CORTEXLABAGGREGATE api \t sliver_to_rspec_node sliver \
%s \r\nsliver_allocations %s" %
(sliver, sliver_allocations))
rspec_sliver = Sliver({
'sliver_id': sliver['urn'],
'name': sliver['slice_id'],
'type': 'iotlab-exclusive',
'tags': []
})
rspec_node['sliver_id'] = rspec_sliver['sliver_id']
if sliver['urn'] in sliver_allocations:
rspec_node['client_id'] = sliver_allocations[
sliver['urn']].client_id
if sliver_allocations[sliver['urn']].component_id:
rspec_node['component_id'] = sliver_allocations[
sliver['urn']].component_id
rspec_node['slivers'] = [rspec_sliver]
# slivers always provide the ssh service
login = Login({
'authentication': 'ssh-keys',
'hostname': sliver['hostname'],
'port': '22',
'username': sliver['slice_name'],
'login': sliver['slice_name']
})
return rspec_node
def sliver_status (self, slice_urn, slice_hrn):
# update nova connection
tenant_name = OSXrn(xrn=slice_hrn, type='slice').get_tenant_name()
self.shell.nova_manager.connect(tenant=tenant_name)
# find out where this slice is currently running
project_name = hrn_to_os_slicename(slice_hrn)
instances = self.shell.nova_manager.servers.findall(name=project_name)
if len(instances) == 0:
raise SliverDoesNotExist("You have not allocated any slivers here")
result = {}
top_level_status = 'ready'
result['geni_urn'] = slice_urn
result['plos_login'] = '******'
# do we need real dates here?
result['plos_expires'] = None
result['geni_expires'] = None
resources = []
for instance in instances:
res = {}
# instances are accessed by ip, not hostname. We need to report the ip
# somewhere so users know where to ssh to.
res['geni_expires'] = None
#res['plos_hostname'] = instance.hostname
res['plos_created_at'] = datetime_to_string(utcparse(instance.created))
res['plos_boot_state'] = instance.status
res['plos_sliver_type'] = self.shell.nova_manager.flavors.find(id=instance.flavor['id']).name
res['geni_urn'] = Xrn(slice_urn, type='slice', id=instance.id).get_urn()
if instance.status.lower() == 'active':
res['boot_state'] = 'ready'
res['geni_status'] = 'ready'
elif instance.status.lower() == 'error':
res['boot_state'] = 'failed'
res['geni_status'] = 'failed'
top_level_status = 'failed'
else:
res['boot_state'] = 'notready'
res['geni_status'] = 'notready'
top_level_status = 'notready'
resources.append(res)
result['geni_status'] = top_level_status
result['geni_resources'] = resources
return result
def sliver_to_rspec_node(self, sliver, sliver_allocations):
"""Used by describe to format node information into a rspec compliant
structure.
Creates a node rspec compliant structure by calling node_to_rspec_node.
Adds slivers, if any, to rspec node structure. Returns the updated
rspec node struct.
:param sliver: sliver dictionary. Contains keys: urn, slice_id, hostname
and slice_name.
:type sliver: dictionary
:param sliver_allocations: dictionary of slivers
:type sliver_allocations: dict
:returns: Node dictionary with all necessary data.
.. seealso:: node_to_rspec_node
"""
rspec_node = self.node_to_rspec_node(sliver)
rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
# add sliver info
logger.debug("IOTLABAGGREGATE api \t sliver_to_rspec_node sliver \
%s \r\nsliver_allocations %s" % (sliver,
sliver_allocations))
rspec_sliver = Sliver({'sliver_id': sliver['urn'],
'name': sliver['slice_id'],
'type': 'iotlab-exclusive',
'tags': []})
rspec_node['sliver_id'] = rspec_sliver['sliver_id']
if sliver['urn'] in sliver_allocations:
rspec_node['client_id'] = sliver_allocations[
sliver['urn']].client_id
if sliver_allocations[sliver['urn']].component_id:
rspec_node['component_id'] = sliver_allocations[
sliver['urn']].component_id
rspec_node['slivers'] = [rspec_sliver]
# slivers always provide the ssh service
login = Login({'authentication': 'ssh-keys',
'hostname': sliver['hostname'],
'port':'22',
'username': sliver['slice_name'],
'login': sliver['slice_name']
})
return rspec_node
def delete(self, urns, options={}):
# collect sliver ids so we can update sliver allocation states after
# we remove the slivers.
aggregate = PlAggregate(self)
slivers = aggregate.get_slivers(urns)
if slivers:
slice_id = slivers[0]['slice_id']
slice_name = slivers[0]['name']
node_ids = []
sliver_ids = []
for sliver in slivers:
node_ids.append(sliver['node_id'])
sliver_ids.append(sliver['sliver_id'])
# leases
leases = self.shell.GetLeases({
'name': slice_name,
'node_id': node_ids
})
leases_ids = [lease['lease_id'] for lease in leases]
slice_hrn = self.shell.GetSliceHrn(int(slice_id))
try:
self.shell.DeleteSliceFromNodes(slice_id, node_ids)
if len(leases_ids) > 0:
self.shell.DeleteLeases(leases_ids)
# delete sliver allocation states
dbsession = self.api.dbsession()
SliverAllocation.delete_allocations(sliver_ids, dbsession)
finally:
pass
# prepare return struct
geni_slivers = []
for sliver in slivers:
geni_slivers.append({
'geni_sliver_urn':
sliver['sliver_id'],
'geni_allocation_status':
'geni_unallocated',
'geni_expires':
datetime_to_string(utcparse(sliver['expires']))
})
return geni_slivers
def delete(self, urns, options={}):
# collect sliver ids so we can update sliver allocation states after
# we remove the slivers.
aggregate = DummyAggregate(self)
slivers = aggregate.get_slivers(urns)
if slivers:
slice_id = slivers[0]['slice_id']
node_ids = []
sliver_ids = []
for sliver in slivers:
node_ids.append(sliver['node_id'])
sliver_ids.append(sliver['sliver_id'])
# determine if this is a peer slice
# xxx I wonder if this would not need to use PlSlices.get_peer instead
# in which case plc.peers could be deprecated as this here
# is the only/last call to this last method in plc.peers
slice_hrn = DummyXrn(auth=self.hrn,
slicename=slivers[0]['slice_name']).get_hrn()
try:
self.shell.DeleteSliceFromNodes({
'slice_id': slice_id,
'node_ids': node_ids
})
# delete sliver allocation states
dbsession = self.api.dbsession()
SliverAllocation.delete_allocations(sliver_ids, dbsession)
finally:
pass
# prepare return struct
geni_slivers = []
for sliver in slivers:
geni_slivers.append({
'geni_sliver_urn':
sliver['sliver_id'],
'geni_allocation_status':
'geni_unallocated',
'geni_expires':
datetime_to_string(utcparse(sliver['expires']))
})
return geni_slivers
def call(self, xrn, creds, rspec, options):
xrn = Xrn(xrn, type='slice')
self.api.logger.info("interface: %s\ttarget-hrn: %s\tmethod-name: %s" %
(self.api.interface, xrn.get_hrn(), self.name))
(speaking_for, _) = urn_to_hrn(options.get('geni_speaking_for'))
# Find the valid credentials
valid_creds = self.api.auth.checkCredentials(
creds,
'createsliver',
xrn.get_hrn(),
speaking_for_hrn=speaking_for)
# use the expiration from the first valid credential to determine when
# the slivers should expire.
expiration = datetime_to_string(
Credential(cred=valid_creds[0]).expiration)
# make sure request is not empty
slivers = RSpec(rspec).version.get_nodes_with_slivers()
if not slivers:
raise InvalidRSpec(
"Missing <sliver_type> or <sliver> element. Request rspec must explicitly allocate slivers"
)
# flter rspec through sfatables
if self.api.interface in ['aggregate']:
chain_name = 'INCOMING'
elif self.api.interface in ['slicemgr']:
chain_name = 'FORWARD-INCOMING'
self.api.logger.debug("Allocate: sfatables on chain %s" % chain_name)
origin_hrn = Credential(cred=valid_creds[0]).get_gid_caller().get_hrn()
self.api.logger.info(
"interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s" %
(self.api.interface, origin_hrn, xrn, self.name))
rspec = run_sfatables(chain_name, xrn.get_hrn(), origin_hrn, rspec)
slivers = RSpec(rspec).version.get_nodes_with_slivers()
if not slivers:
raise SfatablesRejected(slice_xrn)
result = self.api.manager.Allocate(self.api, xrn.get_urn(), creds,
rspec, expiration, options)
return result
def get_rspec(self, slice_xrn=None, version=None, options={}):
version_manager = VersionManager()
version = version_manager.get_version(version)
if not slice_xrn:
rspec_version = version_manager._get_version(
version.type, version.version, 'ad')
else:
rspec_version = version_manager._get_version(
version.type, version.version, 'manifest')
slice, slivers = self.get_slice_and_slivers(slice_xrn)
rspec = RSpec(version=rspec_version, user_options=options)
if slice and 'expires' in slice:
rspec.xml.set('expires',
datetime_to_string(utcparse(slice['expires'])))
if not options.get('list_leases') or options.get(
'list_leases') and options['list_leases'] != 'leases':
nodes = self.get_nodes(slice_xrn, slice, slivers, options)
rspec.version.add_nodes(nodes)
# add sliver defaults
default_sliver = slivers.get(None, [])
if default_sliver:
default_sliver_attribs = default_sliver.get('tags', [])
for attrib in default_sliver_attribs:
logger.info(attrib)
rspec.version.add_default_sliver_attribute(
attrib['tagname'], attrib['value'])
# add wifi channels
channels = self.get_channels(slice, options)
rspec.version.add_channels(channels)
if not options.get('list_leases') or options.get(
'list_leases') and options['list_leases'] != 'resources':
leases_channels = self.get_leases_and_channels(slice, slice_xrn)
rspec.version.add_leases(leases_channels)
return rspec.toxml()
def sliver_to_rspec_node(self, sliver, sites, interfaces, node_tags, \
pl_initscripts, sliver_allocations):
# get the granularity in second for the reservation system
grain = self.driver.shell.GetLeaseGranularity()
rspec_node = self.node_to_rspec_node(sliver, sites, interfaces,
node_tags, pl_initscripts, grain)
# xxx how to retrieve site['login_base']
rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
# remove interfaces from manifest
rspec_node['interfaces'] = []
# add sliver info
rspec_sliver = Sliver({
'sliver_id': sliver['urn'],
'name': sliver['name'],
'type': 'plab-vserver',
'tags': []
})
rspec_node['sliver_id'] = rspec_sliver['sliver_id']
if sliver['urn'] in sliver_allocations:
rspec_node['client_id'] = sliver_allocations[
sliver['urn']].client_id
if sliver_allocations[sliver['urn']].component_id:
rspec_node['component_id'] = sliver_allocations[
sliver['urn']].component_id
rspec_node['slivers'] = [rspec_sliver]
# slivers always provide the ssh service
login = Login({
'authentication': 'ssh-keys',
'hostname': sliver['hostname'],
'port': '22',
'username': sliver['name'],
'login': sliver['name']
})
service = ServicesElement({
'login': login,
'services_user': sliver['services_user']
})
rspec_node['services'] = [service]
return rspec_node
def delete(self, urns, options=None):
if options is None: options={}
# collect sliver ids so we can update sliver allocation states after
# we remove the slivers.
aggregate = PlAggregate(self)
slivers = aggregate.get_slivers(urns)
if slivers:
slice_id = slivers[0]['slice_id']
slice_name = slivers[0]['name']
node_ids = []
sliver_ids = []
for sliver in slivers:
node_ids.append(sliver['node_id'])
sliver_ids.append(sliver['sliver_id'])
# leases
leases = self.shell.GetLeases({'name': slice_name, 'node_id': node_ids})
leases_ids = [lease['lease_id'] for lease in leases ]
slice_hrn = self.shell.GetSliceHrn(int(slice_id))
try:
self.shell.DeleteSliceFromNodes(slice_id, node_ids)
if len(leases_ids) > 0:
self.shell.DeleteLeases(leases_ids)
# delete sliver allocation states
dbsession=self.api.dbsession()
SliverAllocation.delete_allocations(sliver_ids,dbsession)
finally:
pass
# prepare return struct
geni_slivers = []
for sliver in slivers:
geni_slivers.append(
{'geni_sliver_urn': sliver['sliver_id'],
'geni_allocation_status': 'geni_unallocated',
'geni_expires': datetime_to_string(utcparse(sliver['expires']))})
return geni_slivers
def sliver_to_rspec_node(self, sliver, sliver_allocations):
rspec_node = self.node_to_rspec_node(sliver)
rspec_node['expires'] = datetime_to_string(utcparse(sliver['expires']))
# add sliver info
rspec_sliver = Sliver({'sliver_id': sliver['urn'],
'name': sliver['slice_name'],
'type': 'dummy-vserver',
'tags': []})
rspec_node['sliver_id'] = rspec_sliver['sliver_id']
if sliver['urn'] in sliver_allocations:
rspec_node['client_id'] = sliver_allocations[sliver['urn']].client_id
if sliver_allocations[sliver['urn']].component_id:
rspec_node['component_id'] = sliver_allocations[sliver['urn']].component_id
rspec_node['slivers'] = [rspec_sliver]
# slivers always provide the ssh service
login = Login({'authentication': 'ssh-keys',
'hostname': sliver['hostname'],
'port':'22',
'username': sliver['slice_name'],
'login': sliver['slice_name']
})
return rspec_node
def call(self, xrn, creds, rspec, options):
xrn = Xrn(xrn, type='slice')
# Find the valid credentials
valid_creds = self.api.auth.checkCredentialsSpeaksFor(creds, 'createsliver', xrn.get_hrn(), options=options)
the_credential = Credential(cred=valid_creds[0])
# use the expiration from the first valid credential to determine when
# the slivers should expire.
expiration = datetime_to_string(the_credential.expiration)
self.api.logger.debug("Allocate, received expiration from credential: %s"%expiration)
# turned off, as passing an empty rspec is indeed useful for cleaning up the slice
# # make sure request is not empty
# slivers = RSpec(rspec).version.get_nodes_with_slivers()
# if not slivers:
# raise InvalidRSpec("Missing <sliver_type> or <sliver> element. Request rspec must explicitly allocate slivers")
# flter rspec through sfatables
if self.api.interface in ['aggregate']:
chain_name = 'INCOMING'
elif self.api.interface in ['slicemgr']:
chain_name = 'FORWARD-INCOMING'
self.api.logger.debug("Allocate: sfatables on chain %s"%chain_name)
actual_caller_hrn = the_credential.actual_caller_hrn()
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, actual_caller_hrn, xrn.get_hrn(), self.name))
rspec = run_sfatables(chain_name, xrn.get_hrn(), actual_caller_hrn, rspec)
# turned off, as passing an empty rspec is indeed useful for cleaning up the slice
# slivers = RSpec(rspec).version.get_nodes_with_slivers()
# if not slivers:
# raise SfatablesRejected(slice_xrn)
# pass this to the driver code in case they need it
options['actual_caller_hrn'] = actual_caller_hrn
result = self.api.manager.Allocate(self.api, xrn.get_urn(), creds, rspec, expiration, options)
return result
def get_rspec(self, slice_xrn=None, version = None, options=None):
if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
if not slice_xrn:
rspec_version = version_manager._get_version(version.type, version.version, 'ad')
else:
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
slice, slivers = self.get_slice_and_slivers(slice_xrn)
rspec = RSpec(version=rspec_version, user_options=options)
if slice and 'expires' in slice:
rspec.xml.set('expires', datetime_to_string(utcparse(slice['expires'])))
if not options.get('list_leases') or options.get('list_leases') and options['list_leases'] != 'leases':
nodes = self.get_nodes(slice_xrn, slice, slivers, options)
rspec.version.add_nodes(nodes)
# add sliver defaults
default_sliver = slivers.get(None, [])
if default_sliver:
default_sliver_attribs = default_sliver.get('tags', [])
for attrib in default_sliver_attribs:
logger.info(attrib)
rspec.version.add_default_sliver_attribute(attrib['tagname'], attrib['value'])
# add wifi channels
channels = self.get_channels(slice, options)
rspec.version.add_channels(channels)
if not options.get('list_leases') or options.get('list_leases') and options['list_leases'] != 'resources':
leases_channels = self.get_leases_and_channels(slice, slice_xrn)
rspec.version.add_leases(leases_channels)
return rspec.toxml()
def describe(self, urns, version=None, options=None):
"""
Retrieve a manifest RSpec describing the resources contained by the
named entities, e.g. a single slice or a set of the slivers in a slice.
This listing and description should be sufficiently descriptive to allow
experimenters to use the resources.
:param urns: If a slice urn is supplied and there are no slivers in the
given slice at this aggregate, then geni_rspec shall be a valid
manifest RSpec, containing no node elements - no resources.
:type urns: list or strings
:param options: various options. the valid options are: {boolean
geni_compressed <optional>; struct geni_rspec_version { string type;
#case insensitive , string version; # case insensitive}}
:type options: dictionary
:returns: On success returns the following dictionary {geni_rspec:
<geni.rspec, a Manifest RSpec>, geni_urn: <string slice urn of the
containing slice>, geni_slivers:{ geni_sliver_urn:
<string sliver urn>, geni_expires: <dateTime.rfc3339 allocation
expiration string, as in geni_expires from SliversStatus>,
geni_allocation_status: <string sliver state - e.g. geni_allocated
or geni_provisioned >, geni_operational_status:
<string sliver operational state>, geni_error: <optional string.
The field may be omitted entirely but may not be null/None,
explaining any failure for a sliver.>}
.. seealso:: http://groups.geni.net/geni/wiki/GAPI_AM_API_V3#Describe
.. seealso:: http://groups.geni.net/geni/wiki/GAPI_AM_API_V3/CommonConcepts#urns
"""
if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(
version.type, version.version, 'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# get slivers
geni_slivers = []
slivers = self.get_slivers(urns, options)
if slivers:
rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
else:
rspec_expires = datetime_to_string(utcparse(time.time()))
rspec.xml.set('expires', rspec_expires)
# lookup the sliver allocations
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
query = self.driver.api.dbsession().query(SliverAllocation)
sliver_allocations = query.filter((constraint)).all()
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
sliver_allocation_dict[sliver_allocation.sliver_id] = \
sliver_allocation
if not options.get('list_leases') or options['list_leases'] != 'leases':
# add slivers
nodes_dict = {}
for sliver in slivers:
nodes_dict[sliver['node_id']] = sliver
rspec_nodes = []
for sliver in slivers:
rspec_node = self.sliver_to_rspec_node(sliver,
sliver_allocation_dict)
rspec_nodes.append(rspec_node)
geni_sliver = self.rspec_node_to_geni_sliver(rspec_node,
sliver_allocation_dict)
geni_slivers.append(geni_sliver)
rspec.version.add_nodes(rspec_nodes)
if not options.get('list_leases') or options['list_leases'] == 'resources':
if slivers:
leases = self.get_leases(slivers[0])
rspec.version.add_leases(leases)
return {'geni_urn': geni_urn,
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers}
def describe(self, urns, version=None, options={}):
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type,
version.version,
'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# get slivers
geni_slivers = []
slivers = self.get_slivers(urns, options)
if slivers:
rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
else:
rspec_expires = datetime_to_string(utcparse(time.time()))
rspec.xml.set('expires', rspec_expires)
# lookup the sliver allocations
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
sliver_allocations = self.driver.api.dbsession().query(
SliverAllocation).filter(constraint)
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
sliver_allocation_dict[
sliver_allocation.sliver_id] = sliver_allocation
if not options.get(
'list_leases') or options['list_leases'] != 'leases':
# add slivers
site_ids = []
interface_ids = []
tag_ids = []
nodes_dict = {}
for sliver in slivers:
site_ids.append(sliver['site_id'])
interface_ids.extend(sliver['interface_ids'])
tag_ids.extend(sliver['node_tag_ids'])
nodes_dict[sliver['node_id']] = sliver
sites = self.get_sites({'site_id': site_ids})
interfaces = self.get_interfaces({'interface_id': interface_ids})
node_tags = self.get_node_tags({'node_tag_id': tag_ids})
pl_initscripts = self.get_pl_initscripts()
rspec_nodes = []
for sliver in slivers:
if sliver['slice_ids_whitelist'] and sliver[
'slice_id'] not in sliver['slice_ids_whitelist']:
continue
rspec_node = self.sliver_to_rspec_node(sliver, sites,
interfaces, node_tags,
pl_initscripts,
sliver_allocation_dict)
# manifest node element shouldn't contain available attribute
rspec_node.pop('available')
rspec_nodes.append(rspec_node)
geni_sliver = self.rspec_node_to_geni_sliver(
rspec_node, sliver_allocation_dict)
geni_slivers.append(geni_sliver)
rspec.version.add_nodes(rspec_nodes)
# add sliver defaults
#default_sliver = slivers.get(None, [])
#if default_sliver:
# default_sliver_attribs = default_sliver.get('tags', [])
# for attrib in default_sliver_attribs:
# rspec.version.add_default_sliver_attribute(attrib['tagname'], attrib['value'])
# add links
links = self.get_links(sites, nodes_dict, interfaces)
rspec.version.add_links(links)
if not options.get(
'list_leases') or options['list_leases'] != 'resources':
if slivers:
leases = self.get_leases(slivers[0])
rspec.version.add_leases(leases)
return {
'geni_urn': geni_urn,
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers
}
def fill_record_hrns(self, records):
"""
convert pl ids to hrns
"""
# get ids
slice_ids, person_ids, site_ids, node_ids = [], [], [], []
for record in records:
if 'site_id' in record:
site_ids.append(record['site_id'])
if 'site_ids' in record:
site_ids.extend(record['site_ids'])
if 'person_ids' in record:
person_ids.extend(record['person_ids'])
if 'slice_ids' in record:
slice_ids.extend(record['slice_ids'])
if 'node_ids' in record:
node_ids.extend(record['node_ids'])
# get pl records
slices, persons, sites, nodes = {}, {}, {}, {}
if site_ids:
site_list = self.shell.GetSites(site_ids, ['site_id', 'login_base'])
sites = list_to_dict(site_list, 'site_id')
if person_ids:
person_list = self.shell.GetPersons(person_ids, ['person_id', 'email'])
persons = list_to_dict(person_list, 'person_id')
if slice_ids:
slice_list = self.shell.GetSlices(slice_ids, ['slice_id', 'name'])
slices = list_to_dict(slice_list, 'slice_id')
if node_ids:
node_list = self.shell.GetNodes(node_ids, ['node_id', 'hostname'])
nodes = list_to_dict(node_list, 'node_id')
# convert ids to hrns
for record in records:
# get all relevant data
type = record['type']
pointer = record['pointer']
auth_hrn = self.hrn
login_base = ''
if pointer == -1:
continue
if 'site_id' in record:
site = sites[record['site_id']]
login_base = site['login_base']
record['site'] = ".".join([auth_hrn, login_base])
if 'person_ids' in record:
emails = [persons[person_id]['email'] for person_id in record['person_ids'] \
if person_id in persons]
usernames = [email.split('@')[0] for email in emails]
person_hrns = [".".join([auth_hrn, login_base, username]) for username in usernames]
record['persons'] = person_hrns
if 'slice_ids' in record:
slicenames = [slices[slice_id]['name'] for slice_id in record['slice_ids'] \
if slice_id in slices]
slice_hrns = [slicename_to_hrn(auth_hrn, slicename) for slicename in slicenames]
record['slices'] = slice_hrns
if 'node_ids' in record:
hostnames = [nodes[node_id]['hostname'] for node_id in record['node_ids'] \
if node_id in nodes]
node_hrns = [hostname_to_hrn(auth_hrn, login_base, hostname) for hostname in hostnames]
record['nodes'] = node_hrns
if 'site_ids' in record:
login_bases = [sites[site_id]['login_base'] for site_id in record['site_ids'] \
if site_id in sites]
site_hrns = [".".join([auth_hrn, lbase]) for lbase in login_bases]
record['sites'] = site_hrns
if 'expires' in record:
date = utcparse(record['expires'])
datestring = datetime_to_string(date)
record['expires'] = datestring
return records
def describe(self, urns, version=None, options=None):
"""
describe method returns slice slivers (allocated resources) and leases
(OAR job submission). We search in lease table of SFA database all OAR
jobs id for this slice and match OAR jobs with state Waiting or Running.
If OAR job id doesn't exist the experiment is terminated and we delete
the database table entry. Otherwise we add slivers and leases in the
response
:returns:
geni_slivers : a list of allocated slivers with information about
their allocation and operational state
geni_urn : the URN of the slice in which the sliver has been
allocated
geni_rspec: a RSpec describing the allocated slivers and leases
:rtype: dict
:Example:
<rspec>
...
<node component_manager_id="urn:publicid:IDN+iotlab+authority+sa"
component_id=
"urn:publicid:IDN+iotlab+node+m3-10.grenoble.iot-lab.info"
client_id="m3-10.grenoble.iot-lab.info"
sliver_id="urn:publicid:IDN+iotlab+sliver+9953-m3-10"
exclusive="true" component_name="m3-10.grenoble.iot-lab.info">
<hardware_type name="iotlab-node"/>
<location country="France"/>
<granularity grain="30"/>
<sliver_type name="iotlab-exclusive"/>
</node>
<lease slice_id="urn:publicid:IDN+onelab:inria+slice+test_iotlab"
start_time="1427792428" duration="29">
<node component_id=
"urn:publicid:IDN+iotlab+node+m3-10.grenoble.iot-lab.info"/>
</lease>
...
</rspec>
"""
# pylint:disable=R0914,W0212
logger.warning("iotlabaggregate describe")
logger.warning("iotlabaggregate describe urns : %s" % urns)
if not options:
options = {}
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, "manifest")
rspec = RSpec(version=rspec_version, user_options=options)
xrn = Xrn(urns[0])
geni_slivers = []
nodes = self.driver.shell.get_nodes()
reserved_nodes = self.driver.shell.get_reserved_nodes()
if not "error" in nodes and not "error" in reserved_nodes:
# find OAR jobs id for one slice in SFA database
db_leases = [
(lease.job_id, lease.slice_hrn)
for lease in self.driver.api.dbsession().query(LeaseTable).filter(LeaseTable.slice_hrn == xrn.hrn).all()
]
leases = []
for job_id, slice_hrn in db_leases:
# OAR job terminated, we delete entry in database
if not job_id in reserved_nodes:
self._delete_db_lease(job_id)
else:
# onelab slice = job submission from OneLAB
lease = reserved_nodes[job_id]
lease["slice_id"] = hrn_to_urn(slice_hrn, "slice")
leases.append(lease)
# get slivers
slivers = self.get_slivers(urns, leases, nodes)
if slivers:
date = utcparse(slivers[0]["expires"])
rspec_expires = datetime_to_string(date)
else:
rspec_expires = datetime_to_string(utcparse(time.time()))
rspec.xml.set("expires", rspec_expires)
rspec_nodes = []
for sliver in slivers:
rspec_node = self.sliver_to_rspec_node(sliver)
rspec_nodes.append(rspec_node)
geni_sliver = self.rspec_node_to_geni_sliver(rspec_node)
geni_slivers.append(geni_sliver)
logger.warning("iotlabaggregate describe geni_slivers %s" % geni_slivers)
rspec.version.add_nodes(rspec_nodes)
rspec_leases = self.leases_to_rspec_leases(leases)
logger.warning("iotlabaggregate describe rspec_leases %s" % rspec_leases)
rspec.version.add_leases(rspec_leases)
return {"geni_urn": urns[0], "geni_rspec": rspec.toxml(), "geni_slivers": geni_slivers}
def sliver_to_rspec_node(self, sliver):
""" Get node and sliver attributes """
rspec_node = self.node_to_rspec_node(sliver)
rspec_node["expires"] = datetime_to_string(utcparse(sliver["expires"]))
rspec_node["sliver_id"] = sliver["sliver_id"]
return rspec_node
def fill_record_hrns(self, records):
"""
convert nitos ids to hrns
"""
# get ids
slice_ids, user_ids, node_ids = [], [], []
for record in records:
if 'user_ids' in record:
user_ids.extend(record['user_ids'])
if 'slice_ids' in record:
slice_ids.extend(record['slice_ids'])
if 'node_ids' in record:
node_ids.extend(record['node_ids'])
# get nitos records
slices, users, nodes = {}, {}, {}
if node_ids:
all_nodes = self.convert_id(self.shell.getNodes({}, []))
node_list = [
node for node in all_nodes if node['node_id'] in node_ids
]
nodes = list_to_dict(node_list, 'node_id')
if slice_ids:
all_slices = self.convert_id(self.shell.getSlices({}, []))
slice_list = [
slice for slice in all_slices if slice['slice_id'] in slice_ids
]
slices = list_to_dict(slice_list, 'slice_id')
if user_ids:
all_users = self.convert_id(self.shell.getUsers())
user_list = [
user for user in all_users if user['user_id'] in user_ids
]
users = list_to_dict(user_list, 'user_id')
# convert ids to hrns
for record in records:
# get all relevant data
type = record['type']
pointer = record['pointer']
auth_hrn = self.hrn
testbed_name = self.testbedInfo['name']
if pointer == -1:
continue
if 'user_ids' in record:
usernames = [users[user_id]['username'] for user_id in record['user_ids'] \
if user_id in users]
user_hrns = [
".".join([auth_hrn, testbed_name, username])
for username in usernames
]
record['users'] = user_hrns
if 'slice_ids' in record:
slicenames = [slices[slice_id]['slice_name'] for slice_id in record['slice_ids'] \
if slice_id in slices]
slice_hrns = [
slicename_to_hrn(auth_hrn, slicename)
for slicename in slicenames
]
record['slices'] = slice_hrns
if 'node_ids' in record:
hostnames = [nodes[node_id]['hostname'] for node_id in record['node_ids'] \
if node_id in nodes]
node_hrns = [
hostname_to_hrn(auth_hrn, login_base, hostname)
for hostname in hostnames
]
record['nodes'] = node_hrns
if 'expires' in record:
date = utcparse(record['expires'])
datestring = datetime_to_string(date)
record['expires'] = datestring
return records
def describe(self, urns, version=None, options={}):
"""
Retrieve a manifest RSpec describing the resources contained by the
named entities, e.g. a single slice or a set of the slivers in a slice.
This listing and description should be sufficiently descriptive to allow
experimenters to use the resources.
:param urns: If a slice urn is supplied and there are no slivers in the
given slice at this aggregate, then geni_rspec shall be a valid
manifest RSpec, containing no node elements - no resources.
:type urns: list or strings
:param options: various options. the valid options are: {boolean
geni_compressed <optional>; struct geni_rspec_version { string type;
#case insensitive , string version; # case insensitive}}
:type options: dictionary
:returns: On success returns the following dictionary {geni_rspec:
<geni.rspec, a Manifest RSpec>, geni_urn: <string slice urn of the
containing slice>, geni_slivers:{ geni_sliver_urn:
<string sliver urn>, geni_expires: <dateTime.rfc3339 allocation
expiration string, as in geni_expires from SliversStatus>,
geni_allocation_status: <string sliver state - e.g. geni_allocated
or geni_provisioned >, geni_operational_status:
<string sliver operational state>, geni_error: <optional string.
The field may be omitted entirely but may not be null/None,
explaining any failure for a sliver.>}
.. seealso:: http://groups.geni.net/geni/wiki/GAPI_AM_API_V3#Describe
.. seealso:: http://groups.geni.net/geni/wiki/GAPI_AM_API_V3/CommonConcepts#urns
"""
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type,
version.version,
'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# get slivers
geni_slivers = []
slivers = self.get_slivers(urns, options)
if slivers:
rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
else:
rspec_expires = datetime_to_string(utcparse(time.time()))
rspec.xml.set('expires', rspec_expires)
# lookup the sliver allocations
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
logger.debug(" Cortexlabaggregate.PY \tDescribe sliver_ids %s " %
(sliver_ids))
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
query = self.driver.api.dbsession().query(SliverAllocation)
sliver_allocations = query.filter((constraint)).all()
logger.debug(
" Cortexlabaggregate.PY \tDescribe sliver_allocations %s " %
(sliver_allocations))
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
sliver_allocation_dict[sliver_allocation.sliver_id] = \
sliver_allocation
# add slivers
nodes_dict = {}
for sliver in slivers:
nodes_dict[sliver['node_id']] = sliver
rspec_nodes = []
for sliver in slivers:
rspec_node = self.sliver_to_rspec_node(sliver,
sliver_allocation_dict)
rspec_nodes.append(rspec_node)
logger.debug(
" Cortexlabaggregate.PY \tDescribe sliver_allocation_dict %s "
% (sliver_allocation_dict))
geni_sliver = self.rspec_node_to_geni_sliver(
rspec_node, sliver_allocation_dict)
geni_slivers.append(geni_sliver)
logger.debug(" Cortexlabaggregate.PY \tDescribe rspec_nodes %s\
rspec %s " % (rspec_nodes, rspec))
rspec.version.add_nodes(rspec_nodes)
return {
'geni_urn': geni_urn,
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers
}
def fill_record_hrns(self, records):
"""
Convert C-Lab names of the records in the list to hrns
:param record: list of SFA records whose names are converted
:type list
:returns list of SFA records filled with hrn
:rtype list
"""
# get ids
slice_ids, user_ids, node_ids = [], [], []
for record in records:
if 'user_ids' in record:
user_ids.extend(record['user_ids'])
if 'slice_ids' in record:
slice_ids.extend(record['slice_ids'])
if 'node_ids' in record:
node_ids.extend(record['node_ids'])
# get clab records
nodes, slices, users, keys = {}, {}, {}, {}
if node_ids:
all_nodes = self.convert_id(self.driver.testbed_shell.get_nodes())
node_list = [node for node in all_nodes if node['id'] in node_ids]
nodes = self.list_to_dict(node_list, 'id')
if slice_ids:
all_slices = self.convert_id(self.driver.testbed_shell.get_slices())
slice_list = [slice for slice in all_slices if slice['id'] in slice_ids]
slices = self.list_to_dict(slice_list, 'id')
if user_ids:
all_users = self.convert_id(self.driver.testbed_shell.get_users())
user_list = [user for user in all_users if user['id'] in user_ids]
users = self.list_to_dict(user_list, 'id')
# convert ids to hrns
for record in records:
# get all relevant data
type = record['type']
pointer = record['pointer']
auth_hrn = self.driver.AUTHORITY
if pointer == -1:
continue
if 'user_ids' in record:
usernames = [users[user_id]['name'] for user_id in record['user_ids'] if user_id in users]
user_hrns = [".".join([auth_hrn, username]) for username in usernames]
record['users'] = user_hrns
if 'slice_ids' in record:
slicenames = [slices[slice_id]['name'] for slice_id in record['slice_ids'] if slice_id in slices]
slice_hrns = [slicename_to_hrn(slicename, auth_hrn) for slicename in slicenames]
record['slices'] = slice_hrns
if 'node_ids' in record:
hostnames = [nodes[node_id]['name'] for node_id in record['node_ids'] if node_id in nodes]
node_hrns = [hostname_to_hrn(auth_hrn, hostname) for hostname in hostnames]
record['nodes'] = node_hrns
if 'expires' in record:
date = utcparse(record['expires'])
datestring = datetime_to_string(date)
record['expires'] = datestring
return records
def describe(self, urns, version=None, options=None):
if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
rspec = RSpec(version=rspec_version, user_options=options)
# get slivers
geni_slivers = []
slivers = self.get_slivers(urns, options)
if slivers:
rspec_expires = datetime_to_string(utcparse(slivers[0]['expires']))
else:
rspec_expires = datetime_to_string(utcparse(time.time()))
rspec.xml.set('expires', rspec_expires)
# lookup the sliver allocations
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
sliver_allocations = self.driver.api.dbsession().query(SliverAllocation).filter(constraint)
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
sliver_allocation_dict[sliver_allocation.sliver_id] = sliver_allocation
if not options.get('list_leases') or options['list_leases'] != 'leases':
# add slivers
site_ids = []
interface_ids = []
tag_ids = []
nodes_dict = {}
for sliver in slivers:
site_ids.append(sliver['site_id'])
interface_ids.extend(sliver['interface_ids'])
tag_ids.extend(sliver['node_tag_ids'])
nodes_dict[sliver['node_id']] = sliver
sites = self.get_sites({'site_id': site_ids})
interfaces = self.get_interfaces({'interface_id':interface_ids})
node_tags = self.get_node_tags({'node_tag_id': tag_ids})
pl_initscripts = self.get_pl_initscripts()
rspec_nodes = []
for sliver in slivers:
if sliver['slice_ids_whitelist'] and sliver['slice_id'] not in sliver['slice_ids_whitelist']:
continue
rspec_node = self.sliver_to_rspec_node(sliver, sites, interfaces, node_tags,
pl_initscripts, sliver_allocation_dict)
# manifest node element shouldn't contain available attribute
rspec_node.pop('available')
rspec_nodes.append(rspec_node)
geni_sliver = self.rspec_node_to_geni_sliver(rspec_node, sliver_allocation_dict)
geni_slivers.append(geni_sliver)
rspec.version.add_nodes(rspec_nodes)
# add sliver defaults
#default_sliver = slivers.get(None, [])
#if default_sliver:
# default_sliver_attribs = default_sliver.get('tags', [])
# for attrib in default_sliver_attribs:
# rspec.version.add_default_sliver_attribute(attrib['tagname'], attrib['value'])
# add links
links = self.get_links(sites, nodes_dict, interfaces)
rspec.version.add_links(links)
if not options.get('list_leases') or options['list_leases'] != 'resources':
if slivers:
leases = self.get_leases(slivers[0])
rspec.version.add_leases(leases)
return {'geni_urn': geni_urn,
'geni_rspec': rspec.toxml(),
'geni_slivers': geni_slivers}
def fill_record_hrns(self, records):
"""
convert nitos ids to hrns
"""
# get ids
slice_ids, user_ids, node_ids = [], [], []
for record in records:
if 'user_ids' in record:
user_ids.extend(record['user_ids'])
if 'slice_ids' in record:
slice_ids.extend(record['slice_ids'])
if 'node_ids' in record:
node_ids.extend(record['node_ids'])
# get nitos records
slices, users, nodes = {}, {}, {}
if node_ids:
all_nodes = self.convert_id(self.shell.getNodes({}, []))
node_list = [node for node in all_nodes if node['node_id'] in node_ids]
nodes = list_to_dict(node_list, 'node_id')
if slice_ids:
all_slices = self.convert_id(self.shell.getSlices({}, []))
slice_list = [slice for slice in all_slices if slice['slice_id'] in slice_ids]
slices = list_to_dict(slice_list, 'slice_id')
if user_ids:
all_users = self.convert_id(self.shell.getUsers())
user_list = [user for user in all_users if user['user_id'] in user_ids]
users = list_to_dict(user_list, 'user_id')
# convert ids to hrns
for record in records:
# get all relevant data
type = record['type']
pointer = record['pointer']
auth_hrn = self.hrn
testbed_name = self.testbedInfo['name']
if pointer == -1:
continue
if 'user_ids' in record:
usernames = [users[user_id]['username'] for user_id in record['user_ids'] \
if user_id in users]
user_hrns = [".".join([auth_hrn, testbed_name, username]) for username in usernames]
record['users'] = user_hrns
if 'slice_ids' in record:
slicenames = [slices[slice_id]['slice_name'] for slice_id in record['slice_ids'] \
if slice_id in slices]
slice_hrns = [slicename_to_hrn(auth_hrn, slicename) for slicename in slicenames]
record['slices'] = slice_hrns
if 'node_ids' in record:
hostnames = [nodes[node_id]['hostname'] for node_id in record['node_ids'] \
if node_id in nodes]
node_hrns = [hostname_to_hrn(auth_hrn, login_base, hostname) for hostname in hostnames]
record['nodes'] = node_hrns
if 'expires' in record:
date = utcparse(record['expires'])
datestring = datetime_to_string(date)
record['expires'] = datestring
return records
def sliver_status (self, slice_urn, slice_hrn):
# find out where this slice is currently running
slicename = hrn_to_pl_slicename(slice_hrn)
slices = self.shell.GetSlices([slicename], ['slice_id', 'node_ids','person_ids','name','expires'])
if len(slices) == 0:
raise SliverDoesNotExist("%s (used %s as slicename internally)" % (slice_hrn, slicename))
slice = slices[0]
# report about the local nodes only
nodes = self.shell.GetNodes({'node_id':slice['node_ids'],'peer_id':None},
['node_id', 'hostname', 'site_id', 'boot_state', 'last_contact'])
if len(nodes) == 0:
raise SliverDoesNotExist("You have not allocated any slivers here")
# get login info
user = {}
if slice['person_ids']:
persons = self.shell.GetPersons(slice['person_ids'], ['key_ids'])
key_ids = [key_id for person in persons for key_id in person['key_ids']]
person_keys = self.shell.GetKeys(key_ids)
keys = [key['key'] for key in person_keys]
user.update({'urn': slice_urn,
'login': slice['name'],
'protocol': ['ssh'],
'port': ['22'],
'keys': keys})
site_ids = [node['site_id'] for node in nodes]
result = {}
top_level_status = 'unknown'
if nodes:
top_level_status = 'ready'
result['geni_urn'] = slice_urn
result['pl_login'] = slice['name']
result['pl_expires'] = datetime_to_string(utcparse(slice['expires']))
result['geni_expires'] = datetime_to_string(utcparse(slice['expires']))
resources = []
for node in nodes:
res = {}
res['pl_hostname'] = node['hostname']
res['pl_boot_state'] = node['boot_state']
res['pl_last_contact'] = node['last_contact']
res['geni_expires'] = datetime_to_string(utcparse(slice['expires']))
if node['last_contact'] is not None:
res['pl_last_contact'] = datetime_to_string(utcparse(node['last_contact']))
sliver_xrn = Xrn(slice_urn, type='sliver', id=node['node_id'])
sliver_xrn.set_authority(self.hrn)
res['geni_urn'] = sliver_xrn.urn
if node['boot_state'] == 'boot':
res['geni_status'] = 'ready'
else:
res['geni_status'] = 'failed'
top_level_status = 'failed'
res['geni_error'] = ''
res['users'] = [user]
resources.append(res)
result['geni_status'] = top_level_status
result['geni_resources'] = resources
return result
def fill_record_hrns(self, records):
"""
convert pl ids to hrns
"""
# get ids
slice_ids, person_ids, site_ids, node_ids = [], [], [], []
for record in records:
if 'site_id' in record:
site_ids.append(record['site_id'])
if 'site_ids' in record:
site_ids.extend(record['site_ids'])
if 'person_ids' in record:
person_ids.extend(record['person_ids'])
if 'slice_ids' in record:
slice_ids.extend(record['slice_ids'])
if 'node_ids' in record:
node_ids.extend(record['node_ids'])
# get pl records
slices, persons, sites, nodes = {}, {}, {}, {}
if site_ids:
site_list = self.shell.GetSites(
{
'peer_id': None,
'site_id': site_ids
}, ['site_id', 'login_base'])
sites = list_to_dict(site_list, 'site_id')
if person_ids:
person_list = self.shell.GetPersons(
{
'peer_id': None,
'person_id': person_ids
}, ['person_id', 'email'])
persons = list_to_dict(person_list, 'person_id')
if slice_ids:
slice_list = self.shell.GetSlices(
{
'peer_id': None,
'slice_id': slice_ids
}, ['slice_id', 'name'])
slices = list_to_dict(slice_list, 'slice_id')
if node_ids:
node_list = self.shell.GetNodes(
{
'peer_id': None,
'node_id': node_ids
}, ['node_id', 'hostname'])
nodes = list_to_dict(node_list, 'node_id')
# convert ids to hrns
for record in records:
# get all relevant data
type = record['type']
pointer = record['pointer']
auth_hrn = self.hrn
login_base = ''
if pointer == -1:
continue
if 'site_id' in record:
site = sites[record['site_id']]
login_base = site['login_base']
record['site'] = ".".join([auth_hrn, login_base])
if 'person_ids' in record:
emails = [persons[person_id]['email'] for person_id in record['person_ids'] \
if person_id in persons]
usernames = [email.split('@')[0] for email in emails]
person_hrns = [
".".join([auth_hrn, login_base, username])
for username in usernames
]
record['persons'] = person_hrns
if 'slice_ids' in record:
slicenames = [slices[slice_id]['name'] for slice_id in record['slice_ids'] \
if slice_id in slices]
slice_hrns = [
slicename_to_hrn(auth_hrn, slicename)
for slicename in slicenames
]
record['slices'] = slice_hrns
if 'node_ids' in record:
hostnames = [nodes[node_id]['hostname'] for node_id in record['node_ids'] \
if node_id in nodes]
node_hrns = [
hostname_to_hrn(auth_hrn, login_base, hostname)
for hostname in hostnames
]
record['nodes'] = node_hrns
if 'site_ids' in record:
login_bases = [sites[site_id]['login_base'] for site_id in record['site_ids'] \
if site_id in sites]
site_hrns = [
".".join([auth_hrn, lbase]) for lbase in login_bases
]
record['sites'] = site_hrns
if 'expires' in record:
date = utcparse(record['expires'])
datestring = datetime_to_string(date)
record['expires'] = datestring
return records
