-import datetime
import time
import sys
from sfa.util.sfalogging import logger
from sfa.util.faults import RecordNotFound, SliverDoesNotExist
-from sfa.util.xrn import get_authority, hrn_to_urn, urn_to_hrn, Xrn, urn_to_sliver_id
+from sfa.util.xrn import Xrn, get_authority, hrn_to_urn, urn_to_hrn, urn_to_sliver_id
from sfa.util.plxrn import slicename_to_hrn, hrn_to_pl_slicename
from sfa.util.version import version_core
from sfa.util.sfatime import utcparse
self.caching=True
#self.caching=False
+ # essentially a union of the core version, the generic version (this code) and
+ # whatever the driver needs to expose
def GetVersion(self, api):
- version_manager = VersionManager()
- ad_rspec_versions = []
- request_rspec_versions = []
- for rspec_version in version_manager.versions:
- if rspec_version.content_type in ['*', 'ad']:
- ad_rspec_versions.append(rspec_version.to_dict())
- if rspec_version.content_type in ['*', 'request']:
- request_rspec_versions.append(rspec_version.to_dict())
xrn=Xrn(api.hrn)
- version_more = {'interface':'aggregate',
- 'sfa': 2,
- 'geni_api': api.config.SFA_AGGREGATE_API_VERSION,
- 'testbed':'myplc',
- 'hrn':xrn.get_hrn(),
- 'geni_request_rspec_versions': request_rspec_versions,
- 'geni_ad_rspec_versions': ad_rspec_versions,
- }
- return version_core(version_more)
-
- def SliverStatus(self, api, slice_xrn, creds, options):
+ version = version_core()
+ version_generic = {'interface':'aggregate',
+ 'sfa': 2,
+ 'geni_api': api.config.SFA_AGGREGATE_API_VERSION,
+ 'hrn':xrn.get_hrn(),
+ 'urn':xrn.get_urn(),
+ }
+ version.update(version_generic)
+ testbed_version = self.driver.aggregate_version()
+ version.update(testbed_version)
+ return version
+
+ def SliverStatus (self, api, slice_xrn, creds, options):
call_id = options.get('call_id')
if Callids().already_handled(call_id): return {}
- (hrn, _) = urn_to_hrn(slice_xrn)
- # find out where this slice is currently running
- slicename = hrn_to_pl_slicename(hrn)
-
- slices = api.driver.GetSlices([slicename], ['slice_id', 'node_ids','person_ids','name','expires'])
- if len(slices) == 0:
- raise Exception("Slice %s not found (used %s as slicename internally)" % (slice_xrn, slicename))
- slice = slices[0]
-
- # report about the local nodes only
- nodes = api.driver.GetNodes({'node_id':slice['node_ids'],'peer_id':None},
- ['node_id', 'hostname', 'site_id', 'boot_state', 'last_contact'])
- site_ids = [node['site_id'] for node in nodes]
-
- result = {}
- top_level_status = 'unknown'
- if nodes:
- top_level_status = 'ready'
- slice_urn = Xrn(slice_xrn, 'slice').get_urn()
- result['geni_urn'] = slice_urn
- result['pl_login'] = slice['name']
- result['pl_expires'] = datetime.datetime.fromtimestamp(slice['expires']).ctime()
-
- resources = []
- for node in nodes:
- res = {}
- res['pl_hostname'] = node['hostname']
- res['pl_boot_state'] = node['boot_state']
- res['pl_last_contact'] = node['last_contact']
- if node['last_contact'] is not None:
- res['pl_last_contact'] = datetime.datetime.fromtimestamp(node['last_contact']).ctime()
- sliver_id = urn_to_sliver_id(slice_urn, slice['slice_id'], node['node_id'])
- res['geni_urn'] = sliver_id
- if node['boot_state'] == 'boot':
- res['geni_status'] = 'ready'
- else:
- res['geni_status'] = 'failed'
- top_level_status = 'failed'
-
- res['geni_error'] = ''
-
- resources.append(res)
-
- result['geni_status'] = top_level_status
- result['geni_resources'] = resources
- return result
+ xrn = Xrn(slice_xrn)
+ slice_urn=xrn.get_urn()
+ slice_hrn=xrn.get_hrn()
+
+ return self.driver.sliver_status (slice_urn, slice_hrn)
def CreateSliver(self, api, slice_xrn, creds, rspec_string, users, options):
"""
call_id = options.get('call_id')
if Callids().already_handled(call_id): return ""
- aggregate = PlAggregate(self.driver)
- slices = PlSlices(api)
- (hrn, _) = urn_to_hrn(slice_xrn)
- peer = slices.get_peer(hrn)
- sfa_peer = slices.get_sfa_peer(hrn)
- slice_record=None
- if users:
- slice_record = users[0].get('slice_record', {})
-
- # parse rspec
- rspec = RSpec(rspec_string)
- requested_attributes = rspec.version.get_slice_attributes()
-
- # ensure site record exists
- site = slices.verify_site(hrn, slice_record, peer, sfa_peer, options=options)
- # ensure slice record exists
- slice = slices.verify_slice(hrn, slice_record, peer, sfa_peer, options=options)
- # ensure person records exists
- persons = slices.verify_persons(hrn, slice, users, peer, sfa_peer, options=options)
- # ensure slice attributes exists
- slices.verify_slice_attributes(slice, requested_attributes, options=options)
-
- # add/remove slice from nodes
- requested_slivers = [node.get('component_name') for node in rspec.version.get_nodes_with_slivers()]
- nodes = slices.verify_slice_nodes(slice, requested_slivers, peer)
-
- # add/remove links links
- slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
-
- # handle MyPLC peer association.
- # only used by plc and ple.
- slices.handle_peer(site, slice, persons, peer)
-
- return aggregate.get_rspec(slice_xrn=slice_xrn, version=rspec.version)
-
+ xrn = Xrn(slice_xrn)
+ slice_urn=xrn.get_urn()
+ slice_hrn=xrn.get_hrn()
+
+ return self.driver.create_sliver (slice_urn, slice_hrn, creds, rspec_string, users, options)
def RenewSliver(self, api, xrn, creds, expiration_time, options):
call_id = options.get('call_id')
if Callids().already_handled(call_id): return True
- (hrn, _) = urn_to_hrn(xrn)
- slicename = hrn_to_pl_slicename(hrn)
- slices = api.driver.GetSlices({'name': slicename}, ['slice_id'])
- if not slices:
- raise RecordNotFound(hrn)
- slice = slices[0]
- requested_time = utcparse(expiration_time)
- record = {'expires': int(time.mktime(requested_time.timetuple()))}
- try:
- api.driver.UpdateSlice(slice['slice_id'], record)
- return True
- except:
- return False
+
+ xrn = Xrn(slice_xrn)
+ slice_urn=xrn.get_urn()
+ slice_hrn=xrn.get_hrn()
+
+ return self.driver.renew_sliver (slice_urn, slice_hrn, creds, expiration_time, options)
def start_slice(self, api, xrn, creds):
(hrn, _) = urn_to_hrn(xrn)
def GetTicket(self, api, xrn, creds, rspec, users, options):
(slice_hrn, _) = urn_to_hrn(xrn)
- slices = PlSlices(api)
+ slices = PlSlices(self.driver)
peer = slices.get_peer(slice_hrn)
sfa_peer = slices.get_sfa_peer(slice_hrn)
+import datetime
#
from sfa.util.faults import MissingSfaInfo, UnknownSfaType
from sfa.util.sfalogging import logger
# one would think the driver should not need to mess with the SFA db, but..
from sfa.storage.table import SfaTable
+from sfa.rspecs.version_manager import VersionManager
+from sfa.rspecs.rspec import RSpec
+
# the driver interface, mostly provides default behaviours
from sfa.managers.driver import Driver
from sfa.plc.plshell import PlShell
+import sfa.plc.peers as peers
+from sfa.plc.plaggregate import PlAggregate
+from sfa.plc.plslices import PlSlices
+
def list_to_dict(recs, key):
"""
convert a list of dictionaries into a dictionary keyed on the
def __init__ (self, config):
PlShell.__init__ (self, config)
+ Driver.__init__ (self, config)
- self.hrn = config.SFA_INTERFACE_HRN
+ ########################################
+ ########## registry oriented
+ ########################################
########## disabled users
def is_enabled (self, record):
logger.info('unexpected relation to maintain, %s -> %s'%(subject_type,target_type))
+ ########################################
+ ########## aggregate oriented
+ ########################################
+
+ def testbed_name (self): return "myplc"
+
+ # 'geni_request_rspec_versions' and 'geni_ad_rspec_versions' are mandatory
+ def aggregate_version (self):
+ version_manager = VersionManager()
+ ad_rspec_versions = []
+ request_rspec_versions = []
+ for rspec_version in version_manager.versions:
+ if rspec_version.content_type in ['*', 'ad']:
+ ad_rspec_versions.append(rspec_version.to_dict())
+ if rspec_version.content_type in ['*', 'request']:
+ request_rspec_versions.append(rspec_version.to_dict())
+ return {
+ 'testbed':self.testbed_name(),
+ 'geni_request_rspec_versions': request_rspec_versions,
+ 'geni_ad_rspec_versions': ad_rspec_versions,
+ }
+
+ def sliver_status (self, slice_urn, slice_hrn):
+ # find out where this slice is currently running
+ slicename = hrn_to_pl_slicename(slice_hrn)
+
+ slices = self.GetSlices([slicename], ['slice_id', 'node_ids','person_ids','name','expires'])
+ if len(slices) == 0:
+ raise Exception("Slice %s not found (used %s as slicename internally)" % (slice_xrn, slicename))
+ slice = slices[0]
+
+ # report about the local nodes only
+ nodes = self.GetNodes({'node_id':slice['node_ids'],'peer_id':None},
+ ['node_id', 'hostname', 'site_id', 'boot_state', 'last_contact'])
+ site_ids = [node['site_id'] for node in nodes]
+
+ result = {}
+ top_level_status = 'unknown'
+ if nodes:
+ top_level_status = 'ready'
+ result['geni_urn'] = slice_urn
+ result['pl_login'] = slice['name']
+ result['pl_expires'] = datetime.datetime.fromtimestamp(slice['expires']).ctime()
+
+ resources = []
+ for node in nodes:
+ res = {}
+ res['pl_hostname'] = node['hostname']
+ res['pl_boot_state'] = node['boot_state']
+ res['pl_last_contact'] = node['last_contact']
+ if node['last_contact'] is not None:
+ res['pl_last_contact'] = datetime.datetime.fromtimestamp(node['last_contact']).ctime()
+ sliver_id = urn_to_sliver_id(slice_urn, slice['slice_id'], node['node_id'])
+ res['geni_urn'] = sliver_id
+ if node['boot_state'] == 'boot':
+ res['geni_status'] = 'ready'
+ else:
+ res['geni_status'] = 'failed'
+ top_level_status = 'failed'
+
+ res['geni_error'] = ''
+
+ resources.append(res)
+
+ result['geni_status'] = top_level_status
+ result['geni_resources'] = resources
+ return result
+
+ def create_sliver (self, slice_urn, slice_hrn, creds, rspec_string, users, options):
+
+ aggregate = PlAggregate(self)
+ slices = PlSlices(self)
+ peer = slices.get_peer(slice_hrn)
+ sfa_peer = slices.get_sfa_peer(slice_hrn)
+ slice_record=None
+ if users:
+ slice_record = users[0].get('slice_record', {})
+
+ # parse rspec
+ rspec = RSpec(rspec_string)
+ requested_attributes = rspec.version.get_slice_attributes()
+
+ # ensure site record exists
+ site = slices.verify_site(slice_hrn, slice_record, peer, sfa_peer, options=options)
+ # ensure slice record exists
+ slice = slices.verify_slice(slice_hrn, slice_record, peer, sfa_peer, options=options)
+ # ensure person records exists
+ persons = slices.verify_persons(slice_hrn, slice, users, peer, sfa_peer, options=options)
+ # ensure slice attributes exists
+ slices.verify_slice_attributes(slice, requested_attributes, options=options)
+
+ # add/remove slice from nodes
+ requested_slivers = [node.get('component_name') for node in rspec.version.get_nodes_with_slivers()]
+ nodes = slices.verify_slice_nodes(slice, requested_slivers, peer)
+
+ # add/remove links links
+ slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
+
+ # handle MyPLC peer association.
+ # only used by plc and ple.
+ slices.handle_peer(site, slice, persons, peer)
+
+ return aggregate.get_rspec(slice_xrn=slice_urn, version=rspec.version)
+
+ def renew_sliver (self, slice_urn, slice_hrn, creds, expiration_time, options):
+ slicename = hrn_to_pl_slicename(slice_hrn)
+ slices = self.driver.GetSlices({'name': slicename}, ['slice_id'])
+ if not slices:
+ raise RecordNotFound(slice_hrn)
+ slice = slices[0]
+ requested_time = utcparse(expiration_time)
+ record = {'expires': int(time.mktime(requested_time.timetuple()))}
+ try:
+ self.driver.UpdateSlice(slice['slice_id'], record)
+ return True
+ except:
+ return False
+
from types import StringTypes
from collections import defaultdict
-from sfa.util.xrn import get_leaf, get_authority, urn_to_hrn
-from sfa.util.plxrn import hrn_to_pl_slicename
-from sfa.util.policy import Policy
+from sfa.util.sfalogging import logger
+from sfa.util.xrn import Xrn, get_leaf, get_authority, urn_to_hrn
+#from sfa.util.policy import Policy
+from sfa.util.xrn import Xrn
+
from sfa.rspecs.rspec import RSpec
+
from sfa.plc.vlink import VLink
-from sfa.util.xrn import Xrn
+from sfa.util.plxrn import hrn_to_pl_slicename
MAXINT = 2L**31-1
rspec_to_slice_tag = {'max_rate':'net_max_rate'}
- def __init__(self, api, ttl = .5, origin_hrn=None):
- self.api = api
- #filepath = path + os.sep + filename
-# self.policy = Policy(self.api)
- self.origin_hrn = origin_hrn
- self.registry = api.registries[api.hrn]
- self.credential = api.getCredential()
- self.nodes = []
- self.persons = []
+ def __init__(self, driver):
+ self.driver = driver
def get_slivers(self, xrn, node=None):
hrn, type = urn_to_hrn(xrn)
slice_name = hrn_to_pl_slicename(hrn)
# XX Should we just call PLCAPI.GetSliceTicket(slice_name) instead
# of doing all of this?
- #return self.api.driver.GetSliceTicket(self.auth, slice_name)
+ #return self.driver.GetSliceTicket(self.auth, slice_name)
# from PLCAPI.GetSlivers.get_slivers()
slice_fields = ['slice_id', 'name', 'instantiation', 'expires', 'person_ids', 'slice_tag_ids']
- slices = self.api.driver.GetSlices(slice_name, slice_fields)
+ slices = self.driver.GetSlices(slice_name, slice_fields)
# Build up list of users and slice attributes
person_ids = set()
all_slice_tag_ids = set()
person_ids = list(person_ids)
all_slice_tag_ids = list(all_slice_tag_ids)
# Get user information
- all_persons_list = self.api.driver.GetPersons({'person_id':person_ids,'enabled':True}, ['person_id', 'enabled', 'key_ids'])
+ all_persons_list = self.driver.GetPersons({'person_id':person_ids,'enabled':True}, ['person_id', 'enabled', 'key_ids'])
all_persons = {}
for person in all_persons_list:
all_persons[person['person_id']] = person
key_ids.update(person['key_ids'])
key_ids = list(key_ids)
# Get user account keys
- all_keys_list = self.api.driver.GetKeys(key_ids, ['key_id', 'key', 'key_type'])
+ all_keys_list = self.driver.GetKeys(key_ids, ['key_id', 'key', 'key_type'])
all_keys = {}
for key in all_keys_list:
all_keys[key['key_id']] = key
# Get slice attributes
- all_slice_tags_list = self.api.driver.GetSliceTags(all_slice_tag_ids)
+ all_slice_tags_list = self.driver.GetSliceTags(all_slice_tag_ids)
all_slice_tags = {}
for slice_tag in all_slice_tags_list:
all_slice_tags[slice_tag['slice_tag_id']] = slice_tag
site_authority = get_authority(slice_authority).lower()
# check if we are already peered with this site_authority, if so
- peers = self.api.driver.GetPeers({}, ['peer_id', 'peername', 'shortname', 'hrn_root'])
+ peers = self.driver.GetPeers({}, ['peer_id', 'peername', 'shortname', 'hrn_root'])
for peer_record in peers:
names = [name.lower() for name in peer_record.values() if isinstance(name, StringTypes)]
if site_authority in names:
slice_authority = get_authority(hrn)
site_authority = get_authority(slice_authority)
- if site_authority != self.api.hrn:
+ if site_authority != self.driver.hrn:
sfa_peer = site_authority
return sfa_peer
def verify_slice_nodes(self, slice, requested_slivers, peer):
- nodes = self.api.driver.GetNodes(slice['node_ids'], ['node_id', 'hostname', 'interface_ids'])
+ nodes = self.driver.GetNodes(slice['node_ids'], ['node_id', 'hostname', 'interface_ids'])
current_slivers = [node['hostname'] for node in nodes]
# remove nodes not in rspec
try:
if peer:
- self.api.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
- self.api.driver.AddSliceToNodes(slice['name'], added_nodes)
- self.api.driver.DeleteSliceFromNodes(slice['name'], deleted_nodes)
+ self.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
+ self.driver.AddSliceToNodes(slice['name'], added_nodes)
+ self.driver.DeleteSliceFromNodes(slice['name'], deleted_nodes)
except:
- self.api.logger.log_exc('Failed to add/remove slice from nodes')
+ logger.log_exc('Failed to add/remove slice from nodes')
return nodes
def free_egre_key(self):
used = set()
- for tag in self.api.driver.GetSliceTags({'tagname': 'egre_key'}):
+ for tag in self.driver.GetSliceTags({'tagname': 'egre_key'}):
used.add(int(tag['value']))
for i in range(1, 256):
nodes_dict[node['node_id']] = node
interface_ids.extend(node['interface_ids'])
# build dict of interfaces
- interfaces = self.api.driver.GetInterfaces(interface_ids)
+ interfaces = self.driver.GetInterfaces(interface_ids)
interfaces_dict = {}
for interface in interfaces:
interfaces_dict[interface['interface_id']] = interface
slice_tags.append({'name': 'topo_rspec', 'value': str([topo_rspec]), 'node_id': node_id})
# set vini_topo tag
slice_tags.append({'name': 'vini_topo', 'value': 'manual', 'node_id': node_id})
- #self.api.driver.AddSliceTag(slice['name'], 'topo_rspec', str([topo_rspec]), node_id)
+ #self.driver.AddSliceTag(slice['name'], 'topo_rspec', str([topo_rspec]), node_id)
self.verify_slice_attributes(slice, slice_tags, {'append': True}, admin=True)
# bind site
try:
if site:
- self.api.driver.BindObjectToPeer('site', site['site_id'], peer['shortname'], slice['site_id'])
+ self.driver.BindObjectToPeer('site', site['site_id'], peer['shortname'], slice['site_id'])
except Exception,e:
- self.api.driver.DeleteSite(site['site_id'])
+ self.driver.DeleteSite(site['site_id'])
raise e
# bind slice
try:
if slice:
- self.api.driver.BindObjectToPeer('slice', slice['slice_id'], peer['shortname'], slice['slice_id'])
+ self.driver.BindObjectToPeer('slice', slice['slice_id'], peer['shortname'], slice['slice_id'])
except Exception,e:
- self.api.driver.DeleteSlice(slice['slice_id'])
+ self.driver.DeleteSlice(slice['slice_id'])
raise e
# bind persons
for person in persons:
try:
- self.api.driver.BindObjectToPeer('person',
+ self.driver.BindObjectToPeer('person',
person['person_id'], peer['shortname'], person['peer_person_id'])
for (key, remote_key_id) in zip(person['keys'], person['key_ids']):
try:
- self.api.driver.BindObjectToPeer( 'key', key['key_id'], peer['shortname'], remote_key_id)
+ self.driver.BindObjectToPeer( 'key', key['key_id'], peer['shortname'], remote_key_id)
except:
- self.api.driver.DeleteKey(key['key_id'])
- self.api.logger("failed to bind key: %s to peer: %s " % (key['key_id'], peer['shortname']))
+ self.driver.DeleteKey(key['key_id'])
+ logger("failed to bind key: %s to peer: %s " % (key['key_id'], peer['shortname']))
except Exception,e:
- self.api.driver.DeletePerson(person['person_id'])
+ self.driver.DeletePerson(person['person_id'])
raise e
return slice
slicename = hrn_to_pl_slicename(slice_hrn)
authority_name = slicename.split('_')[0]
login_base = authority_name[:20]
- sites = self.api.driver.GetSites(login_base)
+ sites = self.driver.GetSites(login_base)
if not sites:
# create new site record
site = {'name': 'geni.%s' % authority_name,
'peer_site_id': None}
if peer:
site['peer_site_id'] = slice_record.get('site_id', None)
- site['site_id'] = self.api.driver.AddSite(site)
+ site['site_id'] = self.driver.AddSite(site)
# exempt federated sites from monitor policies
- self.api.driver.AddSiteTag(site['site_id'], 'exempt_site_until', "20200101")
+ self.driver.AddSiteTag(site['site_id'], 'exempt_site_until', "20200101")
# # is this still necessary?
# # add record to the local registry
site = sites[0]
if peer:
# unbind from peer so we can modify if necessary. Will bind back later
- self.api.driver.UnBindObjectFromPeer('site', site['site_id'], peer['shortname'])
+ self.driver.UnBindObjectFromPeer('site', site['site_id'], peer['shortname'])
return site
slicename = hrn_to_pl_slicename(slice_hrn)
parts = slicename.split("_")
login_base = parts[0]
- slices = self.api.driver.GetSlices([slicename])
+ slices = self.driver.GetSlices([slicename])
if not slices:
slice = {'name': slicename,
'url': slice_record.get('url', slice_hrn),
'description': slice_record.get('description', slice_hrn)}
# add the slice
- slice['slice_id'] = self.api.driver.AddSlice(slice)
+ slice['slice_id'] = self.driver.AddSlice(slice)
slice['node_ids'] = []
slice['person_ids'] = []
if peer:
if peer:
slice['peer_slice_id'] = slice_record.get('slice_id', None)
# unbind from peer so we can modify if necessary. Will bind back later
- self.api.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
+ self.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
#Update existing record (e.g. expires field) it with the latest info.
if slice_record and slice['expires'] != slice_record['expires']:
- self.api.driver.UpdateSlice( slice['slice_id'], {'expires' : slice_record['expires']})
+ self.driver.UpdateSlice( slice['slice_id'], {'expires' : slice_record['expires']})
return slice
existing_user_ids_filter.append(user['username']+'@geni.net')
if existing_user_ids_filter:
# get existing users by email
- existing_users = self.api.driver.GetPersons({'email': existing_user_ids_filter},
+ existing_users = self.driver.GetPersons({'email': existing_user_ids_filter},
['person_id', 'key_ids', 'email'])
existing_user_ids.extend([user['email'] for user in existing_users])
if users_by_site:
# get a list of user sites (based on requeste user urns
- site_list = self.api.driver.GetSites(users_by_site.keys(), \
+ site_list = self.driver.GetSites(users_by_site.keys(), \
['site_id', 'login_base', 'person_ids'])
# get all existing users at these sites
sites = {}
sites[site['site_id']] = site
site_user_ids.extend(site['person_ids'])
- existing_site_persons_list = self.api.driver.GetPersons(site_user_ids,
+ existing_site_persons_list = self.driver.GetPersons(site_user_ids,
['person_id', 'key_ids', 'email', 'site_ids'])
# all requested users are either existing users or new (added) users
requested_user_ids = users_dict.keys()
# existing slice users
existing_slice_users_filter = {'person_id': slice_record.get('person_ids', [])}
- existing_slice_users = self.api.driver.GetPersons(existing_slice_users_filter,
+ existing_slice_users = self.driver.GetPersons(existing_slice_users_filter,
['person_id', 'key_ids', 'email'])
existing_slice_user_ids = [user['email'] for user in existing_slice_users]
append = options.get('append', True)
if append == False:
for removed_user_id in removed_user_ids:
- self.api.driver.DeletePersonFromSlice(removed_user_id, slice_record['name'])
+ self.driver.DeletePersonFromSlice(removed_user_id, slice_record['name'])
# update_existing users
updated_users_list = [user for user in existing_slice_users if user['email'] in \
updated_user_ids]
'keys': [],
'key_ids': added_user.get('key_ids', []),
}
- person['person_id'] = self.api.driver.AddPerson(person)
+ person['person_id'] = self.driver.AddPerson(person)
if peer:
person['peer_person_id'] = added_user['person_id']
added_persons.append(person)
# enable the account
- self.api.driver.UpdatePerson(person['person_id'], {'enabled': True})
+ self.driver.UpdatePerson(person['person_id'], {'enabled': True})
# add person to site
- self.api.driver.AddPersonToSite(added_user_id, added_user['site'])
+ self.driver.AddPersonToSite(added_user_id, added_user['site'])
for key_string in added_user.get('keys', []):
key = {'key':key_string, 'key_type':'ssh'}
- key['key_id'] = self.api.driver.AddPersonKey(person['person_id'], key)
+ key['key_id'] = self.driver.AddPersonKey(person['person_id'], key)
person['keys'].append(key)
# add the registry record
for added_slice_user_id in added_slice_user_ids.union(added_user_ids):
# add person to the slice
- self.api.driver.AddPersonToSlice(added_slice_user_id, slice_record['name'])
+ self.driver.AddPersonToSlice(added_slice_user_id, slice_record['name'])
# if this is a peer record then it should already be bound to a peer.
# no need to return worry about it getting bound later
key_ids = []
for person in persons:
key_ids.extend(person['key_ids'])
- keylist = self.api.driver.GetKeys(key_ids, ['key_id', 'key'])
+ keylist = self.driver.GetKeys(key_ids, ['key_id', 'key'])
keydict = {}
for key in keylist:
keydict[key['key']] = key['key_id']
try:
if peer:
person = persondict[user['email']]
- self.api.driver.UnBindObjectFromPeer('person', person['person_id'], peer['shortname'])
- key['key_id'] = self.api.driver.AddPersonKey(user['email'], key)
+ self.driver.UnBindObjectFromPeer('person', person['person_id'], peer['shortname'])
+ key['key_id'] = self.driver.AddPersonKey(user['email'], key)
if peer:
key_index = user_keys.index(key['key'])
remote_key_id = user['key_ids'][key_index]
- self.api.driver.BindObjectToPeer('key', key['key_id'], peer['shortname'], remote_key_id)
+ self.driver.BindObjectToPeer('key', key['key_id'], peer['shortname'], remote_key_id)
finally:
if peer:
- self.api.driver.BindObjectToPeer('person', person['person_id'], peer['shortname'], user['person_id'])
+ self.driver.BindObjectToPeer('person', person['person_id'], peer['shortname'], user['person_id'])
# remove old keys (only if we are not appending)
append = options.get('append', True)
if keydict[existing_key_id] in removed_keys:
try:
if peer:
- self.api.driver.UnBindObjectFromPeer('key', existing_key_id, peer['shortname'])
- self.api.driver.DeleteKey(existing_key_id)
+ self.driver.UnBindObjectFromPeer('key', existing_key_id, peer['shortname'])
+ self.driver.DeleteKey(existing_key_id)
except:
pass
filter = {'category': '*slice*'}
if not admin:
filter['|roles'] = ['user']
- slice_attributes = self.api.driver.GetTagTypes(filter)
+ slice_attributes = self.driver.GetTagTypes(filter)
valid_slice_attribute_names = [attribute['tagname'] for attribute in slice_attributes]
# get sliver attributes
added_slice_attributes = []
removed_slice_attributes = []
ignored_slice_attribute_names = []
- existing_slice_attributes = self.api.driver.GetSliceTags({'slice_id': slice['slice_id']})
+ existing_slice_attributes = self.driver.GetSliceTags({'slice_id': slice['slice_id']})
# get attributes that should be removed
for slice_tag in existing_slice_attributes:
# remove stale attributes
for attribute in removed_slice_attributes:
try:
- self.api.driver.DeleteSliceTag(attribute['slice_tag_id'])
+ self.driver.DeleteSliceTag(attribute['slice_tag_id'])
except Exception, e:
- self.api.logger.warn('Failed to remove sliver attribute. name: %s, value: %s, node_id: %s\nCause:%s'\
+ logger.warn('Failed to remove sliver attribute. name: %s, value: %s, node_id: %s\nCause:%s'\
% (name, value, node_id, str(e)))
# add requested_attributes
for attribute in added_slice_attributes:
try:
- self.api.driver.AddSliceTag(slice['name'], attribute['name'], attribute['value'], attribute.get('node_id', None))
+ self.driver.AddSliceTag(slice['name'], attribute['name'], attribute['value'], attribute.get('node_id', None))
except Exception, e:
- self.api.logger.warn('Failed to add sliver attribute. name: %s, value: %s, node_id: %s\nCause:%s'\
+ logger.warn('Failed to add sliver attribute. name: %s, value: %s, node_id: %s\nCause:%s'\
% (name, value, node_id, str(e)))
- def create_slice_aggregate(self, xrn, rspec):
- hrn, type = urn_to_hrn(xrn)
- # Determine if this is a peer slice
- peer = self.get_peer(hrn)
- sfa_peer = self.get_sfa_peer(hrn)
-
- spec = RSpec(rspec)
- # Get the slice record from sfa
- slicename = hrn_to_pl_slicename(hrn)
- slice = {}
- slice_record = None
- registry = self.api.registries[self.api.hrn]
- credential = self.api.getCredential()
-
- site_id, remote_site_id = self.verify_site(registry, credential, hrn, peer, sfa_peer)
- slice = self.verify_slice(registry, credential, hrn, site_id, remote_site_id, peer, sfa_peer)
-
- # find out where this slice is currently running
- nodelist = self.api.driver.GetNodes(slice['node_ids'], ['hostname'])
- hostnames = [node['hostname'] for node in nodelist]
-
- # get netspec details
- nodespecs = spec.getDictsByTagName('NodeSpec')
-
- # dict in which to store slice attributes to set for the nodes
- nodes = {}
- for nodespec in nodespecs:
- if isinstance(nodespec['name'], list):
- for nodename in nodespec['name']:
- nodes[nodename] = {}
- for k in nodespec.keys():
- rspec_attribute_value = nodespec[k]
- if (self.rspec_to_slice_tag.has_key(k)):
- slice_tag_name = self.rspec_to_slice_tag[k]
- nodes[nodename][slice_tag_name] = rspec_attribute_value
- elif isinstance(nodespec['name'], StringTypes):
- nodename = nodespec['name']
- nodes[nodename] = {}
- for k in nodespec.keys():
- rspec_attribute_value = nodespec[k]
- if (self.rspec_to_slice_tag.has_key(k)):
- slice_tag_name = self.rspec_to_slice_tag[k]
- nodes[nodename][slice_tag_name] = rspec_attribute_value
-
- for k in nodespec.keys():
- rspec_attribute_value = nodespec[k]
- if (self.rspec_to_slice_tag.has_key(k)):
- slice_tag_name = self.rspec_to_slice_tag[k]
- nodes[nodename][slice_tag_name] = rspec_attribute_value
-
- node_names = nodes.keys()
- # remove nodes not in rspec
- deleted_nodes = list(set(hostnames).difference(node_names))
- # add nodes from rspec
- added_nodes = list(set(node_names).difference(hostnames))
-
- try:
- if peer:
- self.api.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
-
- self.api.driver.AddSliceToNodes(slicename, added_nodes)
-
- # Add recognized slice tags
- for node_name in node_names:
- node = nodes[node_name]
- for slice_tag in node.keys():
- value = node[slice_tag]
- if (isinstance(value, list)):
- value = value[0]
-
- self.api.driver.AddSliceTag(slicename, slice_tag, value, node_name)
-
- self.api.driver.DeleteSliceFromNodes(slicename, deleted_nodes)
- finally:
- if peer:
- self.api.driver.BindObjectToPeer('slice', slice['slice_id'], peer, slice['peer_slice_id'])
-
- return 1
-