PLC/Methods/GetSlivers.py

   1 import time
   2
   3 from PLC.Faults import *
   4 from PLC.Method import Method
   5 from PLC.Parameter import Parameter, Mixed
   6 from PLC.Filter import Filter
   7 from PLC.Auth import Auth
   8 from PLC.Nodes import Node, Nodes
   9 from PLC.NodeNetworks import NodeNetwork, NodeNetworks
  10 from PLC.NodeGroups import NodeGroup, NodeGroups
  11 from PLC.ConfFiles import ConfFile, ConfFiles
  12 from PLC.Slices import Slice, Slices
  13 from PLC.ForeignSlices import ForeignSlice, ForeignSlices
  14 from PLC.Persons import Person, Persons
  15 from PLC.Keys import Key, Keys
  16 from PLC.SliceAttributes import SliceAttribute, SliceAttributes
  17
  18 class GetSlivers(Method):
  19     """
  20     Returns an array of structs representing nodes and their slivers
  21     (slices bound to nodes). If node_filter is specified, only
  22     information about the specified nodes will be returned. If
  23     node_filter is not specified and called by a node, only
  24     information about the caller will be returned.
  25
  26     All of the information returned by this call can be gathered from
  27     other calls, e.g. GetNodes, GetNodeNetworks, GetSlices, etc. This
  28     function exists primarily for the benefit of Node Manager and
  29     Federation Manager.
  30     """
  31
  32     roles = ['admin', 'node']
  33
  34     accepts = [
  35         Auth(),
  36         Mixed([Mixed(Node.fields['node_id'],
  37                      Node.fields['hostname'])],
  38               Filter(Node.fields)),
  39         ]
  40
  41     returns = [{
  42         'timestamp': Parameter(int, "Timestamp of this call, in seconds since UNIX epoch"),
  43         'node_id': Node.fields['node_id'],
  44         'hostname': Node.fields['hostname'],
  45         'networks': [NodeNetwork.fields],
  46         'groups': [NodeGroup.fields['name']],
  47         'conf_files': [ConfFile.fields],
  48         'slivers': [{
  49             'name': Slice.fields['name'],
  50             'slice_id': Slice.fields['slice_id'],
  51             'instantiation': Slice.fields['instantiation'],
  52             'expires': Slice.fields['expires'],
  53             'keys': [{
  54                 'key_type': Key.fields['key_type'],
  55                 'key': Key.fields['key']
  56             }],
  57             'attributes': [{
  58                 'name': SliceAttribute.fields['name'],
  59                 'value': SliceAttribute.fields['value']
  60             }]
  61         }]
  62     }]
  63
  64     def call(self, auth, node_filter = None):
  65         timestamp = int(time.time())
  66
  67         if node_filter is None and isinstance(self.caller, Node):
  68             all_nodes = {self.caller['node_id']: self.caller}
  69         else:
  70             all_nodes = Nodes(self.api, node_filter).dict()
  71             # XXX Add foreign nodes
  72
  73         # Get default slices
  74         system_slice_attributes = SliceAttributes(self.api, {'name': 'system', 'value': '1'}).dict()
  75         system_slice_ids = [slice_attribute['slice_id'] for slice_attribute in system_slice_attributes.values()]
  76         system_slice_ids = dict.fromkeys(system_slice_ids)
  77
  78         all_nodenetwork_ids = set()
  79         all_nodegroup_ids = set()
  80         all_slice_ids = set(system_slice_ids.keys())
  81         for node_id, node in all_nodes.iteritems():
  82             all_nodenetwork_ids.update(node['nodenetwork_ids'])
  83             all_nodegroup_ids.update(node['nodegroup_ids'])
  84             all_slice_ids.update(node['slice_ids'])
  85
  86         # Get nodenetwork information
  87         all_nodenetworks = NodeNetworks(self.api, all_nodenetwork_ids).dict()
  88
  89         # Get node group information
  90         all_nodegroups = NodeGroups(self.api, all_nodegroup_ids).dict()
  91
  92         # Get (enabled) configuration files
  93         all_conf_files = ConfFiles(self.api, {'enabled': True}).dict()
  94
  95         # Get slice information
  96         all_slices = Slices(self.api, all_slice_ids).dict()
  97         # XXX Merge in foreign slices
  98         all_slices.update(ForeignSlices(self.api, all_slice_ids).dict())
  99
 100         person_ids = set()
 101         slice_attribute_ids = set()
 102         for slice_id, slice in all_slices.iteritems():
 103             ### still missing in foreign slices
 104             if slice.get('person_ids'):
 105                 person_ids.update(slice['person_ids'])
 106             ### still missing in foreign slices
 107             if slice.get('slice_attribute_ids'):
 108                 slice_attribute_ids.update(slice['slice_attribute_ids'])
 109
 110         # Get user information
 111         all_persons = Persons(self.api, person_ids).dict()
 112
 113         key_ids = set()
 114         for person_id, person in all_persons.iteritems():
 115             key_ids.update(person['key_ids'])
 116
 117         # Get user account keys
 118         all_keys = Keys(self.api, key_ids).dict()
 119
 120         # Get slice attributes
 121         all_slice_attributes = SliceAttributes(self.api, slice_attribute_ids).dict()
 122
 123         nodes = []
 124         for node_id, node in all_nodes.iteritems():
 125             networks = [all_nodenetworks[nodenetwork_id] for nodenetwork_id in node['nodenetwork_ids']]
 126             nodegroups = [all_nodegroups[nodegroup_id] for nodegroup_id in node['nodegroup_ids']]
 127             groups = [nodegroup['name'] for nodegroup in nodegroups]
 128
 129             # If multiple entries for the same global configuration
 130             # file exist, it is undefined which one takes precedence.
 131             conf_files = {}
 132             for conf_file in all_conf_files.values():
 133                 if not conf_file['node_ids'] and not conf_file['nodegroup_ids']:
 134                     conf_files[conf_file['dest']] = conf_file
 135
 136             # If a node belongs to multiple node
 137             # groups for which the same configuration file is defined,
 138             # it is undefined which one takes precedence.
 139             for nodegroup in nodegroups:
 140                 for conf_file_id in nodegroup['conf_file_ids']:
 141                     if conf_file_id in all_conf_files:
 142                         conf_files[conf_file['dest']] = all_conf_files[conf_file_id]
 143
 144             # Node configuration files always take precedence over
 145             # node group configuration files.
 146             for conf_file_id in node['conf_file_ids']:
 147                 if conf_file_id in all_conf_files:
 148                     conf_files[conf_file['dest']] = all_conf_files[conf_file_id]
 149
 150             slice_ids = dict.fromkeys(node['slice_ids'])
 151
 152             # If not a foreign node, add all of our default system
 153             # slices to it.
 154             # XXX if not node['peer_id']:
 155             slice_ids.update(system_slice_ids)
 156
 157             slivers = []
 158             for slice in map(lambda id: all_slices[id], slice_ids.keys()):
 159                 keys = []
 160                 ### still missing in foreign slices
 161                 try:
 162                     for person in map(lambda id: all_persons[id], slice['person_ids']):
 163                         keys += [{'key_type': all_keys[key_id]['key_type'],
 164                                   'key': all_keys[key_id]['key']} \
 165                                  for key_id in person['key_ids']]
 166                 except:
 167                     keys += [{'key_type':'missing',
 168                               'key':'key caching not implemented yet'}]
 169
 170                 attributes = {}
 171                 ### still missing in foreign slices
 172                 try:
 173                     for slice_attribute in map(lambda id: all_slice_attributes[id],
 174                                                slice['slice_attribute_ids']):
 175                         # Per-node sliver attributes (slice attributes
 176                         # with non-null node_id fields) take precedence
 177                         # over global slice attributes.
 178                         if not attributes.has_key(slice_attribute['name']) or \
 179                                slice_attribute['node_id'] is not None:
 180                             attributes[slice_attribute['name']] = {
 181                                 'name': slice_attribute['name'],
 182                                 'value': slice_attribute['value']
 183                                 }
 184                 except:
 185                         attributes={'ignored':{'name':'attributes caching','value':'not implemented yet'}}
 186
 187                 slivers.append({
 188                     'name': slice['name'],
 189                     'slice_id': slice['slice_id'],
 190                     'instantiation': slice['instantiation'],
 191                     'expires': slice['expires'],
 192                     'keys': keys,
 193                     'attributes': attributes.values()
 194                     })
 195
 196             nodes.append({
 197                 'timestamp': timestamp,
 198                 'node_id': node['node_id'],
 199                 'hostname': node['hostname'],
 200                 'networks': networks,
 201                 'groups': groups,
 202                 'conf_files': conf_files.values(),
 203                 'slivers': slivers
 204                 })
 205
 206         return nodes