X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fmanagers%2Faggregate_manager_pl.py;h=417cd7c5b74dda1636ac6363e5c210bf7773b346;hb=0dcdc484fb3eb219385cb539b6fdbbebf3c000a6;hp=5791bfaaf7b9af62b354f4b010587df8806bf15d;hpb=70ee1916beed76677a3f2d5fedda3a0a2a068af4;p=sfa.git diff --git a/sfa/managers/aggregate_manager_pl.py b/sfa/managers/aggregate_manager_pl.py index 5791bfaa..417cd7c5 100644 --- a/sfa/managers/aggregate_manager_pl.py +++ b/sfa/managers/aggregate_manager_pl.py @@ -7,18 +7,23 @@ import traceback import sys from types import StringTypes -from sfa.util.misc import * +from sfa.util.namespace import * from sfa.util.rspec import * from sfa.util.specdict import * from sfa.util.faults import * -from sfa.util.record import GeniRecord +from sfa.util.record import SfaRecord from sfa.util.policy import Policy -from sfa.util.prefixTree import prefixTree +from sfa.util.record import * +from sfa.util.sfaticket import SfaTicket from sfa.util.debug import log -from sfa.server.registry import Registries +from sfa.plc.slices import Slices import sfa.plc.peers as peers +from sfa.plc.network import * +from sfa.plc.api import SfaAPI +from sfa.plc.slices import * -def delete_slice(api, hrn): +def delete_slice(api, xrn): + hrn, type = urn_to_hrn(xrn) slicename = hrn_to_pl_slicename(hrn) slices = api.plshell.GetSlices(api.plauth, {'name': slicename}) if not slices: @@ -26,7 +31,7 @@ def delete_slice(api, hrn): slice = slices[0] # determine if this is a peer slice - peer = peers.get_peer(hrn) + peer = peers.get_peer(api, hrn) if peer: api.plshell.UnBindObjectFromPeer(api.plauth, 'slice', slice['slice_id'], peer) api.plshell.DeleteSliceFromNodes(api.plauth, slicename, slice['node_ids']) @@ -34,14 +39,107 @@ def delete_slice(api, hrn): api.plshell.BindObjectToPeer(api.plauth, 'slice', slice['slice_id'], peer, slice['peer_slice_id']) return 1 -def create_slice(api, hrn, rspec): - # XX just import the legacy module and excute that until - # we transition the code to this module - from sfa.plc.slices import Slices +def __get_hostnames(nodes): + hostnames = [] + for node in nodes: + hostnames.append(node.hostname) + return hostnames + +def create_slice(api, xrn, xml): + """ + Verify HRN and initialize the slice record in PLC if necessary. + """ + + hrn, type = urn_to_hrn(xrn) + peer = None slices = Slices(api) - slices.create_slice(hrn, rspec) + peer = slices.get_peer(hrn) + sfa_peer = slices.get_sfa_peer(hrn) + registry = api.registries[api.hrn] + credential = api.getCredential() + site_id, remote_site_id = slices.verify_site(registry, credential, hrn, + peer, sfa_peer) + slice = slices.verify_slice(registry, credential, hrn, site_id, + remote_site_id, peer, sfa_peer) + + network = Network(api) + + slice = network.get_slice(api, hrn) + current = __get_hostnames(slice.get_nodes()) + + network.addRSpec(xml, api.config.SFA_AGGREGATE_RSPEC_SCHEMA) + + request = __get_hostnames(network.nodesWithSlivers()) + + # remove nodes not in rspec + deleted_nodes = list(set(current).difference(request)) + + # add nodes from rspec + added_nodes = list(set(request).difference(current)) + + if peer: + api.plshell.UnBindObjectFromPeer(api.plauth, 'slice', slice.id, peer) + + api.plshell.AddSliceToNodes(api.plauth, slice.name, added_nodes) + api.plshell.DeleteSliceFromNodes(api.plauth, slice.name, deleted_nodes) + + network.updateSliceTags() + + if peer: + api.plshell.BindObjectToPeer(api.plauth, 'slice', slice.id, peer, + slice.peer_id) + + # print network.toxml() + + return True + -def start_slice(api, hrn): +def get_ticket(api, xrn, rspec, origin_hrn=None): + slice_hrn, type = urn_to_hrn(xrn) + # the the slice record + registry = api.registries[api.hrn] + credential = api.getCredential() + records = registry.resolve(credential, xrn) + + # make sure we get a local slice record + record = None + for tmp_record in records: + if tmp_record['type'] == 'slice' and \ + not tmp_record['peer_authority']: + record = SliceRecord(dict=tmp_record) + if not record: + raise RecordNotFound(slice_hrn) + + # get sliver info + slivers = Slices(api).get_slivers(slice_hrn) + if not slivers: + raise SliverDoesNotExist(slice_hrn) + + # get initscripts + initscripts = [] + data = { + 'timestamp': int(time.time()), + 'initscripts': initscripts, + 'slivers': slivers + } + + # create the ticket + object_gid = record.get_gid_object() + new_ticket = SfaTicket(subject = object_gid.get_subject()) + new_ticket.set_gid_caller(api.auth.client_gid) + new_ticket.set_gid_object(object_gid) + new_ticket.set_issuer(key=api.key, subject=api.hrn) + new_ticket.set_pubkey(object_gid.get_pubkey()) + new_ticket.set_attributes(data) + new_ticket.set_rspec(rspec) + #new_ticket.set_parent(api.auth.hierarchy.get_auth_ticket(auth_hrn)) + new_ticket.encode() + new_ticket.sign() + + return new_ticket.save_to_string(save_parents=True) + +def start_slice(api, xrn): + hrn, type = urn_to_hrn(xrn) slicename = hrn_to_pl_slicename(hrn) slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id']) if not slices: @@ -53,7 +151,8 @@ def start_slice(api, hrn): return 1 -def stop_slice(api, hrn): +def stop_slice(api, xrn): + hrn, type = urn_to_hrn(xrn) slicename = hrn_to_pl_slicename(hrn) slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id']) if not slices: @@ -64,16 +163,73 @@ def stop_slice(api, hrn): api.plshell.UpdateSliceTag(api.plauth, attribute_id, "0") return 1 -def reset_slice(api, hrn): +def reset_slice(api, xrn): # XX not implemented at this interface return 1 def get_slices(api): - # XX just import the legacy module and excute that until - # we transition the code to this module - from sfa.plc.slices import Slices - slices = Slices(api) - slices.refresh() - return slices['hrn'] - + # look in cache first + if api.cache: + slices = api.cache.get('slices') + if slices: + return slices + + # get data from db + slices = api.plshell.GetSlices(api.plauth, {'peer_id': None}, ['name']) + slice_hrns = [slicename_to_hrn(api.hrn, slice['name']) for slice in slices] + slice_urns = [hrn_to_urn(slice_hrn, 'slice') for slice_hrn in slice_hrns] + + # cache the result + if api.cache: + api.cache.add('slices', slice_urns) + + return slice_urns +def get_rspec(api, xrn=None, origin_hrn=None): + # look in cache first + if api.cache and not xrn: + rspec = api.cache.get('nodes') + if rspec: + return rspec + + hrn, type = urn_to_hrn(xrn) + network = Network(api) + if (hrn): + if network.get_slice(api, hrn): + network.addSlice() + + rspec = network.toxml() + + # cache the result + if api.cache and not xrn: + api.cache.add('nodes', rspec) + + return rspec + +""" +Returns the request context required by sfatables. At some point, this +mechanism should be changed to refer to "contexts", which is the +information that sfatables is requesting. But for now, we just return +the basic information needed in a dict. +""" +def fetch_context(slice_xrn, user_xrn, contexts): + slice_hrn, type = urn_to_hrn(slice_xrn) + user_hrn, type = urn_to_hrn(user_xrn) + base_context = {'sfa':{'user':{'hrn':user_hrn}, 'slice':{'hrn':slice_hrn}}} + return base_context + +def main(): + api = SfaAPI() + """ + rspec = get_rspec(api, "plc.princeton.sapan", None) + #rspec = get_rspec(api, "plc.princeton.coblitz", None) + #rspec = get_rspec(api, "plc.pl.sirius", None) + print rspec + """ + f = open(sys.argv[1]) + xml = f.read() + f.close() + create_slice(api, "plc.princeton.sapan", xml) + +if __name__ == "__main__": + main()