← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to serve-branches

  • Committer: Marius Kruger
  • Date: 2008-10-02 21:12:58 UTC
  • mto: This revision was merged to the branch mainline in revision 240.
  • Revision ID: amanic@gmail.com-20081002211258-n28j8aa8fmp3u5ck
Add installation instructions for loggerheadd to README.txt and changed ubuntu -> Ubuntu for consistancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
serve-branches
1
 
#
2
 
# Copyright (C) 2008, 2009 Canonical Ltd
3
 
#
 
1
#!/usr/bin/env python
4
2
# This program is free software; you can redistribute it and/or modify
5
3
# it under the terms of the GNU General Public License as published by
6
4
# the Free Software Foundation; either version 2 of the License, or
21
19
import os
22
20
import sys
23
21
 
24
 
from bzrlib.plugin import load_plugins
 
22
from optparse import OptionParser
25
23
 
26
24
from paste import httpserver
27
 
from paste.httpexceptions import HTTPExceptionHandler, HTTPInternalServerError
 
25
from paste.httpexceptions import HTTPExceptionHandler
28
26
from paste.translogger import TransLogger
29
27
 
30
28
from loggerhead import __version__
31
 
from loggerhead.apps.transport import (
32
 
    BranchesFromTransportRoot, UserBranchesFromTransportRoot)
33
 
from loggerhead.config import LoggerheadConfig
 
29
from loggerhead.apps.filesystem import (
 
30
    BranchesFromFileSystemRoot, UserBranchesFromFileSystemRoot)
34
31
from loggerhead.util import Reloader
35
32
from loggerhead.apps.error import ErrorHandlerApp
36
33
 
37
34
 
38
 
def get_config_and_path(args):
39
 
    config = LoggerheadConfig(args)
40
 
 
41
 
    if config.get_option('show_version'):
42
 
        print "loggerhead %s" % (__version__,)
 
35
def command_line_parser():
 
36
    parser = OptionParser("%prog [options] <path>")
 
37
    parser.set_defaults(
 
38
        user_dirs=False,
 
39
        show_version=False,
 
40
        log_folder=None,
 
41
        )
 
42
    parser.add_option("--user-dirs", action="store_true", dest="user_dirs",
 
43
                      help="Serve user directories as ~user.")
 
44
    parser.add_option("--trunk-dir", metavar="DIR",
 
45
                      help="The directory that contains the trunk branches.")
 
46
    parser.add_option("--port", dest="user_port",
 
47
                      help="Port Loggerhead should listen on (defaults to 8080).")
 
48
    parser.add_option("--host", dest="user_host",
 
49
                      help="Host Loggerhead should listen on.")
 
50
    parser.add_option("--prefix", dest="user_prefix",
 
51
                      help="Specify host prefix.")
 
52
    parser.add_option("--reload", action="store_true", dest="reload",
 
53
                      help="Restarts the application when changing python"
 
54
                           " files. Only used for development purposes.")
 
55
    parser.add_option('--log-folder', dest="log_folder",
 
56
                      type=str, help="The directory to place log files in.")
 
57
    parser.add_option("--version", action="store_true", dest="show_version",
 
58
                      help="Print the software version and exit")
 
59
    return parser
 
60
 
 
61
 
 
62
def main(args):
 
63
    parser = command_line_parser()
 
64
    (options, args) = parser.parse_args(sys.argv[1:])
 
65
 
 
66
    if options.show_version:
 
67
        print "loggerhead %s" % __version__
43
68
        sys.exit(0)
44
69
 
45
 
    if config.arg_count > 1:
46
 
        config.print_help()
47
 
        sys.exit(1)
48
 
    elif config.arg_count == 1:
49
 
        base = config.get_arg(0)
50
 
    else:
51
 
        base = '.'
52
 
 
53
 
    if not config.get_option('allow_writes'):
54
 
        base = 'readonly+' + base
55
 
 
56
 
    return config, base
57
 
 
58
 
 
59
 
def setup_logging(config, init_logging=True, log_file=None):
60
 
    log_level = config.get_log_level()
61
 
    if init_logging:
62
 
        logging.basicConfig()
63
 
        if log_level is not None:
64
 
            logging.getLogger('').setLevel(log_level)
65
 
    logger = logging.getLogger('loggerhead')
66
 
    if log_level is not None:
67
 
        logger.setLevel(log_level)
68
 
    if log_file is not None:
69
 
        handler = logging.StreamHandler(log_file)
70
 
    else:
71
 
        if config.get_option('log_folder'):
72
 
            logfile_path = os.path.join(
73
 
                config.get_option('log_folder'), 'serve-branches.log')
74
 
        else:
75
 
            logfile_path = 'serve-branches.log'
76
 
        handler = logging.FileHandler(logfile_path, 'a')
77
 
        formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(name)s:'
78
 
                                      ' %(message)s')
79
 
        handler.setFormatter(formatter)
80
 
    # We set the handler to accept all messages, the *logger* won't emit them
81
 
    # if it is configured to suppress it
82
 
    handler.setLevel(logging.DEBUG)
83
 
    logger.addHandler(handler)
84
 
    def _restrict_logging(logger_name):
85
 
        logger = logging.getLogger(logger_name)
86
 
        if logger.getEffectiveLevel() < logging.INFO:
87
 
            logger.setLevel(logging.INFO)
88
 
    # simpleTAL is *very* verbose in DEBUG mode, which is otherwise the
89
 
    # default. So quiet it up a bit.
90
 
    _restrict_logging('simpleTAL')
91
 
    _restrict_logging('simpleTALES')
92
 
    return logger
93
 
 
94
 
 
95
 
def make_app_for_config_and_path(config, base):
96
 
    if config.get_option('trunk_dir') and not config.get_option('user_dirs'):
 
70
    if len(args) > 1:
 
71
        parser.print_help()
 
72
        sys.exit(1)
 
73
    elif len(args) == 1:
 
74
        [path] = args
 
75
    else:
 
76
        path = '.'
 
77
 
 
78
    if not os.path.isdir(path):
 
79
        print "%s is not a directory" % path
 
80
        sys.exit(1)
 
81
 
 
82
    if options.trunk_dir and not options.user_dirs:
97
83
        print "--trunk-dir is only valid with --user-dirs"
98
84
        sys.exit(1)
99
85
 
100
 
    if config.get_option('reload'):
 
86
    if options.reload:
101
87
        if Reloader.is_installed():
102
88
            Reloader.install()
103
89
        else:
104
90
            return Reloader.restart_with_reloader()
105
91
 
106
 
    if config.get_option('user_dirs'):
107
 
        if not config.get_option('trunk_dir'):
 
92
    if options.user_dirs:
 
93
        if not options.trunk_dir:
108
94
            print "You didn't specify a directory for the trunk directories."
109
95
            sys.exit(1)
110
 
        app = UserBranchesFromTransportRoot(base, config)
111
 
    else:
112
 
        app = BranchesFromTransportRoot(base, config)
113
 
 
114
 
    setup_logging(config)
115
 
 
116
 
    if config.get_option('profile'):
117
 
        from loggerhead.middleware.profile import LSProfMiddleware
118
 
        app = LSProfMiddleware(app)
119
 
    if config.get_option('memory_profile'):
120
 
        from dozer import Dozer
121
 
        app = Dozer(app)
122
 
 
123
 
    if not config.get_option('user_prefix'):
 
96
        app = UserBranchesFromFileSystemRoot(path, options.trunk_dir)
 
97
    else:
 
98
        app = BranchesFromFileSystemRoot(path)
 
99
 
 
100
    # setup_logging()
 
101
    logging.basicConfig()
 
102
    logging.getLogger('').setLevel(logging.DEBUG)
 
103
    logger = getattr(app, 'log', logging.getLogger('loggerhead'))
 
104
    if options.log_folder:
 
105
        logfile_path = os.path.join(options.log_folder, 'serve-branches.log')
 
106
    else:
 
107
        logfile_path = 'serve-branches.log'
 
108
    logfile = logging.FileHandler(logfile_path, 'a')
 
109
    formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(name)s:'
 
110
                                  ' %(message)s')
 
111
    logfile.setFormatter(formatter)
 
112
    logfile.setLevel(logging.DEBUG)
 
113
    logger.addHandler(logfile)
 
114
    # setup_logging() #end
 
115
    app = ErrorHandlerApp(app)
 
116
    app = HTTPExceptionHandler(app)
 
117
    app = TransLogger(app, logger=logger)
 
118
 
 
119
    if not options.user_prefix:
124
120
        prefix = '/'
125
121
    else:
126
 
        prefix = config.get_option('user_prefix')
127
 
        if not prefix.startswith('/'):
128
 
            prefix = '/' + prefix
 
122
        prefix = options.user_prefix
129
123
 
130
124
    try:
131
125
        from paste.deploy.config import PrefixMiddleware
132
126
    except ImportError:
133
 
        cant_proxy_correctly_message = (
134
 
            'Unsupported configuration: PasteDeploy not available, but '
135
 
            'loggerhead appears to be behind a proxy.')
136
 
        def check_not_proxied(app):
137
 
            def wrapped(environ, start_response):
138
 
                if 'HTTP_X_FORWARDED_SERVER' in environ:
139
 
                    exc = HTTPInternalServerError()
140
 
                    exc.explanation = cant_proxy_correctly_message
141
 
                    raise exc
142
 
                return app(environ, start_response)
143
 
            return wrapped
144
 
        app = check_not_proxied(app)
 
127
        pass
145
128
    else:
146
129
        app = PrefixMiddleware(app, prefix=prefix)
147
130
 
148
 
    app = HTTPExceptionHandler(app)
149
 
    app = ErrorHandlerApp(app)
150
 
    app = TransLogger(app, logger=logging.getLogger('loggerhead'))
151
 
 
152
 
    return app
153
 
 
154
 
 
155
 
def main(args):
156
 
    load_plugins()
157
 
 
158
 
    config, path = get_config_and_path(args)
159
 
 
160
 
    app = make_app_for_config_and_path(config, path)
161
 
 
162
 
    if not config.get_option('user_port'):
 
131
    if not options.user_port:
163
132
        port = '8080'
164
133
    else:
165
 
        port = config.get_option('user_port')
 
134
        port = options.user_port
166
135
 
167
 
    if not config.get_option('user_host'):
 
136
    if not options.user_host:
168
137
        host = '0.0.0.0'
169
138
    else:
170
 
        host = config.get_option('user_host')
171
 
 
172
 
    if not config.get_option('protocol'):
173
 
        protocol = 'http'
174
 
    else:
175
 
        protocol = config.get_option('protocol')
176
 
 
177
 
    if protocol == 'http':
178
 
        httpserver.serve(app, host=host, port=port)
179
 
    else:
180
 
        if protocol == 'fcgi':
181
 
            from flup.server.fcgi import WSGIServer
182
 
        elif protocol == 'scgi':
183
 
            from flup.server.scgi import WSGIServer
184
 
        elif protocol == 'ajp':
185
 
            from flup.server.ajp import WSGIServer
186
 
        else:
187
 
            print 'Unknown protocol: %s.' % (protocol)
188
 
            sys.exit(1)
189
 
        WSGIServer(app, bindAddress=(host, int(port))).run()
 
139
        host = options.user_host
 
140
 
 
141
    httpserver.serve(app, host=host, port=port)
 
142
 
 
143
 
 
144
if __name__ == "__main__":
 
145
    main(sys.argv)