geni/alt_aggregate.py

   1 ### $Id$
   2 ### $URL$
   3
   4 import os
   5 import sys
   6 import datetime
   7 import time
   8 import xmlrpclib
   9
  10 from geni.util.geniserver import GeniServer
  11 from geni.util.geniclient import *
  12 from geni.util.certificate import Keypair, Certificate
  13 from geni.util.credential import Credential
  14 from geni.util.trustedroot import TrustedRootList
  15 from geni.util.faults import *
  16 from geni.util.misc import *
  17 from geni.util.config import Config
  18 from geni.util.rspec import Rspec
  19 from geni.util.specdict import *
  20 from geni.util.storage import SimpleStorage
  21
  22 class AltAggregate(GeniServer):
  23
  24     hrn = None
  25     nodes_ttl = None
  26     nodes = None
  27     slices = None
  28     policy = None
  29     timestamp = None
  30     threshold = None
  31     shell = None
  32     registry = None
  33     key_file = None
  34     cert_file = None
  35     credential = None
  36
  37     ##
  38     # Create a new aggregate object.
  39     #
  40     # @param ip the ip address to listen on
  41     # @param port the port to listen on
  42     # @param key_file private key filename of registry
  43     # @param cert_file certificate filename containing public key (could be a GID file)
  44
  45     def __init__(self, ip, port, key_file, cert_file, config = "/etc/sfa/sfa_config"):
  46         GeniServer.__init__(self, ip, port, key_file, cert_file)
  47         self.key_file = key_file
  48         self.cert_file = cert_file
  49         self.config = Config(config)
  50         self.basedir = self.config.GENI_BASE_DIR + os.sep
  51         self.server_basedir = self.basedir + os.sep + "geni" + os.sep
  52         self.hrn = self.config.GENI_INTERFACE_HRN
  53
  54         nodes_file = os.sep.join([self.server_basedir, 'agg.' + self.hrn + '.components'])
  55         self.nodes = SimpleStorage(nodes_file)
  56         self.nodes.load()
  57
  58         slices_file = os.sep.join([self.server_basedir, 'agg.' + self.hrn + '.slices'])
  59         self.slices = SimpleStorage(slices_file)
  60         self.slices.load()
  61
  62         policy_file = os.sep.join([self.server_basedir, 'agg.' + self.hrn + '.policy'])
  63         self.policy = SimpleStorage(policy_file, {'whitelist': [], 'blacklist': []})
  64         self.policy.load()
  65
  66         timestamp_file = os.sep.join([self.server_basedir, 'agg.' + self.hrn + '.timestamp'])
  67         self.timestamp = SimpleStorage(timestamp_file)
  68
  69         self.nodes_ttl = 1
  70
  71         self.connectRegistry()
  72         #self.loadCredential()
  73
  74     def connectRegistry(self):
  75         """
  76         Connect to the registry
  77         """
  78         # connect to registry using GeniClient
  79         address = self.config.GENI_REGISTRY_HOST
  80         port = self.config.GENI_REGISTRY_PORT
  81         url = 'https://%(address)s:%(port)s' % locals()
  82         self.registry = GeniClient(url, self.key_file, self.cert_file)
  83
  84     def loadCredential(self):
  85         """
  86         Attempt to load credential from file if it exists. If it doesnt get
  87         credential from registry.
  88         """
  89
  90         self_cred_filename = self.server_basedir + os.sep + "agg." + self.hrn + ".cred"
  91         ma_cred_filename = self.server_basedir + os.sep + "agg." + self.hrn + ".ma.cred"
  92
  93         # see if this file exists
  94         try:
  95             cred = Credential(filename = ma_cred_filename, subject=self.hrn)
  96             self.credential = cred.save_to_string()
  97         except IOError:
  98             # get self credential
  99             self_cred = self.registry.get_credential(None, 'ma', self.hrn)
 100             self_credential = Credential(string = self_cred)
 101             self_credential.save_to_file(self_cred_filename)
 102
 103             # get ma credential
 104             ma_cred = self.registry.get_credential(self_cred)
 105             ma_credential = Credential(string = ma_cred)
 106             ma_credential.save_to_file(ma_cred_filename)
 107             self.credential = ma_cred
 108
 109     def load_policy(self):
 110         """
 111         Read the list of blacklisted and whitelisted nodes.
 112         """
 113         self.policy.load()
 114
 115     def getNodes(self, format = 'rspec'):
 116         """
 117         Return a list of components at this aggregate.
 118         """
 119
 120     def getSlices(self):
 121         """
 122         Return a list of instnatiated managed by this slice manager.
 123         """
 124
 125     def getResources(self, slice_hrn):
 126         """
 127         Return the current rspec for the specified slice.
 128         """
 129
 130     def getTicket(self, hrn, rspec):
 131         """
 132         Retrieve a ticket
 133         """
 134
 135     def createSlice(self, slice_hrn, rspec, attributes = []):
 136         """
 137         Instantiate/update slice according rspec
 138         """
 139
 140     def updateSlice(self, slice_hrn, rspec, attributes = []):
 141         return self.create_slice(slice_hrn, rspec, attributes)
 142
 143     def deleteSlice(self, slice_hrn):
 144         """
 145         Remove this slice
 146         """
 147
 148     def startSlice(self, slice_hrn):
 149         """
 150         Stop the slice
 151         """
 152
 153     def stopSlice(self, slice_hrn):
 154         """
 155         Stop the slice at the aggregate level
 156         """
 157
 158     def resetSlice(self, slice_hrn):
 159         """
 160         Reset the slice
 161         """
 162
 163     def getPolicy(self):
 164         """
 165         Return this aggregates policy.
 166         """
 167
 168
 169 ##############################
 170 ## Server methods here for now
 171 ##############################
 172
 173     def list_nodes(self, cred, format):
 174         self.decode_authentication(cred, 'listnodes')
 175         return self.getNodes(format)
 176
 177     def list_slices(self, cred):
 178         self.decode_authentication(cred, 'listslices')
 179         return self.getSlices()
 180
 181     def get_resources(self, cred, hrn):
 182         self.decode_authentication(cred, 'listnodes')
 183         return self.getResources(hrn)
 184
 185     def get_ticket(self, cred, hrn, rspec):
 186         self.decode_authentication(cred, 'getticket')
 187         return self.getTicket(hrn, rspec)
 188
 189     def get_policy(self, cred):
 190         self.decode_authentication(cred, 'getpolicy')
 191         return self.getPolicy()
 192
 193     def create_slice(self, cred, hrn, rspec):
 194         self.decode_authentication(cred, 'createslice')
 195         return self.createSlice(hrn, rspec)
 196
 197     def update_slice(self, cred, hrn, rspec):
 198         self.decode_authentication(cred, 'updateslice')
 199         return self.updateSlice(hrn)
 200
 201     def delete_slice(self, cred, hrn):
 202         self.decode_authentication(cred, 'deleteslice')
 203         return self.deleteSlice(hrn)
 204
 205     def start_slice(self, cred, hrn):
 206         self.decode_authentication(cred, 'startslice')
 207         return self.startSlice(hrn)
 208
 209     def stop_slice(self, cred, hrn):
 210         self.decode_authentication(cred, 'stopslice')
 211         return self.stopSlice(hrn)
 212
 213     def reset_slice(self, cred, hrn):
 214         self.decode_authentication(cred, 'resetslice')
 215         return self.resetSlice(hrn)
 216
 217     def register_functions(self):
 218         GeniServer.register_functions(self)
 219
 220         # Aggregate interface methods
 221         self.server.register_function(self.list_nodes)
 222         self.server.register_function(self.list_slices)
 223         self.server.register_function(self.get_resources)
 224         self.server.register_function(self.get_ticket)
 225         self.server.register_function(self.get_policy)
 226         self.server.register_function(self.create_slice)
 227         self.server.register_function(self.update_slice)
 228         self.server.register_function(self.delete_slice)
 229         self.server.register_function(self.start_slice)
 230         self.server.register_function(self.stop_slice)
 231         self.server.register_function(self.reset_slice)
 232