Multi-tier Implementation in Django

$ cat multitier/middleware.py

from threading import local
from django.contrib.sites.models import get_current_site

_thread_locals = local()

class OrganizationMiddleware(object):

    def process_request(self, request):
        _thread_locals.site = get_current_site(request)
        return None

$ cat multitier/template_loader.py

from django.conf import settings
from django.template.loaders.filesystem import Loader as FilesystemLoader
from django.utils._os import safe_join

from .middleware import _thread_locals

class Loader(FilesystemLoader):

    def get_template_sources(self, template_name, template_dirs=None):
        try:
            if not template_dirs:
                template_dirs = settings.TEMPLATE_DIRS
            for theme in [_thread_locals.site.domain]:
                for template_dir in template_dirs:
                    try:
                        template_path = safe_join(
                            template_dir, theme, template_name)
                        yield template_path
                    except UnicodeDecodeError:
                        # The template dir name was a bytestring that wasn't
                        # valid UTF-8.
                        raise
                    except ValueError:
                        # The joined path was located outside
                        # of this particular template_dir (it might be
                        # inside another one, so this isn't fatal).
                        pass

        except AttributeError, attr_err:
            # Something bad appended. We don't even have a request.
            # The middleware might be misconfigured.
            raise RuntimeError(
                "%s, your middleware might be misconfigured.", attr_err)

$ diff -u prev settings.py
 TEMPLATE_LOADERS = (
+   'multitier.template_loader.Loader',
...
 MIDDLEWARE_CLASSES += (
+    'multitier.middleware.OrganizationMiddleware',
...

$ cat django/db/utils.py
...
DEFAULT_DB_ALIAS = 'default'
...
class ConnectionHandler(object):
    def __init__(self, databases=None):

    def __getitem__(self, alias):
        if hasattr(self._connections, alias):
            return getattr(self._connections, alias)   # <-- Look cache HERE
...

$ cat django/db/__init__.py:
...
connections = ConnectionHandler()
...

$ cat django/db/models/query.py:
...
connection = connections[self.db]
...

...
def set_script_prefix(prefix):
    """
    Sets the script prefix for the current thread.
    """
    if not prefix.endswith('/'):
        prefix += '/'
    _prefixes.value = prefix
...

$ cat multitier/urlresolvers.py

import re

from django.core.urlresolvers import RegexURLResolver
from django.conf.urls import patterns
from django.conf import settings
from django.utils.translation.trans_real import DjangoTranslation

from .middleware import _thread_locals

class OrganizationCode(DjangoTranslation):

    def __init__(self, *args, **kw):
        DjangoTranslation.__init__(self, *args, **kw)
        self._catalog = {}
        self.set_output_charset('utf-8')
        self.__language = 'en-us'

    def set_language(self, language):
        self.__language = language

    def language(self):
        return self.__language

    def to_language(self):
        site = _thread_locals.site
        if site:
            # site will be None when 'manage.py show_urls' is invoked.
            return site.domain
        return 'en-us'

class OrganizationRegexURLResolver(RegexURLResolver):
    """
    A URL resolver that always matches the active organization code
    as URL prefix.
    """
    def __init__(self, urlconf_name,
                 default_kwargs=None, app_name=None, namespace=None):
        super(OrganizationRegexURLResolver, self).__init__(
            None, urlconf_name, default_kwargs, app_name, namespace)

    @property
    def regex(self):
        site = _thread_locals.site
        if site:
            # site will be None when 'manage.py show_urls' is invoked.
            return re.compile('^%s/' % site.domain, re.UNICODE)
        return re.compile('^', re.UNICODE)

def site_patterns(prefix, *args):
    pattern_list = patterns(prefix, *args)
    return [OrganizationRegexURLResolver(pattern_list)]

$ cat multitier/middleware.py
...
from django.utils.translation.trans_real import _active
...
class OrganizationMiddleware(object):

    def process_request(self, request):
        _thread_locals.site = get_current_site(request)
        globalpath = os.path.join(os.path.dirname(
                upath(sys.modules[settings.__module__].__file__)), 'locale')
        _active.value = gettext_module.translation(
            'django', globalpath, class_=OrganizationCode)
        return None

$ cat multitier/urls.py
...
urlpatterns = patterns('',
        url(r'^admin/', include(admin.site.urls)),
)

urlpatterns += site_patterns('',
    url(r'^(?P\S+)?', PageView.as_view(), name='multitier_page'),
)