from types import StringTypes, ListType
from geni.util.geniserver import GeniServer
-from geni.util.geniclient import *
+from geni.util.geniclient import GeniClient
from geni.util.cert import Keypair, Certificate
from geni.util.credential import Credential
from geni.util.trustedroot import TrustedRootList
def __init__(self, ip, port, key_file, cert_file, config = "/usr/share/geniwrapper/geni/util/geni_config"):
GeniServer.__init__(self, ip, port, key_file, cert_file)
+ self.server.interface = 'aggregate'
self.key_file = key_file
self.cert_file = cert_file
self.config = Config(config)
elif type in ['slice']:
slicename = hrn_to_pl_slicename(hrn)
slices = self.shell.GetSlices(self.auth, [slicename])
- node_ids = slices[0]['node_ids']
- nodes = self.shell.GetNodes(self.auth, node_ids)
+ if not slices:
+ nodes = []
+ else:
+ slice = slices[0]
+ node_ids = slice['node_ids']
+ nodes = self.shell.GetNodes(self.auth, node_ids)
# Filter out whitelisted nodes
public_nodes = lambda n: n.has_key('slice_ids_whitelist') and not n['slice_ids_whitelist']
# create the plc dict
networks = [{'nodes': nodes,
- 'links': linkspecs,
'name': self.hrn,
'start_time': start_time,
- 'duration': duration}]
+ 'duration': duration}]
+ if type in ['aggregate']:
+ networks[0]['links'] = linkspecs
resources = {'networks': networks, 'start_time': start_time, 'duration': duration}
# convert the plc dict to an rspec dict
# Get the slice record from geni
slice = {}
- records = self.registry.resolve(self.cred, slice_hrn)
- if not records:
- raise RecordNotFound(slice_hrn)
+ records = self.registry.resolve(self.credential, slice_hrn)
for record in records:
if record.get_type() in ['slice']:
slice_info = record.as_dict()
slice = slice_info['pl_info']
+ if not slice:
+ raise RecordNotFound(slice_hrn)
+
# Make sure slice exists at plc, if it doesnt add it
slicename = hrn_to_pl_slicename(slice_hrn)
slices = self.shell.GetSlices(self.auth, [slicename], ['node_ids'])
if not slices:
- # if site doesnt exist add it
parts = slicename.split("_")
login_base = parts[0]
+ # if site doesnt exist add it
sites = self.shell.GetSites(self.auth, [login_base])
if not sites:
authority = get_authority(slice_hrn)
- site_record = self.registry.reolve(self.cred, authority)
+ site_records = self.registry.resolve(self.credential, authority)
+ site_record = {}
+ if not site_records:
+ raise RecordNotFound(authority)
+ site_record = site_records[0]
site_info = site_record.as_dict()
site = site_info['pl_info']
else:
site = sites[0]
- self.shell.AddSlice(self.auth, slice_info)
+ self.shell.AddSlice(self.auth, slice)
# get the list of valid slice users from the registry and make
# they are added to the slice
person_records = self.registry.resolve(self.credential, researcher)
for record in person_records:
if record.get_type() in ['user']:
- person_record = person_records[0]
+ person_record = record
if not person_record:
pass
- person_dict = person_record.as_dict()['plc_info']
+ person_dict = person_record.as_dict()['pl_info']
persons = self.shell.GetPersons(self.auth, [person_dict['email']], ['person_id', 'key_ids'])
# Create the person record
if not persons:
self.shell.AddPerson(self.auth, person_dict)
- self.shell.AddPersonToSlice(self.auth, person_dict['email'], login_base)
- # Add this person's public keys
+ key_ids = []
+ else:
+ key_ids = persons[0]['key_ids']
+
+ self.shell.AddPersonToSlice(self.auth, person_dict['email'], slicename)
+
+ # Get this users local keys
+ keylist = self.shell.GetKeys(self.auth, key_ids, ['key'])
+ keys = [key['key'] for key in keylist]
+
+ # add keys that arent already there
for personkey in person_dict['keys']:
- key = {'type': 'ssh', 'key': personkey}
- self.shellAddPersonKey(self.auth, person_dict['email'], key)
+ if personkey not in keys:
+ key = {'key_type': 'ssh', 'key': personkey}
+ self.shell.AddPersonKey(self.auth, person_dict['email'], key)
# find out where this slice is currently running
nodelist = self.shell.GetNodes(self.auth, slice['node_ids'], ['hostname'])
self.server.register_function(self.start_slice)
self.server.register_function(self.stop_slice)
self.server.register_function(self.reset_slice)
-
+
+
+
+
+class Aggregates(dict):
+
+ def __init__(self, api):
+ dict.__init__(self, {})
+ self.api = api
+ aggregates_file = self.api.server_basedir + os.sep + 'aggregates.xml'
+ connection_dict = {'hrn': '', 'addr': '', 'port': ''}
+ self.aggregate_info = XmlStorage(aggregates_file, {'aggregates': {'aggregate': [connection_dict]}})
+ self.aggregate_info.load()
+ self.connectAggregates()
+
+
+ def connectAggregates(self):
+ """
+ Get connection details for the trusted peer aggregates from file and
+ create an GeniClient connection to each.
+ """
+ required_fields = ['hrn', 'addr', 'port']
+ aggregates = self.aggregate_info['aggregates']['aggregate']
+ if isinstance(aggregates, dict):
+ aggregates = [aggregates]
+ if isinstance(aggregates, list):
+ for aggregate in aggregates:
+ # create xmlrpc connection using GeniClient
+ if not set(required_fields).issubset(aggregate.keys()):
+ continue
+ hrn, address, port = aggregate['hrn'], aggregate['addr'], aggregate['port']
+ if not hrn or not address or not port:
+ continue
+ url = 'http://%(address)s:%(port)s' % locals()
+ self[hrn] = GeniClient(url, self.api.key_file, self.api.cert_file)
+
+ # set up a connection to the local registry
+ # connect to registry using GeniClient
+ address = self.api.config.GENI_AGGREGATE_HOSTNAME
+ port = self.api.config.GENI_AGGREGATE_PORT
+ url = 'http://%(address)s:%(port)s' % locals()
+ self[self.api.hrn] = GeniClient(url, self.api.key_file, self.api.cert_file)
+
git://git.onelab.eu / sfa.git / blobdiff