from mod_python import apache # 404 should do NOTHING so apache can handle it. This view is referenced # in sflc.urls def view404(request): from django.http import HttpResponseNotFound return HttpResponseNotFound("") def outputfilter(filter): # set appropriate cache timeout filter.req.headers_out["Cache-Control"] = "max-age=600" # read raw template raw = [] s = filter.read() while s: raw.append(s) s = filter.read() raw = "".join(raw) # render it from django.template import Context, Template t = Template(raw.decode('utf-8')) del raw cooked = t.render(Context()) del t # send it off! filter.write(cooked.encode('utf-8')) if s is None: filter.close() from django.core.handlers.modpython import * # This is unreferenced from this file, but it must be imported to # enable template inheritance in the outputfilter! import django.template.loader # And now we override a few things in the module # django.core.handlers.modpython del handler class ModPythonRequest(ModPythonRequest): def is_secure(self): return 'HTTPS' in self._req.get_options() and self._req.get_options()['HTTPS'] == 'on' class ModPythonHandler(BaseHandler): request_class = ModPythonRequest def __call__(self, req): # mod_python fakes the environ, and thus doesn't process SetEnv. This fixes that # (SFLC instance doesn't call this) #os.environ.update(req.subprocess_env) # now that the environ works we can see the correct settings, so imports # requesthat use settings now can work from django.conf import settings # if we need to set up middleware, now that settings works we can do it now. if self._request_middleware is None: self.load_middleware() set_script_prefix(req.get_options().get('django.root', '')) signals.request_started.send(sender=self.__class__) try: try: request = self.request_class(req) except UnicodeDecodeError: response = http.HttpResponseBadRequest() else: response = self.get_response(request) # Apply response middleware for middleware_method in self._response_middleware: response = middleware_method(request, response) response = self.apply_response_fixes(request, response) finally: signals.request_finished.send(sender=self.__class__) # SFLC: decline so apache can serve a static file if response.status_code == 404: return apache.DECLINED # Convert our custom HttpResponse object back into the mod_python req. req.content_type = response['Content-Type'] for key, value in list(response.items()): if key != 'content-type': req.headers_out[str(key)] = str(value) for c in list(response.cookies.values()): req.headers_out.add('Set-Cookie', c.output(header='')) req.status = response.status_code try: for chunk in response: req.write(chunk) finally: response.close() return apache.DONE # skip all remaining phases (sf[l]c customization) def postreadrequesthandler(req): # mod_python hooks into this function. return ModPythonHandler()(req)