from PLC.NodeGroups import NodeGroup, NodeGroups
from PLC.ConfFiles import ConfFile, ConfFiles
from PLC.Slices import Slice, Slices
+#from PLC.ForeignSlices import ForeignSlice, ForeignSlices
from PLC.Persons import Person, Persons
from PLC.Keys import Key, Keys
from PLC.SliceAttributes import SliceAttribute, SliceAttributes
-def hashref(rows, key_field):
- d = {}
- for row in rows:
- d[row[key_field]] = row
- return d
-
class GetSlivers(Method):
"""
Returns an array of structs representing nodes and their slivers
}]
}]
+
def call(self, auth, node_filter = None):
timestamp = int(time.time())
if node_filter is None and isinstance(self.caller, Node):
all_nodes = {self.caller['node_id']: self.caller}
else:
- all_nodes = hashref(Nodes(self.api, node_filter), 'node_id')
- # XXX Add foreign nodes
-
- nodenetwork_ids = set()
- nodegroup_ids = set()
- slice_ids = set()
+ all_nodes = Nodes(self.api, node_filter).dict()
+
+ # Get local default slices
+ system_slice_attributes = SliceAttributes(self.api, {'name': 'system', 'value': '1', 'peer_id': None}).dict()
+ system_slice_ids = [slice_attribute['slice_id'] for slice_attribute in system_slice_attributes.values()]
+ system_slice_ids = dict.fromkeys(system_slice_ids)
+
+ all_nodenetwork_ids = set()
+ all_nodegroup_ids = set()
+ all_slice_ids = set(system_slice_ids.keys())
for node_id, node in all_nodes.iteritems():
- nodenetwork_ids.update(node['nodenetwork_ids'])
- nodegroup_ids.update(node['nodegroup_ids'])
- slice_ids.update(node['slice_ids'])
-
+ all_nodenetwork_ids.update(node['nodenetwork_ids'])
+ all_nodegroup_ids.update(node['nodegroup_ids'])
+ all_slice_ids.update(node['slice_ids'])
+
# Get nodenetwork information
- all_nodenetworks = hashref(NodeNetworks(self.api, nodenetwork_ids), 'nodenetwork_id')
+ all_nodenetworks = NodeNetworks(self.api, all_nodenetwork_ids).dict()
# Get node group information
- all_nodegroups = hashref(NodeGroups(self.api, nodegroup_ids), 'nodegroup_id')
+ all_nodegroups = NodeGroups(self.api, all_nodegroup_ids).dict()
# Get (enabled) configuration files
- all_conf_files = hashref(ConfFiles(self.api, {'enabled': True}), 'conf_file_id')
+ all_conf_files = ConfFiles(self.api, {'enabled': True}).dict()
- if slice_ids:
- # Get slices
- all_slices = hashref(Slices(self.api, slice_ids), 'slice_id')
+ # Get slice information
+ all_slices = Slices(self.api, all_slice_ids).dict()
- person_ids = set()
- slice_attribute_ids = set()
- for slice_id, slice in all_slices.iteritems():
+ person_ids = set()
+ slice_attribute_ids = set()
+ for slice_id, slice in all_slices.iteritems():
+ ### still missing in foreign slices
+ if slice.get('person_ids'):
person_ids.update(slice['person_ids'])
+ ### still missing in foreign slices
+ if slice.get('slice_attribute_ids'):
slice_attribute_ids.update(slice['slice_attribute_ids'])
- # Get user accounts
- all_persons = hashref(Persons(self.api, person_ids), 'person_id')
-
- key_ids = set()
- for person_id, person in all_persons.iteritems():
- key_ids.update(person['key_ids'])
+ # Get user information
+ all_persons = Persons(self.api, person_ids).dict()
- # Get user account keys
- all_keys = hashref(Keys(self.api, key_ids), 'key_id')
+ key_ids = set()
+ for person_id, person in all_persons.iteritems():
+ key_ids.update(person['key_ids'])
- # Get slice attributes
- all_slice_attributes = hashref(SliceAttributes(self.api, slice_attribute_ids), 'slice_attribute_id')
+ # Get user account keys
+ all_keys = Keys(self.api, key_ids).dict()
- nodes = []
+ # Get slice attributes
+ all_slice_attributes = SliceAttributes(self.api, slice_attribute_ids).dict()
+
+ nodes = []
for node_id, node in all_nodes.iteritems():
- networks = [all_nodenetworks[nodenetwork_id] for nodenetwork_id in node['nodenetwork_ids']]
+ networks = [all_nodenetworks[nodenetwork_id] for nodenetwork_id in node['nodenetwork_ids']]
nodegroups = [all_nodegroups[nodegroup_id] for nodegroup_id in node['nodegroup_ids']]
groups = [nodegroup['name'] for nodegroup in nodegroups]
for conf_file in all_conf_files.values():
if not conf_file['node_ids'] and not conf_file['nodegroup_ids']:
conf_files[conf_file['dest']] = conf_file
-
- # If a node belongs to multiple node
+
+ # If a node belongs to multiple node
# groups for which the same configuration file is defined,
# it is undefined which one takes precedence.
for nodegroup in nodegroups:
for conf_file_id in nodegroup['conf_file_ids']:
if conf_file_id in all_conf_files:
conf_files[conf_file['dest']] = all_conf_files[conf_file_id]
-
- # Node configuration files always take precedence over
+
+ # Node configuration files always take precedence over
# node group configuration files.
for conf_file_id in node['conf_file_ids']:
if conf_file_id in all_conf_files:
conf_files[conf_file['dest']] = all_conf_files[conf_file_id]
-
- slivers = []
- for slice in map(lambda id: all_slices[id], node['slice_ids']):
+
+ # filter out any slices in this nodes slice_id list that may be invalid
+ # (i.e. expired slices)
+ slice_ids = dict.fromkeys(filter(lambda slice_id: slice_id in all_slice_ids, node['slice_ids']))
+
+ # If not a foreign node, add all of our default system
+ # slices to it.
+ if node['peer_id'] is None:
+ slice_ids.update(system_slice_ids)
+
+ slivers = []
+
+ for slice in map(lambda id: all_slices[id], slice_ids.keys()):
keys = []
- for person in map(lambda id: all_persons[id], slice['person_ids']):
- keys += [{'key_type': all_keys[key_id]['key_type'],
- 'key': all_keys[key_id]['key']} \
- for key_id in person['key_ids']]
-
- attributes = {}
- for slice_attribute in map(lambda id: all_slice_attributes[id],
- slice['slice_attribute_ids']):
- # Per-node sliver attributes (slice attributes
- # with non-null node_id fields) take precedence
- # over global slice attributes.
- if not attributes.has_key(slice_attribute['name']) or \
- slice_attribute['node_id'] is not None:
- attributes[slice_attribute['name']] = {
- 'name': slice_attribute['name'],
- 'value': slice_attribute['value']
- }
+ ### still missing in foreign slices
+ try:
+ for person in map(lambda id: all_persons[id], slice['person_ids']):
+ keys += [{'key_type': all_keys[key_id]['key_type'],
+ 'key': all_keys[key_id]['key']} \
+ for key_id in person['key_ids']]
+ except:
+ keys += [{'key_type':'missing',
+ 'key':'key caching not implemented yet'}]
+
+ sliver_attributes = []
+ attributes = []
+ ### still missing in foreign slices
+ try:
+ slice_attributes = map(lambda id: all_slice_attributes[id],
+ slice['slice_attribute_ids'])
+
+ # Per-node sliver attributes take precedence over
+ # global slice attributes, so set them first.
+ for sliver_attribute in filter(lambda a: a['node_id'] == node_id, slice_attributes):
+ sliver_attributes.append(sliver_attribute['name'])
+ attributes.append({'name': sliver_attribute['name'],
+ 'value': sliver_attribute['value']})
+
+ for slice_attribute in filter(lambda a: a['node_id'] is None, slice_attributes):
+ # Do not set any global slice attributes for
+ # which there is at least one sliver attribute
+ # already set.
+ if slice_attribute['name'] not in sliver_attributes:
+ attributes.append({'name': slice_attribute['name'],
+ 'value': slice_attribute['value']})
+ except Exception, err:
+ attributes=[{'name':'attributes caching','value':'not implemented yet'}]
slivers.append({
'name': slice['name'],
'instantiation': slice['instantiation'],
'expires': slice['expires'],
'keys': keys,
- 'attributes': attributes.values()
+ 'attributes': attributes
})
-
+
nodes.append({
'timestamp': timestamp,
'node_id': node['node_id'],
git://git.onelab.eu / plcapi.git / blobdiff