← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to serve-branches

  • Committer: Paul Hummer
  • Date: 2009-03-30 22:39:07 UTC
  • mfrom: (314.1.9 memory-profiling)
  • Revision ID: paul@canonical.com-20090330223907-66ndm7vo0dg43if3
Added MemoryProfileMiddleware

Show diffs side-by-side

added added

removed removed

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