from types import StringTypes
from collections import defaultdict
import sys
-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
-class Slices:
+class PlSlices:
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
# slice belongs to out local plc or a myplc peer. We will assume it
# is a local site, unless we find out otherwise
peer = None
- print>>sys.stderr, " \r\n \r\n \t slices.py get_peer slice_authority "
+ print>>sys.stderr, " \r\n \r\n \tplslices.py get_peer slice_authority "
# get this slice's authority (site)
slice_authority = get_authority(hrn)
# get this site's authority (sfa root authority or sub authority)
site_authority = get_authority(slice_authority).lower()
- print>>sys.stderr, " \r\n \r\n \t slices.py get_peer slice_authority %s site_authority %s" %(slice_authority,site_authority)
+ print>>sys.stderr, " \r\n \r\n \tplslices.py get_peer slice_authority %s site_authority %s" %(slice_authority,site_authority)
# check if we are already peered with this site_authority, if so
- #peers = self.api.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:
- #peer = peer_record
+ 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:
+ peer = peer_record
return peer
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'], ['hostname'])
+ 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):
return str(key)
- def verify_slice_links(self, slice, links, aggregate):
+ def verify_slice_links(self, slice, requested_links, nodes):
# nodes is undefined here
- if not links:
+ if not requested_links:
return
+
+ # build dict of nodes
+ nodes_dict = {}
+ interface_ids = []
+ for node in nodes:
+ nodes_dict[node['node_id']] = node
+ interface_ids.extend(node['interface_ids'])
+ # build dict of interfaces
+ interfaces = self.driver.GetInterfaces(interface_ids)
+ interfaces_dict = {}
+ for interface in interfaces:
+ interfaces_dict[interface['interface_id']] = interface
slice_tags = []
# need to update the attribute string?
slice_tags.append({'name': 'capabilities', 'value': 'CAP_NET_ADMIN'})
- for link in links:
+ for link in requested_links:
# get the ip address of the first node in the link
ifname1 = Xrn(link['interface1']['component_id']).get_leaf()
- (node, device) = ifname1.split(':')
- node_id = int(node.replace('node', ''))
- node = aggregate.nodes[node_id]
- if1 = aggregate.interfaces[node['interface_ids'][0]]
+ (node_raw, device) = ifname1.split(':')
+ node_id = int(node_raw.replace('node', ''))
+ node = nodes_dict[node_id]
+ if1 = interfaces_dict[node['interface_ids'][0]]
ipaddr = if1['ip']
topo_rspec = VLink.get_topo_rspec(link, ipaddr)
# set topo_rspec tag
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)
+ 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
- def verify_site(self, slice_xrn, slice_record={}, peer=None, sfa_peer=None):
+ def verify_site(self, slice_xrn, slice_record={}, peer=None, sfa_peer=None, options={}):
(slice_hrn, type) = urn_to_hrn(slice_xrn)
site_hrn = get_authority(slice_hrn)
# login base can't be longer than 20 characters
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
- if sfa_peer and slice_record:
- peer_dict = {'type': 'authority', 'hrn': site_hrn, \
- 'peer_authority': sfa_peer, 'pointer': site['site_id']}
- self.registry.register_peer_object(self.credential, peer_dict)
+# # is this still necessary?
+# # add record to the local registry
+# if sfa_peer and slice_record:
+# peer_dict = {'type': 'authority', 'hrn': site_hrn, \
+# 'peer_authority': sfa_peer, 'pointer': site['site_id']}
+# self.registry.register_peer_object(self.credential, peer_dict)
else:
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
- def verify_slice(self, slice_hrn, slice_record, peer, sfa_peer):
- #slicename = hrn_to_pl_slicename(slice_hrn)
- parts = hrn_to_pl_slicename(slice_hrn).split("_")
+ def verify_slice(self, slice_hrn, slice_record, peer, sfa_peer, options={}):
+ slicename = hrn_to_pl_slicename(slice_hrn)
+ parts = slicename.split("_")
login_base = parts[0]
- slicename = slice_hrn
- slices = self.api.driver.GetSlices([slicename])
- print>>sys.stderr, " \r\n \r\rn Slices.py verify_slice slicename %s slices %s slice_record %s"%(slicename ,slices, slice_record)
+ 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:
slice['peer_slice_id'] = slice_record.get('slice_id', None)
# mark this slice as an sfa peer record
- if sfa_peer:
- peer_dict = {'type': 'slice', 'hrn': slice_hrn,
- 'peer_authority': sfa_peer, 'pointer': slice['slice_id']}
- self.registry.register_peer_object(self.credential, peer_dict)
+# if sfa_peer:
+# peer_dict = {'type': 'slice', 'hrn': slice_hrn,
+# 'peer_authority': sfa_peer, 'pointer': slice['slice_id']}
+# self.registry.register_peer_object(self.credential, peer_dict)
else:
slice = slices[0]
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']})
+ if slice_record and slice['expires'] != slice_record['expires']:
+ self.driver.UpdateSlice( slice['slice_id'], {'expires' : slice_record['expires']})
return slice
#def get_existing_persons(self, users):
- def verify_persons(self, slice_hrn, slice_record, users, peer, sfa_peer, append=True):
+ def verify_persons(self, slice_hrn, slice_record, users, peer, sfa_peer, options={}):
users_by_email = {}
users_by_site = defaultdict(list)
-
users_dict = {}
for user in users:
- if 'append' in user and user['append'] == False:
- append = False
+ hrn, type = urn_to_hrn(user['urn'])
+ username = get_leaf(hrn)
+ login_base = get_leaf(get_authority(user['urn']))
+ user['username'] = username
+ user['site'] = login_base
+
if 'email' in user:
users_by_email[user['email']] = user
users_dict[user['email']] = user
- elif 'urn' in user:
- hrn, type = urn_to_hrn(user['urn'])
- username = get_leaf(hrn)
- login_base = get_leaf(get_authority(user['urn']))
- user['username'] = username
- users_by_site[login_base].append(user)
+ else:
+ users_by_site[user['site']].append(user)
+ # start building a list of existing users
existing_user_ids = []
+ existing_user_ids_filter = []
if users_by_email:
+ existing_user_ids_filter.extend(users_by_email.keys())
+ if users_by_site:
+ for login_base in users_by_site:
+ users = users_by_site[login_base]
+ for user in users:
+ 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': users_by_email.keys()},
+ 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 = {}
site_user_ids = []
-
- # get all existing users at these sites
for site in site_list:
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
user_found = False
for existing_user in existing_site_persons_list:
for site_id in existing_user['site_ids']:
- site = sites[site_id]
- if login_base == site['login_base'] and \
- existing_user['email'].startswith(requested_user['username']):
- existing_user_ids.append(existing_user['email'])
- users_dict[existing_user['email']] = requested_user
- user_found = True
- break
+ if site_id in sites:
+ site = sites[site_id]
+ if login_base == site['login_base'] and \
+ existing_user['email'].startswith(requested_user['username']+'@'):
+ existing_user_ids.append(existing_user['email'])
+ users_dict[existing_user['email']] = requested_user
+ user_found = True
+ break
if user_found:
break
fake_email = requested_user['username'] + '@geni.net'
users_dict[fake_email] = requested_user
-
# requested slice 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]
updated_user_ids = set(existing_slice_user_ids).intersection(requested_user_ids)
# Remove stale users (only if we are not appending).
+ # Append by default.
+ 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]
- self.verify_keys(existing_slice_users, updated_users_list, peer, append)
+ self.verify_keys(existing_slice_users, updated_users_list, peer, options)
added_persons = []
# add new users
'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, login_base)
+ 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
- if sfa_peer:
- peer_dict = {'type': 'user', 'hrn': hrn, 'peer_authority': sfa_peer, \
- 'pointer': person['person_id']}
- self.registry.register_peer_object(self.credential, peer_dict)
+# if sfa_peer:
+# peer_dict = {'type': 'user', 'hrn': hrn, 'peer_authority': sfa_peer, \
+# 'pointer': person['person_id']}
+# self.registry.register_peer_object(self.credential, peer_dict)
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
return added_persons
- def verify_keys(self, persons, users, peer, append=True):
+ def verify_keys(self, persons, users, peer, options={}):
# existing keys
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 append == False:
removed_keys = set(existing_keys).difference(requested_keys)
for existing_key_id in keydict:
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
- def verify_slice_attributes(self, slice, requested_slice_attributes, append=False, admin=False):
+ def verify_slice_attributes(self, slice, requested_slice_attributes, options={}, admin=False):
+ append = options.get('append', True)
# get list of attributes users ar able to manage
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:
if slice_tag['tagname'] in ignored_slice_attribute_names:
# 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
-
git://git.onelab.eu / sfa.git / blobdiff