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.Interfaces import Interface, Interfaces
  10 from PLC.NodeGroups import NodeGroup, NodeGroups
  11 from PLC.ConfFiles import ConfFile, ConfFiles
  12 from PLC.Slices import Slice, Slices
  13 from PLC.Persons import Person, Persons
  14 from PLC.Sites import Sites
  15 from PLC.Roles import Roles
  16 from PLC.Keys import Key, Keys
  17 from PLC.SliceTags import SliceTag, SliceTags
  18 from PLC.InitScripts import InitScript, InitScripts
  19 from PLC.Leases import Lease, Leases
  20 from PLC.Timestamp import Duration
  21 from PLC.Methods.GetSliceFamily import GetSliceFamily
  22
  23 from PLC.Accessors.Accessors_standard import *
  24
  25 # XXX used to check if slice expiration time is sane
  26 MAXINT =  2L**31-1
  27
  28 # slice_filter essentially contains the slice_ids for the relevant slices (on the node + system & delegated slices)
  29 def get_slivers(api, caller, auth, slice_filter, node = None):
  30     # Get slice information
  31     slices = Slices(api, slice_filter, ['slice_id', 'name', 'instantiation', 'expires', 'person_ids', 'slice_tag_ids'])
  32
  33     # Build up list of users and slice attributes
  34     person_ids = set()
  35     slice_tag_ids = set()
  36     for slice in slices:
  37         person_ids.update(slice['person_ids'])
  38         slice_tag_ids.update(slice['slice_tag_ids'])
  39
  40     # Get user information
  41     all_persons = Persons(api, {'person_id':person_ids,'enabled':True}, ['person_id', 'enabled', 'key_ids']).dict()
  42
  43     # Build up list of keys
  44     key_ids = set()
  45     for person in all_persons.values():
  46         key_ids.update(person['key_ids'])
  47
  48     # Get user account keys
  49     all_keys = Keys(api, key_ids, ['key_id', 'key', 'key_type']).dict()
  50
  51     # Get slice attributes
  52     all_slice_tags = SliceTags(api, slice_tag_ids).dict()
  53
  54     slivers = []
  55     for slice in slices:
  56         keys = []
  57         for person_id in slice['person_ids']:
  58             if person_id in all_persons:
  59                 person = all_persons[person_id]
  60                 if not person['enabled']:
  61                     continue
  62                 for key_id in person['key_ids']:
  63                     if key_id in all_keys:
  64                         key = all_keys[key_id]
  65                         keys += [{'key_type': key['key_type'],
  66                                   'key': key['key']}]
  67
  68         attributes = []
  69
  70         # All (per-node and global) attributes for this slice
  71         slice_tags = []
  72         for slice_tag_id in slice['slice_tag_ids']:
  73             if slice_tag_id in all_slice_tags:
  74                 slice_tags.append(all_slice_tags[slice_tag_id])
  75
  76         # Per-node sliver attributes take precedence over global
  77         # slice attributes, so set them first.
  78         # Then comes nodegroup slice attributes
  79         # Followed by global slice attributes
  80         sliver_attributes = []
  81
  82         if node is not None:
  83             for sliver_attribute in [ a for a in slice_tags if a['node_id'] == node['node_id'] ]:
  84                 sliver_attributes.append(sliver_attribute['tagname'])
  85                 attributes.append({'tagname': sliver_attribute['tagname'],
  86                                    'value': sliver_attribute['value']})
  87
  88             # set nodegroup slice attributes
  89             for slice_tag in [ a for a in slice_tags if a['nodegroup_id'] in node['nodegroup_ids'] ]:
  90                 # Do not set any nodegroup slice attributes for
  91                 # which there is at least one sliver attribute
  92                 # already set.
  93                 if slice_tag not in slice_tags:
  94                     attributes.append({'tagname': slice_tag['tagname'],
  95                                    'value': slice_tag['value']})
  96
  97         for slice_tag in [ a for a in slice_tags if a['node_id'] is None ]:
  98             # Do not set any global slice attributes for
  99             # which there is at least one sliver attribute
 100             # already set.
 101             if slice_tag['tagname'] not in sliver_attributes:
 102                 attributes.append({'tagname': slice_tag['tagname'],
 103                                    'value': slice_tag['value']})
 104
 105         # XXX Sanity check; though technically this should be a system invariant
 106         # checked with an assertion
 107         if slice['expires'] > MAXINT:  slice['expires']= MAXINT
 108
 109         # expose the slice vref as computed by GetSliceFamily
 110         family = GetSliceFamily (api,caller).call(auth, slice['slice_id'])
 111
 112         slivers.append({
 113             'name': slice['name'],
 114             'slice_id': slice['slice_id'],
 115             'instantiation': slice['instantiation'],
 116             'expires': slice['expires'],
 117             'keys': keys,
 118             'attributes': attributes,
 119             'GetSliceFamily': family,
 120             })
 121
 122     return slivers
 123
 124 ### The pickle module, used in conjunction with caching has a restriction that it does not
 125 ### work on "connection objects." It doesn't matter if the connection object has
 126 ### an 'str' or 'repr' method, there is a taint check that throws an exception if
 127 ### the pickled class is found to derive from a connection.
 128 ### (To be moved to Method.py)
 129
 130 def sanitize_for_pickle (obj):
 131     if (isinstance(obj, dict)):
 132         parent = dict(obj)
 133         for k in parent.keys(): parent[k] = sanitize_for_pickle (parent[k])
 134         return parent
 135     elif (isinstance(obj, list)):
 136         parent = list(obj)
 137         parent = map(sanitize_for_pickle, parent)
 138         return parent
 139     else:
 140         return obj
 141
 142 class GetSlivers(Method):
 143     """
 144     Returns a struct containing information about the specified node
 145     (or calling node, if called by a node and node_id_or_hostname is
 146     not specified), including the current set of slivers bound to the
 147     node.
 148
 149     All of the information returned by this call can be gathered from
 150     other calls, e.g. GetNodes, GetInterfaces, GetSlices, etc. This
 151     function exists almost solely for the benefit of Node Manager.
 152     """
 153
 154     roles = ['admin', 'node']
 155
 156     accepts = [
 157         Auth(),
 158         Mixed(Node.fields['node_id'],
 159               Node.fields['hostname']),
 160         ]
 161
 162     returns = {
 163         'timestamp': Parameter(int, "Timestamp of this call, in seconds since UNIX epoch"),
 164         'node_id': Node.fields['node_id'],
 165         'hostname': Node.fields['hostname'],
 166         'interfaces': [Interface.fields],
 167         'groups': [NodeGroup.fields['groupname']],
 168         'conf_files': [ConfFile.fields],
 169         'initscripts': [InitScript.fields],
 170         'accounts': [{
 171             'name': Parameter(str, "unix style account name", max = 254),
 172             'keys': [{
 173                 'key_type': Key.fields['key_type'],
 174                 'key': Key.fields['key']
 175             }],
 176             }],
 177         'slivers': [{
 178             'name': Slice.fields['name'],
 179             'slice_id': Slice.fields['slice_id'],
 180             'instantiation': Slice.fields['instantiation'],
 181             'expires': Slice.fields['expires'],
 182             'keys': [{
 183                 'key_type': Key.fields['key_type'],
 184                 'key': Key.fields['key']
 185             }],
 186             'attributes': [{
 187                 'tagname': SliceTag.fields['tagname'],
 188                 'value': SliceTag.fields['value']
 189             }]
 190         }],
 191         # how to reach the xmpp server
 192         'xmpp': {'server':Parameter(str,"hostname for the XMPP server"),
 193                  'user':Parameter(str,"username for the XMPP server"),
 194                  'password':Parameter(str,"username for the XMPP server"),
 195                  },
 196         # we consider three policies (reservation-policy)
 197         # none : the traditional way to use a node
 198         # lease_or_idle : 0 or 1 slice runs at a given time
 199         # lease_or_shared : 1 slice is running during a lease, otherwise all the slices come back
 200         'reservation_policy': Parameter(str,"one among none, lease_or_idle, lease_or_shared"),
 201         'leases': [  { 'slice_id' : Lease.fields['slice_id'],
 202                        't_from' : Lease.fields['t_from'],
 203                        't_until' : Lease.fields['t_until'],
 204                        }],
 205     }
 206
 207     def call(self, auth, node_id_or_hostname = None):
 208         timestamp = int(time.time())
 209
 210         # Get node
 211         if node_id_or_hostname is None:
 212             if isinstance(self.caller, Node):
 213                 node = self.caller
 214             else:
 215                 raise PLCInvalidArgument, "'node_id_or_hostname' not specified"
 216         else:
 217             nodes = Nodes(self.api, [node_id_or_hostname])
 218             if not nodes:
 219                 raise PLCInvalidArgument, "No such node"
 220             node = nodes[0]
 221
 222             if node['peer_id'] is not None:
 223                 raise PLCInvalidArgument, "Not a local node"
 224
 225         # Get interface information
 226         interfaces = Interfaces(self.api, node['interface_ids'])
 227
 228         # Get node group information
 229         nodegroups = NodeGroups(self.api, node['nodegroup_ids']).dict('groupname')
 230         groups = nodegroups.keys()
 231
 232         # Get all (enabled) configuration files
 233         all_conf_files = ConfFiles(self.api, {'enabled': True}).dict()
 234         conf_files = {}
 235
 236         # Global configuration files are the default. If multiple
 237         # entries for the same global configuration file exist, it is
 238         # undefined which one takes precedence.
 239         for conf_file in all_conf_files.values():
 240             if not conf_file['node_ids'] and not conf_file['nodegroup_ids']:
 241                 conf_files[conf_file['dest']] = conf_file
 242
 243         # Node group configuration files take precedence over global
 244         # ones. If a node belongs to multiple node groups for which
 245         # the same configuration file is defined, it is undefined
 246         # which one takes precedence.
 247         for nodegroup in nodegroups.values():
 248             for conf_file_id in nodegroup['conf_file_ids']:
 249                 if conf_file_id in all_conf_files:
 250                     conf_file = all_conf_files[conf_file_id]
 251                     conf_files[conf_file['dest']] = conf_file
 252
 253         # Node configuration files take precedence over node group
 254         # configuration files.
 255         for conf_file_id in node['conf_file_ids']:
 256             if conf_file_id in all_conf_files:
 257                 conf_file = all_conf_files[conf_file_id]
 258                 conf_files[conf_file['dest']] = conf_file
 259
 260         # Get all (enabled) initscripts
 261         initscripts = InitScripts(self.api, {'enabled': True})
 262
 263         # Get system slices
 264         system_slice_tags = SliceTags(self.api, {'tagname': 'system', 'value': '1'}).dict('slice_id')
 265         system_slice_ids = system_slice_tags.keys()
 266
 267         # Get nm-controller slices
 268         # xxx Thierry: should these really be exposed regardless of their mapping to nodes ?
 269         controller_and_delegated_slices = Slices(self.api, {'instantiation': ['nm-controller', 'delegated']}, ['slice_id']).dict('slice_id')
 270         controller_and_delegated_slice_ids = controller_and_delegated_slices.keys()
 271         slice_ids = system_slice_ids + controller_and_delegated_slice_ids + node['slice_ids']
 272
 273         slivers = get_slivers(self.api, self.caller, auth, slice_ids, node)
 274
 275         # get the special accounts and keys needed for the node
 276         # root
 277         # site_admin
 278         accounts = []
 279         if False and 'site_id' not in node:
 280             nodes = Nodes(self.api, node['node_id'])
 281             node = nodes[0]
 282
 283         # used in conjunction with reduce to flatten lists, like in
 284         # reduce ( reduce_flatten_list, [ [1] , [2,3] ], []) => [ 1,2,3 ]
 285         def reduce_flatten_list (x,y): return x+y
 286
 287         # power users are pis and techs
 288         def get_site_power_user_keys(api,site_id_or_name):
 289             site = Sites (api,site_id_or_name,['person_ids'])[0]
 290             key_ids = reduce (reduce_flatten_list,
 291                               [ p['key_ids'] for p in \
 292                                     Persons(api,{ 'person_id':site['person_ids'],
 293                                                   'enabled':True, '|role_ids' : [20, 40] },
 294                                             ['key_ids']) ],
 295                               [])
 296             return [ key['key'] for key in Keys (api, key_ids) if key['key_type']=='ssh']
 297
 298         # all admins regardless of their site
 299         def get_all_admin_keys(api):
 300             key_ids = reduce (reduce_flatten_list,
 301                               [ p['key_ids'] for p in \
 302                                     Persons(api, {'peer_id':None, 'enabled':True, '|role_ids':[10] },
 303                                             ['key_ids']) ],
 304                               [])
 305             return [ key['key'] for key in Keys (api, key_ids) if key['key_type']=='ssh']
 306
 307         # 'site_admin' account setup
 308         personsitekeys=get_site_power_user_keys(self.api,node['site_id'])
 309         accounts.append({'name':'site_admin','keys':personsitekeys})
 310
 311         # 'root' account setup on nodes from all 'admin' users
 312         personsitekeys=get_all_admin_keys(self.api)
 313         accounts.append({'name':'root','keys':personsitekeys})
 314
 315         hrn = GetNodeHrn(self.api,self.caller).call(auth,node['node_id'])
 316
 317         # XMPP config for omf federation
 318         try:
 319             if not self.api.config.PLC_OMF_ENABLED:
 320                 raise Exception,"OMF disabled"
 321             xmpp={'server':self.api.config.PLC_OMF_XMPP_SERVER,
 322                   'user':self.api.config.PLC_OMF_XMPP_USER,
 323                   'password':self.api.config.PLC_OMF_XMPP_PASSWORD,
 324                   }
 325         except:
 326             xmpp={'server':None,'user':None,'password':None}
 327
 328         node.update_last_contact()
 329
 330         # expose leases & reservation policy
 331         # in a first implementation we only support none and lease_or_idle
 332         lease_exposed_fields = [ 'slice_id', 't_from', 't_until', 'name', ]
 333         leases=None
 334         if node['node_type'] != 'reservable':
 335             reservation_policy='none'
 336         else:
 337             reservation_policy='lease_or_idle'
 338             # expose the leases for the next 24 hours
 339             leases = [ dict ( [ (k,l[k]) for k in lease_exposed_fields ] )
 340                        for l in Leases (self.api, {'node_id':node['node_id'],
 341                                                    'clip': (timestamp, timestamp+24*Duration.HOUR),
 342                                                    '-SORT': 't_from',
 343                                                    }) ]
 344         granularity=self.api.config.PLC_RESERVATION_GRANULARITY
 345
 346         return {
 347             'timestamp': timestamp,
 348             'node_id': node['node_id'],
 349             'hostname': node['hostname'],
 350             'interfaces': interfaces,
 351             'groups': groups,
 352             'conf_files': conf_files.values(),
 353             'initscripts': initscripts,
 354             'slivers': slivers,
 355             'accounts': accounts,
 356             'xmpp':xmpp,
 357             'hrn':hrn,
 358             'reservation_policy': reservation_policy,
 359             'leases':leases,
 360             'lease_granularity': granularity,
 361             }