+# $Id$
+# $URL$
import time
from PLC.Faults import *
from PLC.ConfFiles import ConfFile, ConfFiles
from PLC.Slices import Slice, Slices
from PLC.Persons import Person, Persons
+from PLC.Sites import Sites
+from PLC.Roles import Roles
from PLC.Keys import Key, Keys
-from PLC.SliceAttributes import SliceAttribute, SliceAttributes
+from PLC.SliceTags import SliceTag, SliceTags
from PLC.InitScripts import InitScript, InitScripts
+# XXX used to check if slice expiration time is sane
+MAXINT = 2L**31-1
+
def get_slivers(api, slice_filter, node = None):
# Get slice information
- slices = Slices(api, slice_filter, ['slice_id', 'name', 'instantiation', 'expires', 'person_ids', 'slice_attribute_ids'])
+ slices = Slices(api, slice_filter, ['slice_id', 'name', 'instantiation', 'expires', 'person_ids', 'slice_tag_ids'])
# Build up list of users and slice attributes
person_ids = set()
- slice_attribute_ids = set()
+ slice_tag_ids = set()
for slice in slices:
person_ids.update(slice['person_ids'])
- slice_attribute_ids.update(slice['slice_attribute_ids'])
+ slice_tag_ids.update(slice['slice_tag_ids'])
# Get user information
all_persons = Persons(api, {'person_id':person_ids,'enabled':True}, ['person_id', 'enabled', 'key_ids']).dict()
all_keys = Keys(api, key_ids, ['key_id', 'key', 'key_type']).dict()
# Get slice attributes
- all_slice_attributes = SliceAttributes(api, slice_attribute_ids).dict()
+ all_slice_tags = SliceTags(api, slice_tag_ids).dict()
slivers = []
for slice in slices:
attributes = []
# All (per-node and global) attributes for this slice
- slice_attributes = []
- for slice_attribute_id in slice['slice_attribute_ids']:
- if slice_attribute_id in all_slice_attributes:
- slice_attributes.append(all_slice_attributes[slice_attribute_id])
+ 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.
sliver_attributes = []
if node is not None:
- for sliver_attribute in filter(lambda a: a['node_id'] == node['node_id'], slice_attributes):
+ 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_attribute in filter(lambda a: a['nodegroup_id'] in node['nodegroup_ids'], 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_attribute['tagname'] not in slice_attributes:
- attributes.append({'tagname': slice_attribute['tagname'],
- 'value': slice_attribute['value']})
+ if slice_tag not in slice_tags:
+ attributes.append({'tagname': slice_tag['tagname'],
+ 'value': slice_tag['value']})
- for slice_attribute in filter(lambda a: a['node_id'] is None, slice_attributes):
+ 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_attribute['tagname'] not in sliver_attributes:
- attributes.append({'tagname': slice_attribute['tagname'],
- 'value': slice_attribute['value']})
+ 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({
'name': slice['name'],
return slivers
-class GetSlivers(Method):
+class v43GetSlivers(Method):
"""
Returns a struct containing information about the specified node
(or calling node, if called by a node and node_id_or_hostname is
'groups': [NodeGroup.fields['groupname']],
'conf_files': [ConfFile.fields],
'initscripts': [InitScript.fields],
+ 'accounts': [{
+ 'name': Parameter(str, "unix style account name", max = 254),
+ 'keys': [{
+ 'key_type': Key.fields['key_type'],
+ 'key': Key.fields['key']
+ }],
+ }],
'slivers': [{
'name': Slice.fields['name'],
'slice_id': Slice.fields['slice_id'],
'key': Key.fields['key']
}],
'attributes': [{
- 'tagname': SliceAttribute.fields['tagname'],
- 'value': SliceAttribute.fields['value']
+ 'tagname': SliceTag.fields['tagname'],
+ 'value': SliceTag.fields['value']
}]
}]
}
initscripts = InitScripts(self.api, {'enabled': True})
# Get system slices
- system_slice_attributes = SliceAttributes(self.api, {'tagname': 'system', 'value': '1'}).dict('slice_id')
- system_slice_ids = system_slice_attributes.keys()
+ system_slice_tags = SliceTags(self.api, {'tagname': 'system', 'value': '1'}).dict('slice_id')
+ system_slice_ids = system_slice_tags.keys()
# Get nm-controller slices
controller_and_delegated_slices = Slices(self.api, {'instantiation': ['nm-controller', 'delegated']}, ['slice_id']).dict('slice_id')
slivers = get_slivers(self.api, slice_ids, node)
+ # get the special accounts and keys needed for the node
+ # root
+ # site_admin
+ accounts = []
+ if False and 'site_id' not in node:
+ nodes = Nodes(self.api, node['node_id'])
+ node = nodes[0]
+
+ # used in conjunction with reduce to flatten lists, like in
+ # reduce ( reduce_flatten_list, [ [1] , [2,3] ], []) => [ 1,2,3 ]
+ def reduce_flatten_list (x,y): return x+y
+
+ # power users are pis and techs
+ def get_site_power_user_keys(api,site_id_or_name):
+ site = Sites (api,site_id_or_name,['person_ids'])[0]
+ key_ids = reduce (reduce_flatten_list,
+ [ p['key_ids'] for p in \
+ Persons(api,{ 'person_id':site['person_ids'],
+ 'enabled':True, '|role_ids' : [20, 40] },
+ ['key_ids']) ],
+ [])
+ return [ key['key'] for key in Keys (api, key_ids) if key['key_type']=='ssh']
+
+ # all admins regardless of their site
+ def get_all_admin_keys(api):
+ key_ids = reduce (reduce_flatten_list,
+ [ p['key_ids'] for p in \
+ Persons(api, {'peer_id':None, 'enabled':True, '|role_ids':[10] },
+ ['key_ids']) ],
+ [])
+ return [ key['key'] for key in Keys (api, key_ids) if key['key_type']=='ssh']
+
+ # 'site_admin' account setup
+ personsitekeys=get_site_power_user_keys(self.api,node['site_id'])
+ accounts.append({'name':'site_admin','keys':personsitekeys})
+
+ # 'root' account setup on nodes from all 'admin' users
+ personsitekeys=get_all_admin_keys(self.api)
+ accounts.append({'name':'root','keys':personsitekeys})
+
node.update_last_contact()
return {
'groups': groups,
'conf_files': conf_files.values(),
'initscripts': initscripts,
- 'slivers': slivers
+ 'slivers': slivers,
+ 'accounts': accounts
}
+
+class v42GetSlivers(v43GetSlivers):
+ """
+ Legacy wrapper for v43GetSlivers.
+ """
+
+ def call(self, auth, node_id_or_hostname = None):
+ result = v43GetSlivers.call(self,auth,node_id_or_hostname)
+ networks = result['networks']
+
+ for i in range(0,len(networks)):
+ network = networks[i]
+ if network.has_key("interface_id"):
+ network['nodenetwork_id']=network['interface_id']
+ if network.has_key("interface_tag_ids"):
+ network['nodenetwork_setting_ids']=network['interface_tag_ids']
+ networks[i]=network
+
+ result['networks']=networks
+ return result
+
+class GetSlivers(v42GetSlivers):
+ """
+ Returns a struct containing information about the specified node
+ (or calling node, if called by a node and node_id_or_hostname is
+ not specified), including the current set of slivers bound to the
+ node.
+
+ All of the information returned by this call can be gathered from
+ other calls, e.g. GetNodes, GetInterfaces, GetSlices, etc. This
+ function exists almost solely for the benefit of Node Manager.
+ """
+
+ pass