~loggerhead-team/loggerhead/trunk-rich

#!/usr/bin/env python

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""A script for starting the loggerhead process."""

import logging

import logging.handlers

from optparse import OptionParser

import os

import sys

import urlparse

from bzrlib.plugin import load_plugins

from bzrlib.util.configobj.configobj import ConfigObj

from paste import httpserver

from paste.httpexceptions import make_middleware

from paste.translogger import make_filter

from loggerhead import daemon

from loggerhead.apps.config import Root

from loggerhead.trace import make_handler, setup_logging

from loggerhead.apps.error import ErrorHandlerApp

def main():

    home = os.path.realpath(os.path.dirname(__file__))

    default_pidfile = os.path.join(home, 'loggerhead.pid')

    default_configfile = os.path.join(home, 'loggerhead.conf')

    default_log_folder = os.path.join(home, 'logs')

    parser = OptionParser(usage='usage: %prog [options]', version='%prog')

    parser.add_option('-f', '--foreground',

                      action='store_true', dest='foreground', default=False,

                      help="run in the foreground; don't daemonize")

    parser.add_option('-C', '--check', action='store_true',

                      dest='check', default=False,

                      help=("only start if not already running (useful for "

                            "cron jobs)"))

    parser.add_option('-p', '--pidfile', dest="pidfile",

                      default=default_pidfile,

                      type=str, help="override pidfile location")

    parser.add_option('-c', '--config-file', dest="configfile",

                      default=default_configfile,

                      type=str, help="override configuration file location")

    parser.add_option('-L', '--log-folder', dest="log_folder",

                      default=default_log_folder,

                      type=str, help="override log file directory")

    options, args = parser.parse_args()

    if len(args) > 0:

        parser.error('No filename arguments are used, only options.')

    if options.check:

        if daemon.is_running(options.pidfile):

            sys.exit(0)

        sys.stderr.write('Did not find loggerhead running in %r;' % (

                         options.pidfile))

        sys.stderr.write(' restarting...\n')

    # read loggerhead config

    config = ConfigObj(options.configfile, encoding='utf-8')

    extra_path = config.get('bzrpath', None)

    if extra_path:

        sys.path.insert(0, extra_path)

    potential_overrides = [('server.socket_port', int),

                           ('server.webpath', str),

                           ('server.thread_pool', int),

                           ('server.socket_host', str)]

    server_port = int(config.get('server.socket_port', 8080))

    nworkers = int(config.get('server.thread_pool', 10))

    server_host = config.get('server.socket_host', '0.0.0.0')

    webpath = config.get('server.webpath', None)

    for key, keytype in potential_overrides:

        value = config.get(key, None)

        if value is not None:

            value = keytype(value)

    if not options.foreground:

        sys.stderr.write('\n')

        sys.stderr.write('Launching loggerhead into the background.\n')

        sys.stderr.write('PID file: %s\n' % options.pidfile)

        sys.stderr.write('\n')

        daemon.daemonize(options.pidfile, home)

    setup_logging(options.log_folder, config, foreground=options.foreground)

    log = logging.getLogger('loggerhead')

    log.info('Starting up...')

    app = Root(config)

    app = app

    app = make_middleware(app)

    app = make_filter(app, None, logger_name=log.name+'.access')

    app = ErrorHandlerApp(app)

    if webpath:

        scheme, netloc, path, blah, blah, blah = urlparse.urlparse(webpath)

        def app(environ, start_response, orig=app):

            environ['SCRIPT_NAME'] = path

            environ['HTTP_HOST'] = netloc

            environ['wsgi.url_scheme'] = scheme

            return orig(environ, start_response)

    load_plugins()

    try:

        httpserver.serve(

            app, host=server_host, port=server_port,

            threadpool_workers=nworkers)

    finally:

        log.info('Shutdown.')

        try:

            os.remove(options.pidfile)

        except OSError:

            pass

if __name__ == '__main__':

    main()