# the driver interface, mostly provides default behaviours
from sfa.managers.driver import Driver
from sfa.planetlab.plshell import PlShell
-import sfa.planetlab.peers as peers
from sfa.planetlab.plaggregate import PlAggregate
from sfa.planetlab.plslices import PlSlices
from sfa.planetlab.plxrn import PlXrn, slicename_to_hrn, hostname_to_hrn, hrn_to_pl_slicename, xrn_to_hostname, top_auth, hash_loginbase
xrn = Xrn(urn)
aggregate = PlAggregate(self)
slices = PlSlices(self)
- peer = slices.get_peer(xrn.get_hrn())
sfa_peer = slices.get_sfa_peer(xrn.get_hrn())
slice_record=None
users = options.get('geni_users', [])
requested_attributes = rspec.version.get_slice_attributes()
# ensure site record exists
- site = slices.verify_site(xrn.hrn, slice_record, peer, sfa_peer, options=options)
+ site = slices.verify_site(xrn.hrn, slice_record, sfa_peer, options=options)
# ensure slice record exists
- slice = slices.verify_slice(xrn.hrn, slice_record, peer, sfa_peer, expiration=expiration, options=options)
+ slice = slices.verify_slice(xrn.hrn, slice_record, sfa_peer, expiration=expiration, options=options)
# ensure person records exists
- persons = slices.verify_persons(xrn.hrn, slice, users, peer, sfa_peer, options=options)
+ persons = slices.verify_persons(xrn.hrn, slice, users, sfa_peer, options=options)
# ensure slice attributes exists
slices.verify_slice_attributes(slice, requested_attributes, options=options)
# add/remove slice from nodes
request_nodes = rspec.version.get_nodes_with_slivers()
- nodes = slices.verify_slice_nodes(urn, slice, request_nodes, peer)
+ nodes = slices.verify_slice_nodes(urn, slice, request_nodes)
# add/remove links links
slices.verify_slice_links(slice, rspec.version.get_link_requests(), nodes)
# add/remove leases
rspec_requested_leases = rspec.version.get_leases()
- leases = slices.verify_slice_leases(slice, rspec_requested_leases, peer)
+ leases = slices.verify_slice_leases(slice, rspec_requested_leases)
- # handle MyPLC peer association.
- # only used by plc and ple.
- slices.handle_peer(site, slice, None, peer)
-
return aggregate.describe([xrn.get_urn()], version=rspec.version)
def provision(self, urns, options={}):
aggregate = PlAggregate(self)
slivers = aggregate.get_slivers(urns)
slice = slivers[0]
- peer = slices.get_peer(slice['hrn'])
sfa_peer = slices.get_sfa_peer(slice['hrn'])
users = options.get('geni_users', [])
- persons = slices.verify_persons(slice['hrn'], slice, users, peer, sfa_peer, options=options)
- slices.handle_peer(None, None, persons, peer)
+ persons = slices.verify_persons(slice['hrn'], slice, users, sfa_peer, options=options)
# update sliver allocation states and set them to geni_provisioned
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
dbsession=self.api.dbsession()
leases = self.shell.GetLeases({'name': slice_name})
leases_ids = [lease['lease_id'] for lease in leases ]
- # determine if this is a peer slice
- # xxx I wonder if this would not need to use PlSlices.get_peer instead
- # in which case plc.peers could be deprecated as this here
- # is the only/last call to this last method in plc.peers
- #slice_hrn = PlXrn(auth=self.hrn, slice_name).get_hrn()
slice_hrn = self.shell.GetSliceHrn(int(slice_id))
- peer = peers.get_peer(self, slice_hrn)
try:
- if peer:
- self.shell.UnBindObjectFromPeer('slice', slice_id, peer)
-
self.shell.DeleteSliceFromNodes(slice_id, node_ids)
if len(leases_ids) > 0:
self.shell.DeleteLeases(leases_ids)
dbsession=self.api.dbsession()
SliverAllocation.delete_allocations(sliver_ids,dbsession)
finally:
- if peer:
- self.shell.BindObjectToPeer('slice', slice_id, peer, slice['peer_slice_id'])
+ pass
# prepare return struct
geni_slivers = []
return slivers
- def get_peer(self, xrn):
- hrn, type = urn_to_hrn(xrn)
- # Becaues of myplc federation, we first need to determine if this
- # 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
-
- # 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()
-
- # check if we are already peered with this site_authority, if so
- peers = self.driver.shell.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
def get_sfa_peer(self, xrn):
hrn, type = urn_to_hrn(xrn)
return sfa_peer
- def verify_slice_leases(self, slice, rspec_requested_leases, peer):
+ def verify_slice_leases(self, slice, rspec_requested_leases):
leases = self.driver.shell.GetLeases({'name':slice['name'], 'clip':int(time.time())}, ['lease_id','name', 'hostname', 't_from', 't_until'])
grain = self.driver.shell.GetLeaseGranularity()
try:
- if peer:
- self.driver.shell.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
self.driver.shell.DeleteLeases(deleted_leases_id)
for lease in added_leases:
self.driver.shell.AddLeases(lease['hostname'], slice['name'], lease['t_from'], lease['t_until'])
return leases
- def verify_slice_nodes(self, slice_urn, slice, rspec_nodes, peer):
+ def verify_slice_nodes(self, slice_urn, slice, rspec_nodes):
slivers = {}
for node in rspec_nodes:
added_nodes = list(set(slivers.keys()).difference(current_slivers))
try:
- if peer:
- self.driver.shell.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
self.driver.shell.AddSliceToNodes(slice['name'], added_nodes)
self.driver.shell.DeleteSliceFromNodes(slice['name'], deleted_nodes)
- def handle_peer(self, site, slice, persons, peer):
- if peer:
- # bind site
- try:
- if site:
- self.driver.shell.BindObjectToPeer('site', site['site_id'], peer['shortname'], slice['site_id'])
- except Exception,e:
- self.driver.shell.DeleteSite(site['site_id'])
- raise e
-
- # bind slice
- try:
- if slice:
- self.driver.shell.BindObjectToPeer('slice', slice['slice_id'], peer['shortname'], slice['slice_id'])
- except Exception,e:
- self.driver.shell.DeleteSlice(slice['slice_id'])
- raise e
-
- # bind persons
- for person in persons:
- try:
- self.driver.shell.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.driver.shell.BindObjectToPeer( 'key', key['key_id'], peer['shortname'], remote_key_id)
- except:
- self.driver.shell.DeleteKey(key['key_id'])
- logger("failed to bind key: %s to peer: %s " % (key['key_id'], peer['shortname']))
- except Exception,e:
- self.driver.shell.DeletePerson(person['person_id'])
- raise e
-
- return slice
-
- def verify_site(self, slice_xrn, slice_record={}, peer=None, sfa_peer=None, options={}):
+ def verify_site(self, slice_xrn, slice_record={}, sfa_peer=None, options={}):
(slice_hrn, type) = urn_to_hrn(slice_xrn)
top_auth_hrn = top_auth(slice_hrn)
site_hrn = '.'.join(slice_hrn.split('.')[:-1])
return site
- def verify_slice(self, slice_hrn, slice_record, peer, sfa_peer, expiration, options={}):
+ def verify_slice(self, slice_hrn, slice_record, sfa_peer, expiration, options={}):
top_auth_hrn = top_auth(slice_hrn)
site_hrn = '.'.join(slice_hrn.split('.')[:-1])
slice_part = slice_hrn.split('.')[-1]
return self.driver.shell.GetSlices(int(slice['slice_id']))[0]
- def verify_persons(self, slice_hrn, slice_record, users, peer, sfa_peer, options={}):
+ def verify_persons(self, slice_hrn, slice_record, users, sfa_peer, options={}):
top_auth_hrn = top_auth(slice_hrn)
site_hrn = '.'.join(slice_hrn.split('.')[:-1])
slice_part = slice_hrn.split('.')[-1]
person_id = slice_persons_by_hrn[person_hrn].get('person_id')
persons_to_verify_keys[person_id] = users_by_hrn[person_hrn]
- self.verify_keys(persons_to_verify_keys, peer, options)
+ self.verify_keys(persons_to_verify_keys, options)
return persons_to_add
- def verify_keys(self, persons_to_verify_keys, peer, options={}):
+ def verify_keys(self, persons_to_verify_keys, options={}):
# we only add keys that comes from sfa to persons in PL
for person_id in persons_to_verify_keys:
person_sfa_keys = persons_to_verify_keys[person_id].get('keys', [])