X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=geni%2Fslicemgr.py;h=ed250637d63dc6f36132efccd7c894688bd5c634;hb=d50cd5814d4e83a2433c695cb76730fafac13fe3;hp=9e6be186c270066b82de1af81ee137e2f92e4816;hpb=4e5ca52f5f61668751cf2b014b63cdfde3b6a318;p=sfa.git diff --git a/geni/slicemgr.py b/geni/slicemgr.py index 9e6be186..ed250637 100644 --- a/geni/slicemgr.py +++ b/geni/slicemgr.py @@ -6,6 +6,7 @@ import time from geni.util.geniserver import * from geni.util.geniclient import * from geni.util.cert import * +from geni.util.credential import Credential from geni.util.trustedroot import * from geni.util.excep import * from geni.util.misc import * @@ -17,8 +18,6 @@ from geni.util.storage import SimpleStorage class SliceMgr(GeniServer): hrn = None - key_file = None - cert_file = None nodes_ttl = None nodes = None slices = None @@ -28,7 +27,9 @@ class SliceMgr(GeniServer): threshold = None shell = None registry = None - + key_file = None + cert_file = None + credential = None ## # Create a new slice manager object. @@ -57,11 +58,11 @@ class SliceMgr(GeniServer): self.nodes = SimpleStorage(nodes_file) self.nodes.load() - slices_file = os.sep.join([server_basedir, 'slicemgr' + self.hrn + '.slices']) + slices_file = os.sep.join([server_basedir, 'smgr' + self.hrn + '.slices']) self.slices = SimpleStorage(slices_file) self.slices.load() - policy_file = os.sep.join([server_basedir, 'smgr.policy']) + policy_file = os.sep.join([server_basedir, 'smgr.' + self.hrn + '.policy']) self.policy = SimpleStorage(policy_file) self.policy.load() @@ -71,6 +72,33 @@ class SliceMgr(GeniServer): self.nodes_ttl = 1 self.connectAggregates() self.connectRegistry() + self.loadCredential() + + + def loadCredential(self): + """ + Attempt to load credential from file if it exists. If it doesnt get + credential from registry. + """ + + self_cred_filename = self.server_basedir + os.sep + "smgr." + self.hrn + ".cred" + ma_cred_filename = self.server_basedir + os.sep + "smgr." + self.hrn + ".sa.cred" + + # see if this file exists + try: + cred = Credential(filename = ma_cred_filename) + self.credential = cred.save_to_string() + except IOError: + # get self credential + self_cred = self.registry.get_credential(None, 'ma', self.hrn) + self_credential = Credential(string = self_cred) + self_credential.save_to_file(self_cred_filename) + + # get ma credential + ma_cred = self.registry.get_gredential(self_cred) + ma_credential = Credential(string = ma_cred) + ma_credential.save_to_file(ma_cred_filename) + self.credential = ma_cred def connect_aggregates(self, aggregates_file): """ @@ -190,13 +218,13 @@ class SliceMgr(GeniServer): def load_slices(self): """ - Read current slice instantiation states. + Read current slice instantiation states. """ print "loading slices" self.slices.load() - def get_components(self): + def getComponents(self): """ Return a list of components managed by this slice manager. """ @@ -210,18 +238,19 @@ class SliceMgr(GeniServer): return self.nodes.keys() - def get_slices(self): + def getSlices(self): """ Return a list of instnatiated managed by this slice manager. """ + # XX return only the slices at the specified hrn return dict(self.slices) - def get_resources(self, slice_hrn): + def getResources(self, slice_hrn): """ Return the current rspec for the specified slice. """ + cred = self.credential - cred = None if slice_hrn in self.slices.keys(): # check if we alreay have this slices state saved rspec = self.slices[slice_hrn] @@ -257,12 +286,12 @@ class SliceMgr(GeniServer): return rspec - def create_slice(self, slice_hrn, rspec, attributes): + def createSlice(self, slice_hrn, rspec, attributes): """ Instantiate the specified slice according to whats defined in the rspec. """ # XX need to gget the correct credentials - cred = None + cred = self.credential # save slice state locally # we can assume that spec object has been validated so its safer to @@ -299,19 +328,19 @@ class SliceMgr(GeniServer): return 1 - def update_slice(self, slice_hrn, rspec, attributes = []): + def updateSlice(self, slice_hrn, rspec, attributes = []): """ Update the specifed slice """ self.create_slice(slice_hrn, rspec, attributes) - def delete_slice_(self, slice_hrn): + def deleteSlice_(self, slice_hrn): """ Remove this slice from all components it was previouly associated with and free up the resources it was using. """ # XX need to get the correct credential - cred = None + cred = self.credential if self.slices.has_key(slice_hrn): self.slices.pop(slice_hrn) @@ -322,33 +351,33 @@ class SliceMgr(GeniServer): return 1 - def start_slice(self, slice_hrn): + def startSlice(self, slice_hrn): """ Stop the slice at plc. """ - # XX need to get the correct credential - cred = None + cred = self.credential for hrn in self.aggregates.keys(): self.aggregates[hrn].startSlice(cred, slice_hrn) return 1 - def stop_slice(self, slice_hrn): + def stopSlice(self, slice_hrn): """ Stop the slice at plc """ + cred = self.credential for hrn in self.aggregates.keys(): self.aggregates[hrn].startSlice(cred, slice_hrn) return 1 - def reset_slice(self, slice_hrn): + def resetSlice(self, slice_hrn): """ Reset the slice """ # XX not yet implemented return 1 - def get_policy(self): + def getPolicy(self): """ Return the policy of this slice manager. """ @@ -361,55 +390,52 @@ class SliceMgr(GeniServer): ## Server methods here for now ############################## - def nodes(self): - return self.get_components() + def list_components(self): + return self.getComponents() - def slices(self): - return self.get_slices() + def list_slices(self, cred, hrn): + self.decode_authentication(cred, 'list') + return self.getSlices(hrn) - def resources(self, cred, hrn): + def get_resources(self, cred, hrn): self.decode_authentication(cred, 'info') - self.verify_object_belongs_to_me(hrn) + return self.getResources(hrn) - return self.get_resources(hrn) + def get_policy(self, cred): + self.decode_authentication(cred, 'info') + return self.getPolicy() - def create(self, cred, hrn, rspec): + def create_slice(self, cred, hrn, rspec): self.decode_authentication(cred, 'embed') - self.verify_object_belongs_to_me(hrn, rspec) - return self.create(hrn) + return self.createSlice(hrn) - def delete(self, cred, hrn): + def delete_slice(self, cred, hrn): self.decode_authentication(cred, 'embed') - self.verify_object_belongs_to_me(hrn) - return self.delete_slice(hrn) + return self.deleteSlice(hrn) - def start(self, cred, hrn): + def start_slice(self, cred, hrn): self.decode_authentication(cred, 'control') - return self.start(hrn) + return self.startSlice(hrn) - def stop(self, cred, hrn): + def stop_slice(self, cred, hrn): self.decode_authentication(cred, 'control') - return self.stop(hrn) + return self.stopSlice(hrn) - def reset(self, cred, hrn): + def reset_slice(self, cred, hrn): self.decode_authentication(cred, 'control') - return self.reset(hrn) - - def policy(self, cred): - self.decode_authentication(cred, 'info') - return self.get_policy() + return self.resetSlice(hrn) def register_functions(self): GeniServer.register_functions(self) # Aggregate interface methods - self.server.register_function(self.components) - self.server.register_function(self.slices) - self.server.register_function(self.resources) - self.server.register_function(self.create) - self.server.register_function(self.delete) - self.server.register_function(self.start) - self.server.register_function(self.stop) - self.server.register_function(self.reset) - self.server.register_function(self.policy) + self.server.register_function(self.list_components) + self.server.register_function(self.list_slices) + self.server.register_function(self.get_resources) + self.server.register_function(self.get_policy) + self.server.register_function(self.create_slice) + self.server.register_function(self.delete_slice) + self.server.register_function(self.start_slice) + self.server.register_function(self.stop_slice) + self.server.register_function(self.reset_slice)