sfa/managers/aggregate_manager_pl.py

   1 ### $Id: slices.py 15842 2009-11-22 09:56:13Z anil $
   2 ### $URL: https://svn.planet-lab.org/svn/sfa/trunk/sfa/plc/slices.py $
   3
   4 import datetime
   5 import time
   6 import traceback
   7 import sys
   8
   9 from types import StringTypes
  10 from sfa.util.misc import *
  11 from sfa.util.rspec import *
  12 from sfa.util.specdict import *
  13 from sfa.util.faults import *
  14 from sfa.util.record import GeniRecord
  15 from sfa.util.policy import Policy
  16 from sfa.util.record import *
  17 from sfa.util.sfaticket import SfaTicket
  18 from sfa.server.registry import Registries
  19 from sfa.util.debug import log
  20 import sfa.plc.peers as peers
  21
  22 def delete_slice(api, hrn):
  23     slicename = hrn_to_pl_slicename(hrn)
  24     slices = api.plshell.GetSlices(api.plauth, {'name': slicename})
  25     if not slices:
  26         return 1
  27     slice = slices[0]
  28
  29     # determine if this is a peer slice
  30     peer = peers.get_peer(api, hrn)
  31     if peer:
  32         api.plshell.UnBindObjectFromPeer(api.plauth, 'slice', slice['slice_id'], peer)
  33     api.plshell.DeleteSliceFromNodes(api.plauth, slicename, slice['node_ids'])
  34     if peer:
  35         api.plshell.BindObjectToPeer(api.plauth, 'slice', slice['slice_id'], peer, slice['peer_slice_id'])
  36     return 1
  37
  38 def create_slice(api, hrn, rspec):
  39     # XX just import the legacy module and excute that until
  40     # we transition the code to this module
  41     from sfa.plc.slices import Slices
  42     slices = Slices(api)
  43     slices.create_slice(hrn, rspec)
  44
  45 def get_ticket(api, slice_hrn, rspec, origin_hrn=None):
  46     # the the slice record
  47     registries = Registries(api)
  48     registry = registries[api.hrn]
  49     credential = api.getCredential()
  50     records = registry.resolve(credential, slice_hrn)
  51
  52     # make sure we get a local slice record
  53     record = None
  54     for tmp_record in records:
  55         if tmp_record['type'] == 'slice' and \
  56            not tmp_record['peer_authority']:
  57             record = SliceRecord(dict=tmp_record)
  58     if not record:
  59         raise RecordNotFound(slice_hrn)
  60
  61     # get sliver info
  62     slivers = Slices(api).get_slivers(slice_hrn)
  63     if not slivers:
  64         raise SliverDoesNotExist(slice_hrn)
  65
  66     # get initscripts
  67     initscripts = None
  68     data = {
  69         'timestamp': int(time.time()),
  70         'initscripts': initscripts,
  71         'slivers': slivers
  72     }
  73
  74     # create the ticket
  75     object_gid = record.get_gid_object()
  76     new_ticket = SfaTicket(subject = object_gid.get_subject())
  77     new_ticket.set_gid_caller(api.auth.client_gid)
  78     new_ticket.set_gid_object(object_gid)
  79     new_ticket.set_issuer(key=api.key, subject=api.hrn)
  80     new_ticket.set_pubkey(object_gid.get_pubkey())
  81     new_ticket.set_attributes(data)
  82     new_ticket.set_rspec(rspec)
  83     #new_ticket.set_parent(api.auth.hierarchy.get_auth_ticket(auth_hrn))
  84     new_ticket.encode()
  85     new_ticket.sign()
  86
  87     return new_ticket.save_to_string(save_parents=True)
  88
  89 def start_slice(api, hrn):
  90     slicename = hrn_to_pl_slicename(hrn)
  91     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
  92     if not slices:
  93         raise RecordNotFound(hrn)
  94     slice_id = slices[0]
  95     attributes = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'name': 'enabled'}, ['slice_attribute_id'])
  96     attribute_id = attreibutes[0]['slice_attribute_id']
  97     api.plshell.UpdateSliceTag(api.plauth, attribute_id, "1" )
  98
  99     return 1
 100
 101 def stop_slice(api, hrn):
 102     slicename = hrn_to_pl_slicename(hrn)
 103     slices = api.plshell.GetSlices(api.plauth, {'name': slicename}, ['slice_id'])
 104     if not slices:
 105         raise RecordNotFound(hrn)
 106     slice_id = slices[0]['slice_id']
 107     attributes = api.plshell.GetSliceTags(api.plauth, {'slice_id': slice_id, 'name': 'enabled'}, ['slice_attribute_id'])
 108     attribute_id = attributes[0]['slice_attribute_id']
 109     api.plshell.UpdateSliceTag(api.plauth, attribute_id, "0")
 110     return 1
 111
 112 def reset_slice(api, hrn):
 113     # XX not implemented at this interface
 114     return 1
 115
 116 def get_slices(api):
 117     # XX just import the legacy module and excute that until
 118     # we transition the code to this module
 119     from sfa.plc.slices import Slices
 120     slices = Slices(api)
 121     slices.refresh()
 122     return slices['hrn']
 123
 124
 125 def get_rspec(api, hrn=None, origin_hrn=None):
 126     from sfa.plc.nodes import Nodes
 127     nodes = Nodes(api, origin_hrn=origin_hrn)
 128     if hrn:
 129         rspec = nodes.get_rspec(hrn)
 130     else:
 131         nodes.refresh()
 132         rspec = nodes['rspec']
 133
 134     return rspec
 135
 136 """
 137 Returns the request context required by sfatables. At some point, this mechanism should be changed
 138 to refer to "contexts", which is the information that sfatables is requesting. But for now, we just
 139 return the basic information needed in a dict.
 140 """
 141 def fetch_context(slice_hrn, user_hrn, contexts):
 142     base_context = {'sfa':{'user':{'hrn':user_hrn}}}
 143     return base_context
 144
 145 def main():
 146     r = RSpec()
 147     r.parseFile(sys.argv[1])
 148     rspec = r.toDict()
 149     create_slice(None,'plc.princeton.tmacktestslice',rspec)
 150
 151 if __name__ == "__main__":
 152     main()