sfa/server/sfa-server.py

   1 #!/usr/bin/python
   2 #
   3 ### $Id$
   4 ### $URL$
   5 #
   6 # SFA PLC Wrapper
   7 #
   8 # This wrapper implements the SFA Registry and Slice Interfaces on PLC.
   9 # Depending on command line options, it starts some combination of a
  10 # Registry, an Aggregate Manager, and a Slice Manager.
  11 #
  12 # There are several items that need to be done before starting the wrapper
  13 # server.
  14 #
  15 # NOTE:  Many configuration settings, including the PLC maintenance account
  16 # credentials, URI of the PLCAPI, and PLC DB URI and admin credentials are initialized
  17 # from your MyPLC configuration (/etc/planetlab/plc_config*).  Please make sure this information
  18 # is up to date and accurate.
  19 #
  20 # 1) Import the existing planetlab database, creating the
  21 #    appropriate SFA records. This is done by running the "sfa-import-plc.py" tool.
  22 #
  23 # 2) Create a "trusted_roots" directory and place the certificate of the root
  24 #    authority in that directory. Given the defaults in sfa-import-plc.py, this
  25 #    certificate would be named "planetlab.gid". For example,
  26 #
  27 #    mkdir trusted_roots; cp authorities/planetlab.gid trusted_roots/
  28 #
  29 # TODO: Can all three servers use the same "registry" certificate?
  30 ##
  31
  32 # TCP ports for the three servers
  33 registry_port=12345
  34 aggregate_port=12346
  35 slicemgr_port=12347
  36 component_port=12346
  37
  38 import os, os.path
  39 import sys
  40 from optparse import OptionParser
  41 from sfa.trust.trustedroot import TrustedRootList
  42 from sfa.trust.certificate import Keypair, Certificate
  43 from sfa.trust.hierarchy import Hierarchy
  44 from sfa.util.config import Config
  45 from sfa.util.report import trace
  46
  47 # after http://www.erlenstar.demon.co.uk/unix/faq_2.html
  48 def daemon():
  49     """Daemonize the current process."""
  50     if os.fork() != 0: os._exit(0)
  51     os.setsid()
  52     if os.fork() != 0: os._exit(0)
  53     os.umask(0)
  54     devnull = os.open(os.devnull, os.O_RDWR)
  55     os.dup2(devnull, 0)
  56     # xxx fixme - this is just to make sure that nothing gets stupidly lost - should use devnull
  57     crashlog = os.open('/var/log/sfa.daemon', os.O_RDWR | os.O_APPEND | os.O_CREAT, 0644)
  58     os.dup2(crashlog, 1)
  59     os.dup2(crashlog, 2)
  60
  61 def init_server_key(server_key_file, server_cert_file, config, hierarchy):
  62
  63     subject = config.SFA_INTERFACE_HRN
  64     # check if the server's private key exists. If it doesnt,
  65     # get the right one from the authorities directory. If it cant be
  66     # found in the authorities directory, generate a random one
  67     if not os.path.exists(server_key_file):
  68         hrn = config.SFA_INTERFACE_HRN.lower()
  69         hrn_parts = hrn.split(".")
  70         rel_key_path = hrn
  71         pkey_filename = hrn+".pkey"
  72
  73         # sub authority's have "." in their hrn. This must
  74         # be converted to os.path separator
  75         if len(hrn_parts) > 0:
  76             rel_key_path = hrn.replace(".", os.sep)
  77             pkey_filename= hrn_parts[-1]+".pkey"
  78
  79         key_file = os.sep.join([hierarchy.basedir, rel_key_path, pkey_filename])
  80         if not os.path.exists(key_file):
  81             # if it doesnt exist then this is probably a fresh interface
  82             # with no records. Generate a random keypair for now
  83             trace("server's public key not found in %s" % key_file)
  84             trace("generating a random server key pair")
  85             key = Keypair(create=True)
  86             key.save_to_file(server_key_file)
  87             cert = Certificate(subject=subject)
  88             cert.set_issuer(key=key, subject=subject)
  89             cert.set_pubkey(key)
  90             cert.sign()
  91             cert.save_to_file(server_cert_file, save_parents=True)
  92
  93         else:
  94             # the pkey was found in the authorites directory. lets
  95             # copy it to where the server key should be and generate
  96             # the cert
  97             key = Keypair(filename=key_file)
  98             key.save_to_file(server_key_file)
  99             cert = Certificate(subject=subject)
 100             cert.set_issuer(key=key, subject=subject)
 101             cert.set_pubkey(key)
 102             cert.sign()
 103             cert.save_to_file(server_cert_file, save_parents=True)
 104
 105
 106     # If private key exists and cert doesnt, recreate cert
 107     if (os.path.exists(server_key_file)) and (not os.path.exists(server_cert_file)):
 108         key = Keypair(filename=server_key_file)
 109         cert = Certificate(subject=subject)
 110         cert.set_issuer(key=key, subject=subject)
 111         cert.set_pubkey(key)
 112         cert.sign()
 113         cert.save_to_file(server_cert_file)
 114
 115 def init_server(options, config):
 116     """
 117     Execute the init method defined in the manager file
 118     """
 119     manager_base = 'sfa.managers'
 120     if options.registry:
 121         mgr_type = config.SFA_REGISTRY_TYPE
 122         manager_module = manager_base + ".registry_manager_%s" % mgr_type
 123         try: manager = __import__(manager_module, fromlist=[manager_base])
 124         except: manager = None
 125         if manager and hasattr(manager, 'init_server'):
 126             manager.init_server()
 127     if options.am:
 128         mgr_type = config.SFA_AGGREGATE_TYPE
 129         manager_module = manager_base + ".aggregate_manager_%s" % mgr_type
 130         try: manager = __import__(manager_module, fromlist=[manager_base])
 131         except: manager = None
 132         if manager and hasattr(manager, 'init_server'):
 133             manager.init_server()
 134     if options.sm:
 135         mgr_type = config.SFA_SM_TYPE
 136         manager_module = manager_base + ".slice_manager_%s" % mgr_type
 137         try: manager = __import__(manager_module, fromlist=[manager_base])
 138         except: manager = None
 139         if manager and hasattr(manager, 'init_server'):
 140             manager.init_server()
 141     if options.cm:
 142         mgr_type = config.SFA_CM_TYPE
 143         manager_module = manager_base + ".component_manager_%s" % mgr_type
 144         try: manager = __import__(manager_module, fromlist=[manager_base])
 145         except: manager = None
 146         if manager and hasattr(manager, 'init_server'):
 147             manager.init_server()
 148
 149
 150 def main():
 151     # xxx get rid of globals - name consistently CamelCase or under_score
 152     global AuthHierarchy
 153     global TrustedRoots
 154     global registry_port
 155     global aggregate_port
 156     global slicemgr_port
 157
 158     # Generate command line parser
 159     parser = OptionParser(usage="sfa-server [options]")
 160     parser.add_option("-r", "--registry", dest="registry", action="store_true",
 161          help="run registry server", default=False)
 162     parser.add_option("-s", "--slicemgr", dest="sm", action="store_true",
 163          help="run slice manager", default=False)
 164     parser.add_option("-a", "--aggregate", dest="am", action="store_true",
 165          help="run aggregate manager", default=False)
 166     parser.add_option("-c", "--component", dest="cm", action="store_true",
 167          help="run component server", default=False)
 168     parser.add_option("-v", "--verbose", dest="verbose", action="store_true",
 169          help="verbose mode", default=False)
 170     parser.add_option("-d", "--daemon", dest="daemon", action="store_true",
 171          help="Run as daemon.", default=False)
 172     (options, args) = parser.parse_args()
 173
 174     if (options.daemon):  daemon()
 175
 176     config = Config()
 177     hierarchy = Hierarchy()
 178     trusted_roots = TrustedRootList(config.get_trustedroots_dir())
 179     server_key_file = os.path.join(hierarchy.basedir, "server.key")
 180     server_cert_file = os.path.join(hierarchy.basedir, "server.cert")
 181
 182     init_server_key(server_key_file, server_cert_file, config, hierarchy)
 183     init_server(options, config)
 184
 185     # start registry server
 186     if (options.registry):
 187         from sfa.server.registry import Registry
 188         r = Registry("", registry_port, server_key_file, server_cert_file)
 189         r.start()
 190
 191     # start aggregate manager
 192     if (options.am):
 193         from sfa.server.aggregate import Aggregate
 194         a = Aggregate("", aggregate_port, server_key_file, server_cert_file)
 195         a.start()
 196
 197     # start slice manager
 198     if (options.sm):
 199         from sfa.server.slicemgr import SliceMgr
 200         s = SliceMgr("", slicemgr_port, server_key_file, server_cert_file)
 201         s.start()
 202
 203     if (options.cm):
 204         from sfa.server.component import Component
 205         c = Component("", component_port, server_key_file, server_cert_file)
 206         c.start()
 207
 208 if __name__ == "__main__":
 209     main()