from PLC.Faults import *
from PLC.Method import Method
from PLC.Parameter import Parameter, Mixed
-from PLC.Auth import PasswordAuth
+from PLC.Filter import Filter
+from PLC.Auth import Auth
from PLC.Nodes import Node, Nodes
from PLC.NodeNetworks import NodeNetwork, NodeNetworks
from PLC.NodeGroups import NodeGroup, NodeGroups
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 slivers (slices bound to
- nodes). If node_id_or_hostname_list is specified, only slivers
- bound to the specified nodes are queried.
+ Returns an array of structs representing nodes and their slivers
+ (slices bound to nodes). If node_filter is specified, only
+ information about the specified nodes will be returned. If
+ node_filter is not specified and called by a node, only
+ information about the caller will be returned.
All of the information returned by this call can be gathered from
other calls, e.g. GetNodes, GetNodeNetworks, GetSlices, etc. This
Federation Manager.
"""
- roles = ['admin']
+ roles = ['admin', 'node']
accepts = [
- PasswordAuth(),
- [Mixed(Node.fields['node_id'],
- Node.fields['hostname'])]
+ Auth(),
+ Mixed([Mixed(Node.fields['node_id'],
+ Node.fields['hostname'])],
+ Filter(Node.fields)),
]
returns = [{
'timestamp': Parameter(int, "Timestamp of this call, in seconds since UNIX epoch"),
- 'id': Node.fields['node_id'],
+ 'node_id': Node.fields['node_id'],
'hostname': Node.fields['hostname'],
- 'boot_state': Node.fields['boot_state'],
'networks': [NodeNetwork.fields],
'groups': [NodeGroup.fields['name']],
'conf_files': [ConfFile.fields],
'slivers': [{
'name': Slice.fields['name'],
- 'id': Slice.fields['slice_id'],
+ 'slice_id': Slice.fields['slice_id'],
'instantiation': Slice.fields['instantiation'],
'expires': Slice.fields['expires'],
'keys': [{
}]
}]
- def call(self, auth, node_id_or_hostname_list = None):
+ def call(self, auth, node_filter = None):
timestamp = int(time.time())
- all_nodes = Nodes(self.api, node_id_or_hostname_list)
+ 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()
- conf_file_ids = set()
slice_ids = set()
for node_id, node in all_nodes.iteritems():
nodenetwork_ids.update(node['nodenetwork_ids'])
nodegroup_ids.update(node['nodegroup_ids'])
- conf_file_ids.update(node['conf_file_ids'])
slice_ids.update(node['slice_ids'])
# Get nodenetwork information
- if nodenetwork_ids:
- all_nodenetworks = NodeNetworks(self.api, nodenetwork_ids)
- else:
- all_nodenetworks = {}
+ all_nodenetworks = hashref(NodeNetworks(self.api, nodenetwork_ids), 'nodenetwork_id')
# Get node group information
- if nodegroup_ids:
- all_nodegroups = NodeGroups(self.api, nodegroup_ids)
+ all_nodegroups = hashref(NodeGroups(self.api, nodegroup_ids), 'nodegroup_id')
- for nodegroup_id, nodegroup in all_nodegroups.iteritems():
- conf_file_ids.update(nodegroup['conf_file_ids'])
- else:
- all_nodegroups = {}
-
- # Get configuration files
- if conf_file_ids:
- all_conf_files = ConfFiles(self.api, conf_file_ids)
- else:
- all_conf_files = {}
+ # Get (enabled) configuration files
+ all_conf_files = hashref(ConfFiles(self.api, {'enabled': True}), 'conf_file_id')
if slice_ids:
# Get slices
- all_slices = Slices(self.api, slice_ids)
+ all_slices = hashref(Slices(self.api, slice_ids), 'slice_id')
person_ids = set()
slice_attribute_ids = set()
slice_attribute_ids.update(slice['slice_attribute_ids'])
# Get user accounts
- all_persons = Persons(self.api, person_ids)
+ 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 account keys
- all_keys = Keys(self.api, key_ids)
+ all_keys = hashref(Keys(self.api, key_ids), 'key_id')
# Get slice attributes
- all_slice_attributes = SliceAttributes(self.api, slice_attribute_ids)
+ all_slice_attributes = hashref(SliceAttributes(self.api, slice_attribute_ids), 'slice_attribute_id')
nodes = []
for node_id, node in all_nodes.iteritems():
nodegroups = [all_nodegroups[nodegroup_id] for nodegroup_id in node['nodegroup_ids']]
groups = [nodegroup['name'] for nodegroup in nodegroups]
+ # If multiple entries for the same global configuration
+ # file exist, it is undefined which one takes precedence.
+ conf_files = {}
+ 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
# groups for which the same configuration file is defined,
# it is undefined which one takes precedence.
- conf_files = {}
for nodegroup in nodegroups:
- for conf_file in map(lambda id: all_conf_files[id], nodegroup['conf_file_ids']):
- conf_files[conf_file['dest']] = conf_file
+ 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 group configuration files.
- for conf_file in map(lambda id: all_conf_files[id], node['conf_file_ids']):
- conf_files[conf_file['dest']] = conf_file
+ 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']):
nodes.append({
'timestamp': timestamp,
- 'id': node['node_id'],
+ 'node_id': node['node_id'],
'hostname': node['hostname'],
'networks': networks,
'groups': groups,
git://git.onelab.eu / plcapi.git / blobdiff