def verify_slice(self, slice_hrn, slice_record, peer, sfa_peer, options={}):
slicename = hrn_to_pl_slicename(slice_hrn)
parts = slicename.split("_")
login_base = parts[0]
slices = self.driver.shell.GetSlices([slicename])
if not slices:
slice = {'name': slicename,
'url': slice_record.get('url', slice_hrn),
'description': slice_record.get('description', slice_hrn)}
# add the slice
slice['slice_id'] = self.driver.shell.AddSlice(slice)
slice['node_ids'] = []
slice['person_ids'] = []
if peer:
slice['peer_slice_id'] = slice_record.get('slice_id', None)
# mark this slice as an sfa peer record
# if sfa_peer:
# peer_dict = {'type': 'slice', 'hrn': slice_hrn,
# 'peer_authority': sfa_peer, 'pointer': slice['slice_id']}
# self.registry.register_peer_object(self.credential, peer_dict)
else:
slice = slices[0]
if peer:
slice['peer_slice_id'] = slice_record.get('slice_id', None)
# unbind from peer so we can modify if necessary. Will bind back later
self.driver.shell.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
#Update existing record (e.g. expires field) it with the latest info.
if slice_record.get('expires'):
requested_expires = int(datetime_to_epoch(utcparse(slice_record['expires'])))
if requested_expires and slice['expires'] != requested_expires:
self.driver.shell.UpdateSlice( slice['slice_id'], {'expires' : requested_expires})
return slice
def start_slice (self, slice_urn, slice_hrn, creds):
slicename = hrn_to_pl_slicename(slice_hrn)
slices = self.shell.GetSlices({'name': slicename}, ['slice_id'])
if not slices:
raise RecordNotFound(slice_hrn)
slice_id = slices[0]['slice_id']
slice_tags = self.shell.GetSliceTags({'slice_id': slice_id, 'tagname': 'enabled'}, ['slice_tag_id'])
# just remove the tag if it exists
if slice_tags:
self.shell.DeleteSliceTag(slice_tags[0]['slice_tag_id'])
return 1
def verify_slice_leases(self, slice, rspec_requested_leases, peer):
leases = self.driver.shell.GetLeases({'name':slice['name'], 'clip':int(time.time())}, ['lease_id','name', 'hostname', 't_from', 't_until'])
grain = self.driver.shell.GetLeaseGranularity()
requested_leases = []
for lease in rspec_requested_leases:
requested_lease = {}
slice_name = hrn_to_pl_slicename(lease['slice_id'])
if slice_name != slice['name']:
continue
elif Xrn(lease['component_id']).get_authority_urn().split(':')[0] != self.driver.hrn:
continue
hostname = xrn_to_hostname(lease['component_id'])
# fill the requested node with nitos ids
requested_lease['name'] = slice['name']
requested_lease['hostname'] = hostname
requested_lease['t_from'] = int(lease['start_time'])
requested_lease['t_until'] = int(lease['duration']) * grain + int(lease['start_time'])
requested_leases.append(requested_lease)
# prepare actual slice leases by lease_id
leases_by_id = {}
for lease in leases:
leases_by_id[lease['lease_id']] = {'name': lease['name'], 'hostname': lease['hostname'], \
't_from': lease['t_from'], 't_until': lease['t_until']}
added_leases = []
kept_leases_id = []
deleted_leases_id = []
for lease_id in leases_by_id:
if leases_by_id[lease_id] not in requested_leases:
deleted_leases_id.append(lease_id)
else:
kept_leases_id.append(lease_id)
requested_leases.remove(leases_by_id[lease_id])
added_leases = requested_leases
try:
if peer:
self.driver.shell.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
self.driver.shell.DeleteLeases(deleted_leases_id)
for lease in added_leases:
self.driver.shell.AddLeases(lease['hostname'], slice['name'], lease['t_from'], lease['t_until'])
except:
logger.log_exc('Failed to add/remove slice leases')
return leases
def stop_slice (self, slice_urn, slice_hrn, creds):
slicename = hrn_to_pl_slicename(slice_hrn)
slices = self.shell.GetSlices({'name': slicename}, ['slice_id'])
if not slices:
raise RecordNotFound(slice_hrn)
slice_id = slices[0]['slice_id']
slice_tags = self.shell.GetSliceTags({'slice_id': slice_id, 'tagname': 'enabled'})
if not slice_tags:
self.shell.AddSliceTag(slice_id, 'enabled', '0')
elif slice_tags[0]['value'] != "0":
tag_id = slice_tags[0]['slice_tag_id']
self.shell.UpdateSliceTag(tag_id, '0')
return 1
def renew_sliver (self, slice_urn, slice_hrn, creds, expiration_time, options):
slicename = hrn_to_pl_slicename(slice_hrn)
slices = self.shell.GetSlices({'name': slicename}, ['slice_id'])
if not slices:
raise RecordNotFound(slice_hrn)
slice = slices[0]
requested_time = utcparse(expiration_time)
record = {'expires': int(datetime_to_epoch(requested_time))}
try:
self.shell.UpdateSlice(slice['slice_id'], record)
return True
except:
return False
def sfa_fields_to_pl_fields(self, type, hrn, sfa_record):
pl_record = {}
if type == "slice":
pl_record["name"] = hrn_to_pl_slicename(hrn)
if "instantiation" in sfa_record:
pl_record['instantiation'] = sfa_record['instantiation']
else:
pl_record["instantiation"] = "plc-instantiated"
if "url" in sfa_record:
pl_record["url"] = sfa_record["url"]
if "description" in sfa_record:
pl_record["description"] = sfa_record["description"]
if "expires" in sfa_record:
date = utcparse(sfa_record['expires'])
expires = datetime_to_epoch(date)
pl_record["expires"] = expires
elif type == "node":
if not "hostname" in pl_record:
# fetch from sfa_record
if "hostname" not in sfa_record:
raise MissingSfaInfo("hostname")
pl_record["hostname"] = sfa_record["hostname"]
if "model" in sfa_record:
pl_record["model"] = sfa_record["model"]
else:
pl_record["model"] = "geni"
elif type == "authority":
pl_record["login_base"] = PlXrn(xrn=hrn,
type='authority').pl_login_base()
if "name" not in sfa_record:
pl_record["name"] = hrn
if "abbreviated_name" not in sfa_record:
pl_record["abbreviated_name"] = hrn
if "enabled" not in sfa_record:
pl_record["enabled"] = True
if "is_public" not in sfa_record:
pl_record["is_public"] = True
return pl_record
def sfa_fields_to_pl_fields(self, type, hrn, sfa_record):
pl_record = {}
if type == "slice":
pl_record["name"] = hrn_to_pl_slicename(hrn)
if "instantiation" in sfa_record:
pl_record['instantiation']=sfa_record['instantiation']
else:
pl_record["instantiation"] = "plc-instantiated"
if "url" in sfa_record:
pl_record["url"] = sfa_record["url"]
if "description" in sfa_record:
pl_record["description"] = sfa_record["description"]
if "expires" in sfa_record:
date = utcparse(sfa_record['expires'])
expires = datetime_to_epoch(date)
pl_record["expires"] = expires
elif type == "node":
if not "hostname" in pl_record:
# fetch from sfa_record
if "hostname" not in sfa_record:
raise MissingSfaInfo("hostname")
pl_record["hostname"] = sfa_record["hostname"]
if "model" in sfa_record:
pl_record["model"] = sfa_record["model"]
else:
pl_record["model"] = "geni"
elif type == "authority":
pl_record["login_base"] = PlXrn(xrn=hrn,type='authority').pl_login_base()
if "name" not in sfa_record:
pl_record["name"] = hrn
if "abbreviated_name" not in sfa_record:
pl_record["abbreviated_name"] = hrn
if "enabled" not in sfa_record:
pl_record["enabled"] = True
if "is_public" not in sfa_record:
pl_record["is_public"] = True
return pl_record
def delete_sliver (self, slice_urn, slice_hrn, creds, options):
slicename = hrn_to_pl_slicename(slice_hrn)
slices = self.shell.GetSlices({'name': slicename})
if not slices:
return True
slice = slices[0]
# 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
peer = peers.get_peer(self, slice_hrn)
try:
if peer:
self.shell.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
self.shell.DeleteSliceFromNodes(slicename, slice['node_ids'])
finally:
if peer:
self.shell.BindObjectToPeer('slice', slice['slice_id'], peer, slice['peer_slice_id'])
return True
def get_slice_and_slivers(self, slice_xrn):
"""
Returns a dict of slivers keyed on the sliver's node_id
"""
slivers = {}
slice = None
if not slice_xrn:
return (slice, slivers)
slice_urn = hrn_to_urn(slice_xrn, 'slice')
slice_hrn, _ = urn_to_hrn(slice_xrn)
slice_name = hrn_to_pl_slicename(slice_hrn)
slices = self.driver.shell.GetSlices(slice_name)
if not slices:
return (slice, slivers)
slice = slices[0]
# sort slivers by node id
for node_id in slice['node_ids']:
sliver_xrn = Xrn(slice_urn, type='sliver', id=node_id)
sliver_xrn.set_authority(self.driver.hrn)
sliver = Sliver({'sliver_id': sliver_xrn.urn,
'name': slice['name'],
'type': 'plab-vserver',
'tags': []})
slivers[node_id]= sliver
# sort sliver attributes by node id
tags = self.driver.shell.GetSliceTags({'slice_tag_id': slice['slice_tag_ids']})
for tag in tags:
# most likely a default/global sliver attribute (node_id == None)
if tag['node_id'] not in slivers:
sliver_xrn = Xrn(slice_urn, type='sliver', id=tag['node_id'])
sliver_xrn.set_authority(self.driver.hrn)
sliver = Sliver({'sliver_id': sliver_xrn.urn,
'name': slice['name'],
'type': 'plab-vserver',
'tags': []})
slivers[tag['node_id']] = sliver
slivers[tag['node_id']]['tags'].append(tag)
return (slice, slivers)
def verify_site(self, slice_xrn, slice_record={}, peer=None, sfa_peer=None, options={}):
(slice_hrn, type) = urn_to_hrn(slice_xrn)
site_hrn = get_authority(slice_hrn)
# login base can't be longer than 20 characters
slicename = hrn_to_pl_slicename(slice_hrn)
authority_name = slicename.split('_')[0]
login_base = authority_name[:20]
sites = self.driver.shell.GetSites(login_base)
if not sites:
# create new site record
site = {'name': 'geni.%s' % authority_name,
'abbreviated_name': authority_name,
'login_base': login_base,
'max_slices': 100,
'max_slivers': 1000,
'enabled': True,
'peer_site_id': None}
if peer:
site['peer_site_id'] = slice_record.get('site_id', None)
site['site_id'] = self.driver.shell.AddSite(site)
# exempt federated sites from monitor policies
self.driver.shell.AddSiteTag(site['site_id'], 'exempt_site_until', "20200101")
# # is this still necessary?
# # add record to the local registry
# if sfa_peer and slice_record:
# peer_dict = {'type': 'authority', 'hrn': site_hrn, \
# 'peer_authority': sfa_peer, 'pointer': site['site_id']}
# self.registry.register_peer_object(self.credential, peer_dict)
else:
site = sites[0]
if peer:
# unbind from peer so we can modify if necessary. Will bind back later
self.driver.shell.UnBindObjectFromPeer('site', site['site_id'], peer['shortname'])
return site
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 get_gids(registry=None, verbose=False):
"""
Get the gid for all instantiated slices on this node and store it
in /etc/sfa/slice.gid in the slice's filesystem
"""
# define useful variables
config = Config()
data_dir = config.data_path
config_dir = config.SFA_CONFIG_DIR
trusted_certs_dir = config.get_trustedroots_dir()
keyfile = data_dir + os.sep + "server.key"
certfile = data_dir + os.sep + "server.cert"
node_gid_file = config_dir + os.sep + "node.gid"
node_gid = GID(filename=node_gid_file)
hrn = node_gid.get_hrn()
interface_hrn = config.SFA_INTERFACE_HRN
# get credential
cred = GetCredential(registry=registry, verbose=verbose)
# make sure server key cert pair exists
create_server_keypair(keyfile=keyfile, certfile=certfile, hrn=hrn, verbose=verbose)
registry = server_proxy(url=registry, keyfile=keyfile, certfile=certfile)
if verbose:
print "Getting current slices on this node"
# get a list of slices on this node
from sfa.generic import Generic
generic=Generic.the_flavour()
api = generic.make_api(interface='component')
xids_tuple = api.driver.nodemanager.GetXIDs()
slices = eval(xids_tuple[1])
slicenames = slices.keys()
# generate a list of slices that dont have gids installed
slices_without_gids = []
for slicename in slicenames:
if not os.path.isfile("/vservers/%s/etc/slice.gid" % slicename) \
or not os.path.isfile("/vservers/%s/etc/node.gid" % slicename):
slices_without_gids.append(slicename)
# convert slicenames to hrns
hrns = [slicename_to_hrn(interface_hrn, slicename) \
for slicename in slices_without_gids]
# exit if there are no gids to install
if not hrns:
return
if verbose:
print "Getting gids for slices on this node from registry"
# get the gids
# and save them in the right palce
records = registry.GetGids(hrns, cred)
for record in records:
# if this isnt a slice record skip it
if not record['type'] == 'slice':
continue
slicename = hrn_to_pl_slicename(record['hrn'])
# if this slice isnt really instatiated skip it
if not os.path.exists("/vservers/%(slicename)s" % locals()):
continue
# save the slice gid in /etc/sfa/ in the vservers filesystem
vserver_path = "/vservers/%(slicename)s" % locals()
gid = record['gid']
slice_gid_filename = os.sep.join([vserver_path, "etc", "slice.gid"])
if verbose:
print "Saving GID for %(slicename)s as %(slice_gid_filename)s" % locals()
GID(string=gid).save_to_file(slice_gid_filename, save_parents=True)
# save the node gid in /etc/sfa
node_gid_filename = os.sep.join([vserver_path, "etc", "node.gid"])
if verbose:
print "Saving node GID for %(slicename)s as %(node_gid_filename)s" % locals()
node_gid.save_to_file(node_gid_filename, save_parents=True)
def get_gids(registry=None, verbose=False):
"""
Get the gid for all instantiated slices on this node and store it
in /etc/sfa/slice.gid in the slice's filesystem
"""
# define useful variables
config = Config()
data_dir = config.data_path
config_dir = config.SFA_CONFIG_DIR
trusted_certs_dir = config.get_trustedroots_dir()
keyfile = data_dir + os.sep + "server.key"
certfile = data_dir + os.sep + "server.cert"
node_gid_file = config_dir + os.sep + "node.gid"
node_gid = GID(filename=node_gid_file)
hrn = node_gid.get_hrn()
interface_hrn = config.SFA_INTERFACE_HRN
# get credential
cred = GetCredential(registry=registry, verbose=verbose)
# make sure server key cert pair exists
create_server_keypair(keyfile=keyfile,
certfile=certfile,
hrn=hrn,
verbose=verbose)
registry = server_proxy(url=registry, keyfile=keyfile, certfile=certfile)
if verbose:
print "Getting current slices on this node"
# get a list of slices on this node
from sfa.generic import Generic
generic = Generic.the_flavour()
api = generic.make_api(interface='component')
xids_tuple = api.driver.nodemanager.GetXIDs()
slices = eval(xids_tuple[1])
slicenames = slices.keys()
# generate a list of slices that dont have gids installed
slices_without_gids = []
for slicename in slicenames:
if not os.path.isfile("/vservers/%s/etc/slice.gid" % slicename) \
or not os.path.isfile("/vservers/%s/etc/node.gid" % slicename):
slices_without_gids.append(slicename)
# convert slicenames to hrns
hrns = [slicename_to_hrn(interface_hrn, slicename) \
for slicename in slices_without_gids]
# exit if there are no gids to install
if not hrns:
return
if verbose:
print "Getting gids for slices on this node from registry"
# get the gids
# and save them in the right palce
records = registry.GetGids(hrns, cred)
for record in records:
# if this isnt a slice record skip it
if not record['type'] == 'slice':
continue
slicename = hrn_to_pl_slicename(record['hrn'])
# if this slice isnt really instatiated skip it
if not os.path.exists("/vservers/%(slicename)s" % locals()):
continue
# save the slice gid in /etc/sfa/ in the vservers filesystem
vserver_path = "/vservers/%(slicename)s" % locals()
gid = record['gid']
slice_gid_filename = os.sep.join([vserver_path, "etc", "slice.gid"])
if verbose:
print "Saving GID for %(slicename)s as %(slice_gid_filename)s" % locals(
)
GID(string=gid).save_to_file(slice_gid_filename, save_parents=True)
# save the node gid in /etc/sfa
node_gid_filename = os.sep.join([vserver_path, "etc", "node.gid"])
if verbose:
print "Saving node GID for %(slicename)s as %(node_gid_filename)s" % locals(
)
node_gid.save_to_file(node_gid_filename, save_parents=True)
def get_slivers(self, xrn, node=None):
hrn, type = urn_to_hrn(xrn)
slice_name = hrn_to_pl_slicename(hrn)
# XX Should we just call PLCAPI.GetSliceTicket(slice_name) instead
# of doing all of this?
#return self.driver.shell.GetSliceTicket(self.auth, slice_name)
# from PLCAPI.GetSlivers.get_slivers()
slice_fields = ['slice_id', 'name', 'instantiation', 'expires', 'person_ids', 'slice_tag_ids']
slices = self.driver.shell.GetSlices(slice_name, slice_fields)
# Build up list of users and slice attributes
person_ids = set()
all_slice_tag_ids = set()
for slice in slices:
person_ids.update(slice['person_ids'])
all_slice_tag_ids.update(slice['slice_tag_ids'])
person_ids = list(person_ids)
all_slice_tag_ids = list(all_slice_tag_ids)
# Get user information
all_persons_list = self.driver.shell.GetPersons({'person_id':person_ids,'enabled':True},
['person_id', 'enabled', 'key_ids'])
all_persons = {}
for person in all_persons_list:
all_persons[person['person_id']] = person
# Build up list of keys
key_ids = set()
for person in all_persons.values():
key_ids.update(person['key_ids'])
key_ids = list(key_ids)
# Get user account keys
all_keys_list = self.driver.shell.GetKeys(key_ids, ['key_id', 'key', 'key_type'])
all_keys = {}
for key in all_keys_list:
all_keys[key['key_id']] = key
# Get slice attributes
all_slice_tags_list = self.driver.shell.GetSliceTags(all_slice_tag_ids)
all_slice_tags = {}
for slice_tag in all_slice_tags_list:
all_slice_tags[slice_tag['slice_tag_id']] = slice_tag
slivers = []
for slice in slices:
keys = []
for person_id in slice['person_ids']:
if person_id in all_persons:
person = all_persons[person_id]
if not person['enabled']:
continue
for key_id in person['key_ids']:
if key_id in all_keys:
key = all_keys[key_id]
keys += [{'key_type': key['key_type'],
'key': key['key']}]
attributes = []
# All (per-node and global) attributes for this slice
slice_tags = []
for slice_tag_id in slice['slice_tag_ids']:
if slice_tag_id in all_slice_tags:
slice_tags.append(all_slice_tags[slice_tag_id])
# Per-node sliver attributes take precedence over global
# slice attributes, so set them first.
# Then comes nodegroup slice attributes
# Followed by global slice attributes
sliver_attributes = []
if node is not None:
for sliver_attribute in filter(lambda a: a['node_id'] == node['node_id'], slice_tags):
sliver_attributes.append(sliver_attribute['tagname'])
attributes.append({'tagname': sliver_attribute['tagname'],
'value': sliver_attribute['value']})
# set nodegroup slice attributes
for slice_tag in filter(lambda a: a['nodegroup_id'] in node['nodegroup_ids'], slice_tags):
# Do not set any nodegroup slice attributes for
# which there is at least one sliver attribute
# already set.
if slice_tag not in slice_tags:
attributes.append({'tagname': slice_tag['tagname'],
'value': slice_tag['value']})
for slice_tag in filter(lambda a: a['node_id'] is None, slice_tags):
# Do not set any global slice attributes for
# which there is at least one sliver attribute
# already set.
if slice_tag['tagname'] not in sliver_attributes:
attributes.append({'tagname': slice_tag['tagname'],
'value': slice_tag['value']})
# XXX Sanity check; though technically this should be a system invariant
# checked with an assertion
if slice['expires'] > MAXINT: slice['expires']= MAXINT
slivers.append({
'hrn': hrn,
'name': slice['name'],
'slice_id': slice['slice_id'],
'instantiation': slice['instantiation'],
'expires': slice['expires'],
'keys': keys,
'attributes': attributes
})
return slivers
def get_slivers(self, xrn, node=None):
hrn, type = urn_to_hrn(xrn)
slice_name = hrn_to_pl_slicename(hrn)
# XX Should we just call PLCAPI.GetSliceTicket(slice_name) instead
# of doing all of this?
#return self.driver.shell.GetSliceTicket(self.auth, slice_name)
# from PLCAPI.GetSlivers.get_slivers()
slice_fields = [
'slice_id', 'name', 'instantiation', 'expires', 'person_ids',
'slice_tag_ids'
]
slices = self.driver.shell.GetSlices(slice_name, slice_fields)
# Build up list of users and slice attributes
person_ids = set()
all_slice_tag_ids = set()
for slice in slices:
person_ids.update(slice['person_ids'])
all_slice_tag_ids.update(slice['slice_tag_ids'])
person_ids = list(person_ids)
all_slice_tag_ids = list(all_slice_tag_ids)
# Get user information
all_persons_list = self.driver.shell.GetPersons(
{
'person_id': person_ids,
'enabled': True
}, ['person_id', 'enabled', 'key_ids'])
all_persons = {}
for person in all_persons_list:
all_persons[person['person_id']] = person
# Build up list of keys
key_ids = set()
for person in all_persons.values():
key_ids.update(person['key_ids'])
key_ids = list(key_ids)
# Get user account keys
all_keys_list = self.driver.shell.GetKeys(
key_ids, ['key_id', 'key', 'key_type'])
all_keys = {}
for key in all_keys_list:
all_keys[key['key_id']] = key
# Get slice attributes
all_slice_tags_list = self.driver.shell.GetSliceTags(all_slice_tag_ids)
all_slice_tags = {}
for slice_tag in all_slice_tags_list:
all_slice_tags[slice_tag['slice_tag_id']] = slice_tag
slivers = []
for slice in slices:
keys = []
for person_id in slice['person_ids']:
if person_id in all_persons:
person = all_persons[person_id]
if not person['enabled']:
continue
for key_id in person['key_ids']:
if key_id in all_keys:
key = all_keys[key_id]
keys += [{
'key_type': key['key_type'],
'key': key['key']
}]
attributes = []
# All (per-node and global) attributes for this slice
slice_tags = []
for slice_tag_id in slice['slice_tag_ids']:
if slice_tag_id in all_slice_tags:
slice_tags.append(all_slice_tags[slice_tag_id])
# Per-node sliver attributes take precedence over global
# slice attributes, so set them first.
# Then comes nodegroup slice attributes
# Followed by global slice attributes
sliver_attributes = []
if node is not None:
for sliver_attribute in filter(
lambda a: a['node_id'] == node['node_id'], slice_tags):
sliver_attributes.append(sliver_attribute['tagname'])
attributes.append({
'tagname': sliver_attribute['tagname'],
'value': sliver_attribute['value']
})
# set nodegroup slice attributes
for slice_tag in filter(
lambda a: a['nodegroup_id'] in node['nodegroup_ids'],
slice_tags):
# Do not set any nodegroup slice attributes for
# which there is at least one sliver attribute
# already set.
if slice_tag not in slice_tags:
attributes.append({
'tagname': slice_tag['tagname'],
'value': slice_tag['value']
})
for slice_tag in filter(lambda a: a['node_id'] is None,
slice_tags):
# Do not set any global slice attributes for
# which there is at least one sliver attribute
# already set.
if slice_tag['tagname'] not in sliver_attributes:
attributes.append({
'tagname': slice_tag['tagname'],
'value': slice_tag['value']
})
# XXX Sanity check; though technically this should be a system invariant
# checked with an assertion
if slice['expires'] > MAXINT: slice['expires'] = MAXINT
slivers.append({
'hrn': hrn,
'name': slice['name'],
'slice_id': slice['slice_id'],
'instantiation': slice['instantiation'],
'expires': slice['expires'],
'keys': keys,
'attributes': attributes
})
return slivers
