Files @ a8710b4b9f2a
Branch filter:

Location: website/www/

Denver Gingerich
Copyleft Compliance: mostly minor fixes to new pgs

These are mostly minor edits (typo fixes, etc.) to the enforcement
strategy and firmware liberation pages that were just added.

The one large change was to replace the first paragraph of the
enforcement strategy page with the full Conservancy description used
previously. The glue text used to shorten it appeared unsalvageable
and it wasn't immediately obvious how to replace it with something
better, so we used the full description instead.
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 =
    while s:
        s =
    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!
    if s is None:

# 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

from django.core.handlers.modpython import *
del handler

class ModPythonRequest(ModPythonRequest):
    def is_secure(self):
        return self._req.get_options().has_key('HTTPS') 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)

        # 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:

        set_script_prefix(req.get_options().get('django.root', '')) 
                request = self.request_class(req)
            except UnicodeDecodeError:
                response = http.HttpResponseBadRequest()
                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)

        # 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 response.items():
            if key != 'content-type':
                req.headers_out[str(key)] = str(value)
        for c in response.cookies.values():
            req.headers_out.add('Set-Cookie', c.output(header=''))
        req.status = response.status_code
            for chunk in response:

        return apache.DONE # skip all remaining phases (sf[l]c customization)

def postreadrequesthandler(req):
    # mod_python hooks into this function.
    return ModPythonHandler()(req)