Adding mod_python handler.

1 files changed, 240 insertions, 0 deletions

diff --git a/paste/modpython.py b/paste/modpython.py
new file mode 100644
index 0000000..f3b29bf
--- /dev/null
+++ b/paste/modpython.py
@@ -0,0 +1,240 @@
+"""
+WSGI Paste wrapper for mod_python. Requires Python 2.2 or greater.
+
+
+Example httpd.conf section for a Paste app with an ini file::
+
+    <Location />
+        SetHandler python-program
+        PythonHandler mod_python.wsgi_paste
+        PythonOption paste.ini /some/location/your/pasteconfig.ini
+    </Location>
+
+If you'd like to use a virtual installation, make sure to add it in the path
+like so::
+
+    <Location />
+        SetHandler python-program
+        PythonHandler mod_python.wsgi_paste
+        PythonPath "['/virtual/project/directory', '/virtual/lib/python2.4/'] + sys.path"
+        PythonOption paste.ini /virtual/project/directory/pasteconfig.ini
+    </Location>
+
+Some WSGI implementations assume that the SCRIPT_NAME environ variable will
+always be equal to "the root URL of the app"; Apache probably won't act as
+you expect in that case. You can add another PythonOption directive to tell
+modpython_gateway to force that behavior:
+
+    PythonOption SCRIPT_NAME /mcontrol
+
+Some WSGI applications need to be cleaned up when Apache exits. You can
+register a cleanup handler with yet another PythonOption directive:
+
+    PythonOption wsgi.cleanup module::function
+
+The module.function will be called with no arguments on server shutdown,
+once for each child process or thread.
+
+This module highly based on Robert Brewer's, here:
+http://projects.amor.org/misc/svn/modpython_gateway.py
+"""
+
+import traceback
+import os
+
+from mod_python import apache
+from paste.deploy import loadapp
+
+class InputWrapper(object):
+    
+    def __init__(self, req):
+        self.req = req
+    
+    def close(self):
+        pass
+    
+    def read(self, size=-1):
+        return self.req.read(size)
+    
+    def readline(self, size=-1):
+        return self.req.readline(size)
+    
+    def readlines(self, hint=-1):
+        return self.req.readlines(hint)
+    
+    def __iter__(self):
+        line = self.readline()
+        while line:
+            yield line
+            # Notice this won't prefetch the next line; it only
+            # gets called if the generator is resumed.
+            line = self.readline()
+
+
+class ErrorWrapper(object):
+    
+    def __init__(self, req):
+        self.req = req
+    
+    def flush(self):
+        pass
+    
+    def write(self, msg):
+        self.req.log_error(msg)
+    
+    def writelines(self, seq):
+        self.write(''.join(seq))
+
+
+bad_value = ("You must provide a PythonOption '%s', either 'on' or 'off', "
+             "when running a version of mod_python < 3.1")
+
+
+class Handler:
+    
+    def __init__(self, req):
+        self.started = False
+        
+        options = req.get_options()
+        
+        # Threading and forking
+        try:
+            q = apache.mpm_query
+            threaded = q(apache.AP_MPMQ_IS_THREADED)
+            forked = q(apache.AP_MPMQ_IS_FORKED)
+        except AttributeError:
+            threaded = options.get('multithread', '').lower()
+            if threaded == 'on':
+                threaded = True
+            elif threaded == 'off':
+                threaded = False
+            else:
+                raise ValueError(bad_value % "multithread")
+            
+            forked = options.get('multiprocess', '').lower()
+            if forked == 'on':
+                forked = True
+            elif forked == 'off':
+                forked = False
+            else:
+                raise ValueError(bad_value % "multiprocess")
+        
+        env = self.environ = dict(apache.build_cgi_env(req))
+        
+        if 'SCRIPT_NAME' in options:
+            # Override SCRIPT_NAME and PATH_INFO if requested.
+            env['SCRIPT_NAME'] = options['SCRIPT_NAME']
+            env['PATH_INFO'] = req.uri[len(options['SCRIPT_NAME']):]
+        else:
+            env['SCRIPT_NAME'] = ''
+            env['PATH_INFO'] = req.uri
+        
+        env['wsgi.input'] = InputWrapper(req)
+        env['wsgi.errors'] = ErrorWrapper(req)
+        env['wsgi.version'] = (1,0)
+        env['wsgi.run_once'] = False
+        if env.get("HTTPS") in ('yes', 'on', '1'):
+            env['wsgi.url_scheme'] = 'https'
+        else:
+            env['wsgi.url_scheme'] = 'http'
+        env['wsgi.multithread']  = threaded
+        env['wsgi.multiprocess'] = forked
+        
+        self.request = req
+    
+    def run(self, application):
+        try:
+            result = application(self.environ, self.start_response)
+            for data in result:
+                self.write(data)
+            if not self.started:
+                self.request.set_content_length(0)
+            if hasattr(result, 'close'):
+                result.close()
+        except:
+            traceback.print_exc(None, self.environ['wsgi.errors'])
+            if not self.started:
+                self.request.status = 500
+                self.request.content_type = 'text/plain'
+                data = "A server error occurred. Please contact the administrator."
+                self.request.set_content_length(len(data))
+                self.request.write(data)
+    
+    def start_response(self, status, headers, exc_info=None):
+        if exc_info:
+            try:
+                if self.started:
+                    raise exc_info[0], exc_info[1], exc_info[2]
+            finally:
+                exc_info = None
+        
+        self.request.status = int(status[:3])
+        
+        for key, val in headers:
+            if key.lower() == 'content-length':
+                self.request.set_content_length(int(val))
+            elif key.lower() == 'content-type':
+                self.request.content_type = val
+            else:
+                self.request.headers_out.add(key, val)
+        
+        return self.write
+    
+    def write(self, data):
+        if not self.started:
+            self.started = True
+        self.request.write(data)
+
+
+startup = None
+cleanup = None
+wsgiapps = {}
+
+def handler(req):
+    options = req.get_options()
+    # Run a startup function if requested.
+    global startup
+    if 'wsgi.startup' in options and not startup:
+        func = options['wsgi.startup']
+        if func:
+            module_name, object_str = func.split('::', 1)
+            module = __import__(module_name, globals(), locals(), [''])
+            startup = apache.resolve_object(module, object_str)
+            startup(req)
+    
+    # Register a cleanup function if requested.
+    global cleanup
+    if 'wsgi.cleanup' in options and not cleanup:
+        func = options['wsgi.cleanup']
+        if func:
+            module_name, object_str = func.split('::', 1)
+            module = __import__(module_name, globals(), locals(), [''])
+            cleanup = apache.resolve_object(module, object_str)
+            def cleaner(data):
+                cleanup()
+            try:
+                # apache.register_cleanup wasn't available until 3.1.4.
+                apache.register_cleanup(cleaner)
+            except AttributeError:
+                req.server.register_cleanup(req, cleaner)
+    
+    # Import the wsgi 'application' callable and pass it to Handler.run
+    global wsgiapps
+    appini = options.get('paste.ini')
+    app = None
+    if appini:
+        if appini not in wsgiapps:
+            wsgiapps[appini] = loadapp("config:%s" % appini)
+        app = wsgiapps[appini]
+    
+    # Import the wsgi 'application' callable and pass it to Handler.run
+    appwsgi = options.get('wsgi.application')
+    if appwsgi and not appini:
+        modname, objname = appwsgi.split('::', 1)
+        module = __import__(modname, globals(), locals(), [''])
+        app = getattr(module, objname)
+    
+    Handler(req).run(app)
+    
+    # status was set in Handler; always return apache.OK
+    return apache.OK