Merge lp:~mwhudson/launchpad/no-hosted-area-include-launchpad-loggerhead into lp:launchpad

[Michael Hudson-Doyle]

Hi Tim,

This branch replaces https://code.edge.launchpad.net/~mwhudson/launchpad/no-hosted-area-join-launchpad-loggerhead/+merge/24105 and just adds the files from the launchpad-loggerhead branch without trying to do anything fancy.

Cheers,
mwh

[Tim Penhey (thumper)]

review: Approve

=== modified file 'Makefile'
--- Makefile	2010-04-27 03:45:51 +0000
+++ Makefile	2010-04-27 03:46:17 +0000
@@ -229,13 +229,13 @@
 	    -i $(LPCONFIG)
 
 run_codebrowse: build
-	BZR_PLUGIN_PATH=bzrplugins $(PY) sourcecode/launchpad-loggerhead/start-loggerhead.py -f
+	BZR_PLUGIN_PATH=bzrplugins $(PY) scripts/start-loggerhead.py -f
 
 start_codebrowse: build
-	BZR_PLUGIN_PATH=$(shell pwd)/bzrplugins $(PY) sourcecode/launchpad-loggerhead/start-loggerhead.py
+	BZR_PLUGIN_PATH=$(shell pwd)/bzrplugins $(PY) scripts/start-loggerhead.py
 
 stop_codebrowse:
-	$(PY) sourcecode/launchpad-loggerhead/stop-loggerhead.py
+	$(PY) scripts/stop-loggerhead.py
 
 run_codehosting: check_schema inplace stop hosted_branches
 	$(RM) thread*.request
 
=== added directory 'lib/launchpad_loggerhead'
=== removed symlink 'lib/launchpad_loggerhead'
=== target was u'../sourcecode/launchpad-loggerhead/launchpad_loggerhead/'
=== added file 'lib/launchpad_loggerhead/__init__.py'
--- lib/launchpad_loggerhead/__init__.py	1970-01-01 00:00:00 +0000
+++ lib/launchpad_loggerhead/__init__.py	2010-04-27 03:46:17 +0000
@@ -0,0 +1,1 @@
+
 
=== added file 'lib/launchpad_loggerhead/app.py'
--- lib/launchpad_loggerhead/app.py	1970-01-01 00:00:00 +0000
+++ lib/launchpad_loggerhead/app.py	2010-04-27 03:46:17 +0000
@@ -0,0 +1,232 @@
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+import logging
+import re
+import os
+import threading
+import urllib
+import urlparse
+import xmlrpclib
+
+from bzrlib import branch, errors, lru_cache, urlutils
+
+from loggerhead.apps import favicon_app, static_app
+from loggerhead.apps.branch import BranchWSGIApp
+
+from openid.extensions.sreg import SRegRequest, SRegResponse
+from openid.consumer.consumer import CANCEL, Consumer, FAILURE, SUCCESS
+from openid.store.memstore import MemoryStore
+
+from paste.fileapp import DataApp
+from paste.request import construct_url, parse_querystring, path_info_pop
+from paste.httpexceptions import (
+    HTTPMovedPermanently, HTTPNotFound, HTTPUnauthorized)
+
+from canonical.config import config
+from canonical.launchpad.xmlrpc import faults
+from lp.code.interfaces.codehosting import (
+    BRANCH_TRANSPORT, LAUNCHPAD_ANONYMOUS, LAUNCHPAD_SERVICES)
+from lp.codehosting.vfs import branch_id_to_path
+
+robots_txt = '''\
+User-agent: *
+Disallow: /
+'''
+
+robots_app = DataApp(robots_txt, content_type='text/plain')
+
+
+thread_transports = threading.local()
+
+def valid_launchpad_name(s):
+    return re.match('^[a-z0-9][a-z0-9\+\.\-]*$', s) is not None
+
+
+def valid_launchpad_user_name(s):
+    return re.match('^~[a-z0-9][a-z0-9\+\.\-]*$', s) is not None
+
+
+def valid_launchpad_branch_name(s):
+    return re.match(r'^(?i)[a-z0-9][a-z0-9+\.\-@_]*\Z', s) is not None
+
+
+class RootApp:
+
+    def __init__(self, session_var):
+        self.graph_cache = lru_cache.LRUCache(10)
+        self.branchfs = xmlrpclib.ServerProxy(
+            config.codehosting.branchfs_endpoint)
+        self.session_var = session_var
+        self.store = MemoryStore()
+        self.log = logging.getLogger('lp-loggerhead')
+        branch.Branch.hooks.install_named_hook(
+            'transform_fallback_location',
+            self._transform_fallback_location_hook,
+            'RootApp._transform_fallback_location_hook')
+
+    def _transform_fallback_location_hook(self, branch, url):
+        """Transform a human-readable fallback URL into and id-based one.
+
+        Branches on Launchpad record their stacked-on URLs in the form
+        '/~user/product/branch', but we need to access branches based on
+        database ID to gain access to private branches.  So we use this hook
+        into Bazaar's branch-opening process to translate the former to the
+        latter.
+        """
+        # It might seem that using the LAUNCHPAD_SERVICES 'user', which allows
+        # access to all branches, here would be a security risk.  But in fact
+        # it isn't, because a user will only have launchpad.View on the
+        # stacked branch if they have it for all the stacked-on branches.
+        # (It would be nice to use the user from the request, but that's far
+        # from simple because branch hooks are global per-process and we
+        # handle different requests in different threads).
+        transport_type, info, trail = self.branchfs.translatePath(
+            LAUNCHPAD_SERVICES, url)
+        return urlparse.urljoin(
+            config.codehosting.internal_branch_by_id_root,
+            branch_id_to_path(info['id']))
+
+    def get_transports(self):
+        t = getattr(thread_transports, 'transports', None)
+        if t is None:
+            thread_transports.transports = []
+        return thread_transports.transports
+
+    def _make_consumer(self, environ):
+        """Build an OpenID `Consumer` object with standard arguments."""
+        return Consumer(environ[self.session_var], self.store)
+
+    def _begin_login(self, environ, start_response):
+        """Start the process of authenticating with OpenID.
+
+        We redirect the user to Launchpad to identify themselves, asking to be
+        sent their nickname.  Launchpad will then redirect them to our +login
+        page with enough information that we can then redirect them again to
+        the page they were looking at, with a cookie that gives us the
+        username.
+        """
+        openid_request = self._make_consumer(environ).begin(
+            'https://' + config.vhost.openid.hostname)
+        openid_request.addExtension(
+            SRegRequest(required=['nickname']))
+        back_to = construct_url(environ)
+        raise HTTPMovedPermanently(openid_request.redirectURL(
+            config.codehosting.secure_codebrowse_root,
+            config.codehosting.secure_codebrowse_root + '+login/?'
+            + urllib.urlencode({'back_to':back_to})))
+
+    def _complete_login(self, environ, start_response):
+        """Complete the OpenID authentication process.
+
+        Here we handle the result of the OpenID process.  If the process
+        succeeded, we record the username in the session and redirect the user
+        to the page they were trying to view that triggered the login attempt.
+        In the various failures cases we return a 401 Unauthorized response
+        with a brief explanation of what went wrong.
+        """
+        query = dict(parse_querystring(environ))
+        # Passing query['openid.return_to'] here is massive cheating, but
+        # given we control the endpoint who cares.
+        response = self._make_consumer(environ).complete(
+            query, query['openid.return_to'])
+        if response.status == SUCCESS:
+            self.log.error('open id response: SUCCESS')
+            sreg_info = SRegResponse.fromSuccessResponse(response)
+            environ[self.session_var]['user'] = sreg_info['nickname']
+            raise HTTPMovedPermanently(query['back_to'])
+        elif response.status == FAILURE:
+            self.log.error('open id response: FAILURE: %s', response.message)
+            exc = HTTPUnauthorized()
+            exc.explanation = response.message
+            raise exc
+        elif response.status == CANCEL:
+            self.log.error('open id response: CANCEL')
+            exc = HTTPUnauthorized()
+            exc.explanation = "Authetication cancelled."
+            raise exc
+        else:
+            self.log.error('open id response: UNKNOWN')
+            exc = HTTPUnauthorized()
+            exc.explanation = "Unknown OpenID response."
+            raise exc
+
+    def __call__(self, environ, start_response):
+        environ['loggerhead.static.url'] = environ['SCRIPT_NAME']
+        if environ['PATH_INFO'].startswith('/static/'):
+            path_info_pop(environ)
+            return static_app(environ, start_response)
+        elif environ['PATH_INFO'] == '/favicon.ico':
+            return favicon_app(environ, start_response)
+        elif environ['PATH_INFO'] == '/robots.txt':
+            return robots_app(environ, start_response)
+        elif environ['PATH_INFO'].startswith('/+login'):
+            return self._complete_login(environ, start_response)
+        path = environ['PATH_INFO']
+        trailingSlashCount = len(path) - len(path.rstrip('/'))
+        user = environ[self.session_var].get('user', LAUNCHPAD_ANONYMOUS)
+        try:
+            transport_type, info, trail = self.branchfs.translatePath(
+                user, urlutils.escape(path))
+        except xmlrpclib.Fault, f:
+            if faults.check_fault(f, faults.PathTranslationError):
+                raise HTTPNotFound()
+            elif faults.check_fault(f, faults.PermissionDenied):
+                # If we're not allowed to see the branch...
+                if environ['wsgi.url_scheme'] != 'https':
+                    # ... the request shouldn't have come in over http, as
+                    # requests for private branches over http should be
+                    # redirected to https by the dynamic rewrite script we use
+                    # (which runs before this code is reached), but just in
+                    # case...
+                    env_copy = environ.copy()
+                    env_copy['wsgi.url_scheme'] = 'https'
+                    raise HTTPMovedPermanently(construct_url(env_copy))
+                elif user != LAUNCHPAD_ANONYMOUS:
+                    # ... if the user is already logged in and still can't see
+                    # the branch, they lose.
+                    exc = HTTPUnauthorized()
+                    exc.explanation = "You are logged in as %s." % user
+                    raise exc
+                else:
+                    # ... otherwise, lets give them a chance to log in with
+                    # OpenID.
+                    return self._begin_login(environ, start_response)
+            else:
+                raise
+        if transport_type != BRANCH_TRANSPORT:
+            raise HTTPNotFound()
+        trail = urlutils.unescape(trail).encode('utf-8')
+        trail += trailingSlashCount * '/'
+        amount_consumed = len(path) - len(trail)
+        consumed = path[:amount_consumed]
+        branch_name = consumed.strip('/')
+        self.log.info('Using branch: %s', branch_name)
+        if trail and not trail.startswith('/'):
+            trail = '/' + trail
+        environ['PATH_INFO'] = trail
+        environ['SCRIPT_NAME'] += consumed.rstrip('/')
+        branch_url = urlparse.urljoin(
+            config.codehosting.internal_branch_by_id_root,
+            branch_id_to_path(info['id']))
+        branch_link = urlparse.urljoin(
+            config.codebrowse.launchpad_root, branch_name)
+        cachepath = os.path.join(
+            config.codebrowse.cachepath, branch_name[1:])
+        if not os.path.isdir(cachepath):
+            os.makedirs(cachepath)
+        self.log.info('branch_url: %s', branch_url)
+        try:
+            bzr_branch = branch.Branch.open(
+                branch_url, possible_transports=self.get_transports())
+        except errors.NotBranchError, err:
+            self.log.warning('Not a branch: %s', err)
+            raise HTTPNotFound()
+        bzr_branch.lock_read()
+        try:
+            view = BranchWSGIApp(
+                bzr_branch, branch_name, {'cachepath': cachepath},
+                self.graph_cache, branch_link=branch_link, served_url=None)
+            return view.app(environ, start_response)
+        finally:
+            bzr_branch.unlock()
 
=== added file 'lib/launchpad_loggerhead/debug.py'
--- lib/launchpad_loggerhead/debug.py	1970-01-01 00:00:00 +0000
+++ lib/launchpad_loggerhead/debug.py	2010-04-27 03:46:17 +0000
@@ -0,0 +1,120 @@
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+import thread
+import time
+
+from paste.request import construct_url
+
+
+def tabulate(cells):
+    """Format a list of lists of strings in a table.
+
+    The 'cells' are centered.
+
+    >>> print ''.join(tabulate(
+    ...     [['title 1', 'title 2'],
+    ...      ['short', 'rather longer']]))
+     title 1     title 2
+      short   rather longer
+    """
+    widths = {}
+    for row in cells:
+        for col_index, cell in enumerate(row):
+            widths[col_index] = max(len(cell), widths.get(col_index, 0))
+    result = []
+    for row in cells:
+        result_row = ''
+        for col_index, cell in enumerate(row):
+            result_row += cell.center(widths[col_index] + 2)
+        result.append(result_row.rstrip() + '\n')
+    return result
+
+
+def threadpool_debug(app):
+    """Wrap `app` to provide debugging information about the threadpool state.
+
+    The returned application will serve debugging information about the state
+    of the threadpool at '/thread-debug' -- but only when accessed directly,
+    not when accessed through Apache.
+    """
+    def wrapped(environ, start_response):
+        if ('HTTP_X_FORWARDED_SERVER' in environ
+            or environ['PATH_INFO'] != '/thread-debug'):
+            environ['lp.timestarted'] = time.time()
+            return app(environ, start_response)
+        threadpool = environ['paste.httpserver.thread_pool']
+        start_response("200 Ok", [])
+        output = [("url", "time running", "time since last activity")]
+        now = time.time()
+        # Because we're accessing mutable structures without locks here,
+        # we're a bit cautious about things looking like we expect -- if a
+        # worker doesn't seem fully set up, we just ignore it.
+        for worker in threadpool.workers:
+            if not hasattr(worker, 'thread_id'):
+                continue
+            time_started, info = threadpool.worker_tracker.get(
+                worker.thread_id, (None, None))
+            if time_started is not None and info is not None:
+                real_time_started = info.get(
+                    'lp.timestarted', time_started)
+                output.append(
+                    map(str,
+                        (construct_url(info),
+                         now - real_time_started,
+                         now - time_started,)))
+        return tabulate(output)
+    return wrapped
+
+
+def change_kill_thread_criteria(application):
+    """Interfere with threadpool so that threads are killed for inactivity.
+
+    The usual rules with paste's threadpool is that a thread that takes longer
+    than 'hung_thread_limit' seconds to process a request is considered hung
+    and more than 'kill_thread_limit' seconds is killed.
+
+    Because loggerhead streams its output, how long the entire request takes
+    to process depends on things like how fast the users internet connection
+    is.  What we'd like to do is kill threads that don't _start_ to produce
+    output for 'kill_thread_limit' seconds.
+
+    What this class actually does is arrange things so that threads that
+    produce no output for 'kill_thread_limit' are killed, because that's the
+    rule Apache uses when interpreting ProxyTimeout.
+    """
+    def wrapped_application(environ, start_response):
+        threadpool = environ['paste.httpserver.thread_pool']
+        def reset_timer():
+            """Make this thread safe for another 'kill_thread_limit' seconds.
+
+            We do this by hacking the threadpool's record of when this thread
+            started to pretend that it started right now.  Hacky, but it's
+            enough to fool paste.httpserver.ThreadPool.kill_hung_threads and
+            that's what matters.
+            """
+            threadpool.worker_tracker[thread.get_ident()][0] = time.time()
+        def response_hook(status, response_headers, exc_info=None):
+            # We reset the timer when the HTTP headers are sent...
+            reset_timer()
+            writer = start_response(status, response_headers, exc_info)
+            def wrapped_writer(arg):
+                # ... and whenever more output has been generated.
+                reset_timer()
+                return writer(arg)
+            return wrapped_writer
+        result = application(environ, response_hook)
+        # WSGI allows the application to return an iterable, which could be a
+        # generator that does significant processing between successive items,
+        # so we should reset the timer between each item.
+        #
+        # This isn't really necessary as loggerhead doesn't return any
+        # non-trivial iterables to the WSGI server.  But it's probably better
+        # to cope with this case to avoid nasty suprises if loggerhead
+        # changes.
+        def reset_timer_between_items(iterable):
+            for item in iterable:
+                reset_timer()
+                yield item
+        return reset_timer_between_items(result)
+    return wrapped_application
 
=== added file 'lib/launchpad_loggerhead/session.py'
--- lib/launchpad_loggerhead/session.py	1970-01-01 00:00:00 +0000
+++ lib/launchpad_loggerhead/session.py	2010-04-27 03:46:17 +0000
@@ -0,0 +1,73 @@
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Simple paste-y session manager tuned for the needs of launchpad-loggerhead.
+"""
+
+import pickle
+
+from paste.auth.cookie import AuthCookieHandler, AuthCookieSigner
+
+
+class MyAuthCookieSigner(AuthCookieSigner):
+    """Fix a bug in AuthCookieSigner."""
+
+    def sign(self, content):
+        # XXX 2008-01-13 Michael Hudson: paste.auth.cookie generates bogus
+        # cookies when the value is long:
+        # http://trac.pythonpaste.org/pythonpaste/ticket/257.  This is fixed
+        # now, so when a new version is released and packaged we can remove
+        # this class.
+        r = AuthCookieSigner.sign(self, content)
+        return r.replace('\n', '')
+
+
+class SessionHandler(object):
+    """Middleware that provides a cookie-based session.
+
+    The session dict is stored, pickled (and HMACed), in a cookie, so don't
+    store very much in the session!
+    """
+
+    def __init__(self, application, session_var, secret=None):
+        """Initialize a SessionHandler instance.
+
+        :param application: This is the wrapped application which will have
+            access to the ``environ[session_var]`` dictionary managed by this
+            middleware.
+        :param session_var: The key under which to store the session
+            dictionary in the environment.
+        :param secret: A secret value used for signing the cookie.  If not
+            supplied, a new secret will be used for each instantiation of the
+            SessionHandler.
+        """
+        self.application = application
+        self.cookie_handler = AuthCookieHandler(
+            self._process, scanlist=[session_var],
+            signer=MyAuthCookieSigner(secret))
+        self.session_var = session_var
+
+    def __call__(self, environ, start_response):
+        # We need to put the request through the cookie handler first, so we
+        # can access the validated string in the environ in `_process` below.
+        return self.cookie_handler(environ, start_response)
+
+    def _process(self, environ, start_response):
+        """Process a request.
+
+        AuthCookieHandler takes care of getting the text value of the session
+        in and out of the cookie (and validating the text using HMAC) so we
+        just need to convert that string to and from a real dictionary using
+        pickle.
+        """
+        if self.session_var in environ:
+            session = pickle.loads(environ[self.session_var])
+        else:
+            session = {}
+        environ[self.session_var] = session
+        def response_hook(status, response_headers, exc_info=None):
+            session = environ.pop(self.session_var)
+            if session:
+                environ[self.session_var] = pickle.dumps(session)
+            return start_response(status, response_headers, exc_info)
+        return self.application(environ, response_hook)
 
=== added directory 'lib/launchpad_loggerhead/static'
=== added file 'lib/launchpad_loggerhead/static/robots.txt'
--- lib/launchpad_loggerhead/static/robots.txt	1970-01-01 00:00:00 +0000
+++ lib/launchpad_loggerhead/static/robots.txt	2010-04-27 03:46:17 +0000
@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /
 
=== added file 'scripts/start-loggerhead.py'
--- scripts/start-loggerhead.py	1970-01-01 00:00:00 +0000
+++ scripts/start-loggerhead.py	2010-04-27 03:46:17 +0000
@@ -0,0 +1,177 @@
+#!/usr/bin/python2.5 -S
+#
+# Copyright 2009, 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+import _pythonpath
+
+import logging
+import os
+import sys
+
+from paste import httpserver
+from paste.deploy.config import PrefixMiddleware
+from paste.httpexceptions import HTTPExceptionHandler
+from paste.request import construct_url
+from paste.translogger import TransLogger
+
+from canonical.config import config
+import lp.codehosting
+
+LISTEN_HOST = '0.0.0.0'
+LISTEN_PORT = 8080
+THREADPOOL_WORKERS = 10
+
+
+class NoLockingFileHandler(logging.FileHandler):
+    """A version of logging.FileHandler that doesn't do it's own locking.
+
+    We experienced occasional hangs in production where gdb-ery on the server
+    revealed that we sometimes end up with many threads blocking on the RLock
+    held by the logging file handler, and log reading finds that an exception
+    managed to kill a thread in an unsafe window for RLock's.
+
+    Luckily, there's no real reason for us to take a lock during logging as
+    each log message translates to one call to .write on a file object, which
+    translates to one fwrite call, and it seems that this does enough locking
+    itself for our purposes.
+
+    So this handler just doesn't lock in log message handling.
+    """
+
+    def acquire(self):
+        pass
+
+    def release(self):
+        pass
+
+
+def setup_logging(home, foreground):
+    # i hate that stupid logging config format, so just set up logging here.
+
+    log_folder = config.codebrowse.log_folder
+    if not log_folder:
+        log_folder = os.path.join(home, 'logs')
+    if not os.path.exists(log_folder):
+        os.mkdir(log_folder)
+
+    f = logging.Formatter(
+        '%(levelname)-.3s [%(asctime)s.%(msecs)03d] [%(thread)d] %(name)s: %(message)s',
+        '%Y%m%d-%H:%M:%S')
+    debug_log = NoLockingFileHandler(os.path.join(log_folder, 'debug.log'))
+    debug_log.setLevel(logging.DEBUG)
+    debug_log.setFormatter(f)
+    if foreground:
+        stdout_log = logging.StreamHandler(sys.stdout)
+        stdout_log.setLevel(logging.DEBUG)
+        stdout_log.setFormatter(f)
+    f = logging.Formatter('[%(asctime)s.%(msecs)03d] %(message)s',
+                          '%Y%m%d-%H:%M:%S')
+    access_log = NoLockingFileHandler(os.path.join(log_folder, 'access.log'))
+    access_log.setLevel(logging.INFO)
+    access_log.setFormatter(f)
+
+    logging.getLogger('').setLevel(logging.DEBUG)
+    logging.getLogger('').addHandler(debug_log)
+    logging.getLogger('wsgi').addHandler(access_log)
+
+    if foreground:
+        logging.getLogger('').addHandler(stdout_log)
+    else:
+        class S(object):
+            def write(self, str):
+                logging.getLogger().error(str.rstrip('\n'))
+            def flush(self):
+                pass
+        sys.stderr = S()
+
+
+
+foreground = False
+if len(sys.argv) > 1:
+    if sys.argv[1] == '-f':
+        foreground = True
+
+home = os.path.realpath(os.path.dirname(__file__))
+pidfile = os.path.join(home, 'loggerhead.pid')
+
+if not foreground:
+    sys.stderr.write('\n')
+    sys.stderr.write('Launching loggerhead into the background.\n')
+    sys.stderr.write('PID file: %s\n' % (pidfile,))
+    sys.stderr.write('\n')
+
+    from loggerhead.daemon import daemonize
+    daemonize(pidfile, home)
+
+setup_logging(home, foreground=foreground)
+
+log = logging.getLogger('loggerhead')
+log.info('Starting up...')
+
+log.info('Loading the bzr plugins...')
+from bzrlib.plugin import load_plugins
+load_plugins()
+
+import bzrlib.plugins
+if getattr(bzrlib.plugins, 'loom', None) is None:
+    log.error('Loom plugin loading failed.')
+
+from launchpad_loggerhead.debug import (
+    change_kill_thread_criteria, threadpool_debug)
+from launchpad_loggerhead.app import RootApp
+from launchpad_loggerhead.session import SessionHandler
+
+SESSION_VAR = 'lh.session'
+
+secret = open(os.path.join(config.root, config.codebrowse.secret_path)).read()
+
+app = RootApp(SESSION_VAR)
+app = HTTPExceptionHandler(app)
+app = SessionHandler(app, SESSION_VAR, secret)
+def log_on_request_start(app):
+    def wrapped(environ, start_response):
+        log = logging.getLogger('loggerhead')
+        log.info("Starting to process %s", construct_url(environ))
+        return app(environ, start_response)
+    return wrapped
+app = log_on_request_start(app)
+app = PrefixMiddleware(app)
+app = TransLogger(app)
+app = threadpool_debug(app)
+
+def set_scheme(app):
+    """Set wsgi.url_scheme in the environment correctly.
+
+    We serve requests that originated from both http and https, and
+    distinguish between them by adding a header in the https Apache config.
+    """
+    def wrapped(environ, start_response):
+        environ['wsgi.url_scheme'] = environ.pop(
+            'HTTP_X_FORWARDED_SCHEME', 'http')
+        return app(environ, start_response)
+    return wrapped
+app = set_scheme(app)
+app = change_kill_thread_criteria(app)
+
+try:
+    httpserver.serve(
+        app, host=LISTEN_HOST, port=LISTEN_PORT,
+        threadpool_workers=THREADPOOL_WORKERS,
+        threadpool_options={
+            # Kill threads after 300 seconds.  This is insanely high, but
+            # lower enough than the default (1800 seconds!) that evidence
+            # suggests it will be hit occasionally, and there's very little
+            # chance of it having negative consequences.
+            'kill_thread_limit': 300,
+            # Check for threads that should be killed every 10 requests.  The
+            # default is every 100, which is easily long enough for things to
+            # gum up completely in between checks.
+            'hung_check_period': 10,
+            })
+finally:
+    log.info('Shutdown.')
+    try:
+        os.remove(pidfile)
+    except OSError:
+        pass
 
=== added file 'scripts/stop-loggerhead.py'
--- scripts/stop-loggerhead.py	1970-01-01 00:00:00 +0000
+++ scripts/stop-loggerhead.py	2010-04-27 03:46:17 +0000
@@ -0,0 +1,33 @@
+#!/usr/bin/python2.5 -S
+#
+# Copyright 2009, 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+import _pythonpath
+
+import os
+import sys
+
+home = os.path.realpath(os.path.dirname(__file__))
+pidfile = os.path.join(home, 'loggerhead.pid')
+
+try:
+    f = open(pidfile, 'r')
+except IOError, e:
+    print 'No pid file found.'
+    sys.exit(1)
+
+pid = int(f.readline())
+
+try:
+    os.kill(pid, 0)
+except OSError, e:
+    print 'Stale pid file; server is not running.'
+    sys.exit(1)
+
+print
+print 'Shutting down previous server @ pid %d.' % (pid,)
+print
+
+import signal
+os.kill(pid, signal.SIGTERM)
 
=== modified file 'utilities/sourcedeps.conf'
--- utilities/sourcedeps.conf	2010-04-21 12:30:48 +0000
+++ utilities/sourcedeps.conf	2010-04-27 03:46:17 +0000
@@ -5,7 +5,6 @@
 bzr-svn lp:~launchpad-pqm/bzr-svn/devel;revno=2708
 cscvs lp:~launchpad-pqm/launchpad-cscvs/devel;revno=432
 dulwich lp:~launchpad-pqm/dulwich/devel;revno=418
-launchpad-loggerhead lp:~launchpad-pqm/launchpad-loggerhead/devel;revno=54
 loggerhead lp:~launchpad-pqm/loggerhead/devel;revno=174
 lpreview lp:~launchpad-pqm/bzr-lpreview/devel;revno=23
 mailman lp:~launchpad-pqm/mailman/2.1;revno=976