sfa-0.9-17 tag
[sfa.git] / sfa / util / componentserver.py
1 ##
2 # This module implements a general-purpose server layer for sfa.
3 # The same basic server should be usable on the registry, component, or
4 # other interfaces.
5 #
6 # TODO: investigate ways to combine this with existing PLC server?
7 ##
8
9 ### $Id: componentserver.py 17275 2010-03-05 21:37:10Z tmack $
10 ### $URL: http://svn.planet-lab.org/svn/sfa/trunk/sfa/util/componentserver.py $
11
12 import sys
13 import traceback
14 import threading
15 import socket, os
16 import SocketServer
17 import BaseHTTPServer
18 import SimpleHTTPServer
19 import SimpleXMLRPCServer
20 from OpenSSL import SSL
21 from sfa.trust.certificate import Keypair, Certificate
22 from sfa.trust.credential import *
23 from sfa.util.faults import *
24 from sfa.plc.api import ComponentAPI 
25 from sfa.util.server import verify_callback, ThreadedServer 
26 from sfa.util.debug import log
27
28
29 ##
30 # taken from the web (XXX find reference). Implents HTTPS xmlrpc request handler
31
32 class SecureXMLRpcRequestHandler(SimpleXMLRPCServer.SimpleXMLRPCRequestHandler):
33     """Secure XML-RPC request handler class.
34
35     It it very similar to SimpleXMLRPCRequestHandler but it uses HTTPS for transporting XML data.
36     """
37     def setup(self):
38         self.connection = self.request
39         self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)
40         self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)
41
42     def do_POST(self):
43         """Handles the HTTPS POST request.
44
45         It was copied out from SimpleXMLRPCServer.py and modified to shutdown the socket cleanly.
46         """
47         try:
48             peer_cert = Certificate()
49             peer_cert.load_from_pyopenssl_x509(self.connection.get_peer_certificate())
50             self.api = ComponentAPI(peer_cert = peer_cert, 
51                            interface = self.server.interface, 
52                            key_file = self.server.key_file, 
53                            cert_file = self.server.cert_file)
54             # get arguments
55             request = self.rfile.read(int(self.headers["content-length"]))
56             # In previous versions of SimpleXMLRPCServer, _dispatch
57             # could be overridden in this class, instead of in
58             # SimpleXMLRPCDispatcher. To maintain backwards compatibility,
59             # check to see if a subclass implements _dispatch and dispatch
60             # using that method if present.
61             #response = self.server._marshaled_dispatch(request, getattr(self, '_dispatch', None))
62             # XX TODO: Need to get the real remote address
63             remote_addr = (remote_ip, remote_port) = self.connection.getpeername()
64             self.api.remote_addr = remote_addr
65             #remote_addr = (self.rfile.connection.remote_ip, remote_port)
66             #self.api.remote_addr = remote_addr
67             response = self.api.handle(remote_addr, request)
68
69         
70         except Exception, fault:
71             raise
72             # This should only happen if the module is buggy
73             # internal error, report as HTTP server error
74             self.send_response(500)
75             self.end_headers()
76             traceback.print_exc()
77         else:
78             # got a valid XML RPC response
79             self.send_response(200)
80             self.send_header("Content-type", "text/xml")
81             self.send_header("Content-length", str(len(response)))
82             self.end_headers()
83             self.wfile.write(response)
84
85             # shut down the connection
86             self.wfile.flush()
87             self.connection.shutdown() # Modified here!
88
89 ##
90 # Implements an HTTPS XML-RPC server. Generally it is expected that SFA
91 # functions will take a credential string, which is passed to
92 # decode_authentication. Decode_authentication() will verify the validity of
93 # the credential, and verify that the user is using the key that matches the
94 # GID supplied in the credential.
95
96 class ComponentServer(threading.Thread):
97
98     ##
99     # Create a new SfaServer object.
100     #
101     # @param ip the ip address to listen on
102     # @param port the port to listen on
103     # @param key_file private key filename of registry
104     # @param cert_file certificate filename containing public key 
105     #   (could be a GID file)
106
107     def __init__(self, ip, port, key_file, cert_file, api=None):
108         threading.Thread.__init__(self)
109         self.key = Keypair(filename = key_file)
110         self.cert = Certificate(filename = cert_file)
111         self.server = ThreadedServer((ip, port), SecureXMLRpcRequestHandler, key_file, cert_file)
112         self.trusted_cert_list = None
113         self.register_functions()
114
115
116     ##
117     # Register functions that will be served by the XMLRPC server. This
118     # function should be overrided by each descendant class.
119
120     def register_functions(self):
121         self.server.register_function(self.noop)
122
123     ##
124     # Sample no-op server function. The no-op function decodes the credential
125     # that was passed to it.
126
127     def noop(self, cred, anything):
128         self.decode_authentication(cred)
129
130         return anything
131
132     ##
133     # Execute the server, serving requests forever. 
134
135     def run(self):
136         self.server.serve_forever()
137
138