← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to serve-branches

  • Committer: Michael Hudson
  • Date: 2009-02-19 01:24:20 UTC
  • mto: This revision was merged to the branch mainline in revision 271.
  • Revision ID: michael.hudson@canonical.com-20090219012420-c6s1j3etl2t4r7wa
defer loading of plugins until after we've set up the logging

Show diffs side-by-side

added added

removed removed

Lines of Context:
serve-branches
16
16
"""Search for branches underneath a directory and serve them all."""
17
17
 
18
18
import logging
 
19
import os
19
20
import sys
20
21
 
 
22
from optparse import OptionParser
 
23
 
 
24
from bzrlib.plugin import load_plugins
 
25
 
21
26
from paste import httpserver
22
 
from paste.httpexceptions import HTTPExceptionHandler
 
27
from paste.httpexceptions import HTTPExceptionHandler, HTTPInternalServerError
23
28
from paste.translogger import TransLogger
24
29
 
25
 
from loggerhead.apps.filesystem import BranchesFromFileSystemRoot
26
 
 
27
 
 
28
 
logging.basicConfig()
29
 
logging.getLogger().setLevel(logging.DEBUG)
30
 
 
31
 
if len(sys.argv) > 1:
32
 
    path = sys.argv[1]
33
 
else:
34
 
    path = '.'
35
 
 
36
 
app = BranchesFromFileSystemRoot(path)
37
 
 
38
 
app = HTTPExceptionHandler(app)
39
 
app = TransLogger(app)
40
 
 
41
 
try:
42
 
    from paste.deploy.config import PrefixMiddleware
43
 
except ImportError:
44
 
    pass
45
 
else:
46
 
    app = PrefixMiddleware(app)
47
 
 
48
 
#from paste.evalexception import EvalException
49
 
#app = EvalException(app)
50
 
 
51
 
httpserver.serve(app, host='0.0.0.0', port='8080')
 
30
from loggerhead import __version__
 
31
from loggerhead.apps.filesystem import (
 
32
    BranchesFromFileSystemRoot, UserBranchesFromFileSystemRoot)
 
33
from loggerhead.util import Reloader
 
34
from loggerhead.apps.error import ErrorHandlerApp
 
35
 
 
36
 
 
37
def command_line_parser():
 
38
    parser = OptionParser("%prog [options] <path>")
 
39
    parser.set_defaults(
 
40
        user_dirs=False,
 
41
        show_version=False,
 
42
        log_folder=None,
 
43
        )
 
44
    parser.add_option("--user-dirs", action="store_true", dest="user_dirs",
 
45
                      help="Serve user directories as ~user.")
 
46
    parser.add_option("--trunk-dir", metavar="DIR",
 
47
                      help="The directory that contains the trunk branches.")
 
48
    parser.add_option("--port", dest="user_port",
 
49
                      help=("Port Loggerhead should listen on "
 
50
                            "(defaults to 8080)."))
 
51
    parser.add_option("--host", dest="user_host",
 
52
                      help="Host Loggerhead should listen on.")
 
53
    parser.add_option("--prefix", dest="user_prefix",
 
54
                      help="Specify host prefix.")
 
55
    parser.add_option("--profile", action="store_true", dest="profile",
 
56
                      help="Generate callgrind profile data to "
 
57
                        "%d-stats.callgrind on each request.")
 
58
    parser.add_option("--reload", action="store_true", dest="reload",
 
59
                      help="Restarts the application when changing python"
 
60
                           " files. Only used for development purposes.")
 
61
    parser.add_option('--log-folder', dest="log_folder",
 
62
                      type=str, help="The directory to place log files in.")
 
63
    parser.add_option("--version", action="store_true", dest="show_version",
 
64
                      help="Print the software version and exit")
 
65
    return parser
 
66
 
 
67
 
 
68
def main(args):
 
69
    parser = command_line_parser()
 
70
    (options, args) = parser.parse_args(sys.argv[1:])
 
71
 
 
72
    if options.show_version:
 
73
        print "loggerhead %s" % __version__
 
74
        sys.exit(0)
 
75
 
 
76
    if len(args) > 1:
 
77
        parser.print_help()
 
78
        sys.exit(1)
 
79
    elif len(args) == 1:
 
80
        [path] = args
 
81
    else:
 
82
        path = '.'
 
83
 
 
84
    if not os.path.isdir(path):
 
85
        print "%s is not a directory" % path
 
86
        sys.exit(1)
 
87
 
 
88
    if options.trunk_dir and not options.user_dirs:
 
89
        print "--trunk-dir is only valid with --user-dirs"
 
90
        sys.exit(1)
 
91
 
 
92
    if options.reload:
 
93
        if Reloader.is_installed():
 
94
            Reloader.install()
 
95
        else:
 
96
            return Reloader.restart_with_reloader()
 
97
 
 
98
    if options.user_dirs:
 
99
        if not options.trunk_dir:
 
100
            print "You didn't specify a directory for the trunk directories."
 
101
            sys.exit(1)
 
102
        app = UserBranchesFromFileSystemRoot(path, options.trunk_dir)
 
103
    else:
 
104
        app = BranchesFromFileSystemRoot(path)
 
105
 
 
106
    # setup_logging()
 
107
    logging.basicConfig()
 
108
    logging.getLogger('').setLevel(logging.DEBUG)
 
109
    logger = getattr(app, 'log', logging.getLogger('loggerhead'))
 
110
    if options.log_folder:
 
111
        logfile_path = os.path.join(options.log_folder, 'serve-branches.log')
 
112
    else:
 
113
        logfile_path = 'serve-branches.log'
 
114
    logfile = logging.FileHandler(logfile_path, 'a')
 
115
    formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(name)s:'
 
116
                                  ' %(message)s')
 
117
    logfile.setFormatter(formatter)
 
118
    logfile.setLevel(logging.DEBUG)
 
119
    logger.addHandler(logfile)
 
120
    # setup_logging() #end
 
121
    app = TransLogger(app, logger=logger)
 
122
    if options.profile:
 
123
        from loggerhead.middleware.profile import LSProfMiddleware
 
124
        app = LSProfMiddleware(app)
 
125
 
 
126
    if not options.user_prefix:
 
127
        prefix = '/'
 
128
    else:
 
129
        prefix = options.user_prefix
 
130
 
 
131
    try:
 
132
        from paste.deploy.config import PrefixMiddleware
 
133
    except ImportError:
 
134
        cant_proxy_correctly_message = (
 
135
            'Unsupported configuration: PasteDeploy not available, but '
 
136
            'loggerhead appears to be behind a proxy.')
 
137
        def check_not_proxied(app):
 
138
            def wrapped(environ, start_response):
 
139
                if 'HTTP_X_FORWARDED_SERVER' in environ:
 
140
                    exc = HTTPInternalServerError()
 
141
                    exc.explanation = cant_proxy_correctly_message
 
142
                    raise exc
 
143
                return app(environ, start_response)
 
144
            return wrapped
 
145
        app = check_not_proxied(app)
 
146
    else:
 
147
        app = PrefixMiddleware(app, prefix=prefix)
 
148
 
 
149
    app = HTTPExceptionHandler(app)
 
150
    app = ErrorHandlerApp(app)
 
151
 
 
152
    if not options.user_port:
 
153
        port = '8080'
 
154
    else:
 
155
        port = options.user_port
 
156
 
 
157
    if not options.user_host:
 
158
        host = '0.0.0.0'
 
159
    else:
 
160
        host = options.user_host
 
161
 
 
162
    load_plugins()
 
163
 
 
164
    httpserver.serve(app, host=host, port=port)
 
165
 
 
166
 
 
167
if __name__ == "__main__":
 
168
    main(sys.argv)