58bfdb9c37803bcb49e1e3ea81cfd48bffe44074
[sfa.git] / 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 from sfa.plc.api import SfaAPI
47 from sfa.server.registry import Registries
48 from sfa.server.aggregate import Aggregates
49
50 # after http://www.erlenstar.demon.co.uk/unix/faq_2.html
51 def daemon():
52     """Daemonize the current process."""
53     if os.fork() != 0: os._exit(0)
54     os.setsid()
55     if os.fork() != 0: os._exit(0)
56     os.umask(0)
57     devnull = os.open(os.devnull, os.O_RDWR)
58     os.dup2(devnull, 0)
59     # xxx fixme - this is just to make sure that nothing gets stupidly lost - should use devnull
60     crashlog = os.open('/var/log/sfa.daemon', os.O_RDWR | os.O_APPEND | os.O_CREAT, 0644)
61     os.dup2(crashlog, 1)
62     os.dup2(crashlog, 2)
63
64 def init_server_key(server_key_file, server_cert_file, config, hierarchy):
65
66     subject = config.SFA_INTERFACE_HRN
67     # check if the server's private key exists. If it doesnt,
68     # get the right one from the authorities directory. If it cant be
69     # found in the authorities directory, generate a random one
70     if not os.path.exists(server_key_file):
71         hrn = config.SFA_INTERFACE_HRN.lower()
72         hrn_parts = hrn.split(".")
73         rel_key_path = hrn
74         pkey_filename = hrn+".pkey"
75
76         # sub authority's have "." in their hrn. This must
77         # be converted to os.path separator
78         if len(hrn_parts) > 0:
79             rel_key_path = hrn.replace(".", os.sep)
80             pkey_filename= hrn_parts[-1]+".pkey"
81
82         key_file = os.sep.join([hierarchy.basedir, rel_key_path, pkey_filename])
83         if not os.path.exists(key_file):
84             # if it doesnt exist then this is probably a fresh interface
85             # with no records. Generate a random keypair for now
86             trace("server's public key not found in %s" % key_file)
87             trace("generating a random server key pair")
88             key = Keypair(create=True)
89             key.save_to_file(server_key_file)
90             cert = Certificate(subject=subject)
91             cert.set_issuer(key=key, subject=subject)
92             cert.set_pubkey(key)
93             cert.sign()
94             cert.save_to_file(server_cert_file, save_parents=True)
95
96         else:
97             # the pkey was found in the authorites directory. lets 
98             # copy it to where the server key should be and generate
99             # the cert
100             key = Keypair(filename=key_file)
101             key.save_to_file(server_key_file)
102             cert = Certificate(subject=subject)
103             cert.set_issuer(key=key, subject=subject)
104             cert.set_pubkey(key)
105             cert.sign()
106             cert.save_to_file(server_cert_file, save_parents=True)
107
108
109     # If private key exists and cert doesnt, recreate cert
110     if (os.path.exists(server_key_file)) and (not os.path.exists(server_cert_file)):
111         key = Keypair(filename=server_key_file)
112         cert = Certificate(subject=subject)
113         cert.set_issuer(key=key, subject=subject)
114         cert.set_pubkey(key)
115         cert.sign()
116         cert.save_to_file(server_cert_file)
117
118 def init_server(options, config):
119     """
120     Execute the init method defined in the manager file 
121     """
122     manager_base = 'sfa.managers'
123     if options.registry:
124         mgr_type = config.SFA_REGISTRY_TYPE
125         manager_module = manager_base + ".registry_manager_%s" % mgr_type
126         try: manager = __import__(manager_module, fromlist=[manager_base])
127         except: manager = None
128         if manager and hasattr(manager, 'init_server'): 
129             manager.init_server()    
130     if options.am:
131         mgr_type = config.SFA_AGGREGATE_TYPE
132         manager_module = manager_base + ".aggregate_manager_%s" % mgr_type
133         try: manager = __import__(manager_module, fromlist=[manager_base])
134         except: manager = None
135         if manager and hasattr(manager, 'init_server'):
136             manager.init_server()    
137     if options.sm:
138         mgr_type = config.SFA_SM_TYPE
139         manager_module = manager_base + ".slice_manager_%s" % mgr_type
140         try: manager = __import__(manager_module, fromlist=[manager_base])
141         except: manager = None
142         if manager and hasattr(manager, 'init_server'):
143             manager.init_server()    
144     if options.cm:
145         mgr_type = config.SFA_CM_TYPE
146         manager_module = manager_base + ".component_manager_%s" % mgr_type
147         try: manager = __import__(manager_module, fromlist=[manager_base])
148         except: manager = None
149         if manager and hasattr(manager, 'init_server'):
150             manager.init_server()    
151             
152
153 def sync_interfaces():
154     """
155     Attempt to install missing trusted gids and db records for 
156     our federated interfaces
157     """
158     api = SfaAPI()
159     registries = Registries(api)
160     aggregates = Aggregates(api)
161     registries.sync_interfaces()
162     aggregates.sync_interfaces()
163
164 def main():
165     # xxx get rid of globals - name consistently CamelCase or under_score
166     global AuthHierarchy
167     global TrustedRoots
168     global registry_port
169     global aggregate_port
170     global slicemgr_port
171
172     # Generate command line parser
173     parser = OptionParser(usage="sfa-server [options]")
174     parser.add_option("-r", "--registry", dest="registry", action="store_true",
175          help="run registry server", default=False)
176     parser.add_option("-s", "--slicemgr", dest="sm", action="store_true",
177          help="run slice manager", default=False)
178     parser.add_option("-a", "--aggregate", dest="am", action="store_true",
179          help="run aggregate manager", default=False)
180     parser.add_option("-c", "--component", dest="cm", action="store_true",
181          help="run component server", default=False)
182     parser.add_option("-v", "--verbose", dest="verbose", action="store_true", 
183          help="verbose mode", default=False)
184     parser.add_option("-d", "--daemon", dest="daemon", action="store_true",
185          help="Run as daemon.", default=False)
186     (options, args) = parser.parse_args()
187
188     if (options.daemon):  daemon()
189
190     config = Config()
191     hierarchy = Hierarchy()
192     server_key_file = os.path.join(hierarchy.basedir, "server.key")
193     server_cert_file = os.path.join(hierarchy.basedir, "server.cert")
194
195     init_server_key(server_key_file, server_cert_file, config, hierarchy)
196     init_server(options, config)
197     sync_interfaces()   
198  
199     # start registry server
200     if (options.registry):
201         from sfa.server.registry import Registry
202         r = Registry("", registry_port, server_key_file, server_cert_file)
203         r.start()
204
205     # start aggregate manager
206     if (options.am):
207         from sfa.server.aggregate import Aggregate
208         a = Aggregate("", aggregate_port, server_key_file, server_cert_file)
209         a.start()
210
211     # start slice manager
212     if (options.sm):
213         from sfa.server.slicemgr import SliceMgr
214         s = SliceMgr("", slicemgr_port, server_key_file, server_cert_file)
215         s.start()
216
217     if (options.cm):
218         from sfa.server.component import Component
219         c = Component("", component_port, server_key_file, server_cert_file)
220         c.start()
221
222 if __name__ == "__main__":
223     main()