← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to serve-branches

score one for the memory profiling we did at pycon: store the "where merged"
information in small tuples, not small sets.
this makes the 'whole history' cache for a launchpad branch take up about 15%
less RAM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
serve-branches
19
19
import os
20
20
import sys
21
21
 
22
 
from optparse import OptionParser
 
22
from bzrlib.plugin import load_plugins
23
23
 
24
24
from paste import httpserver
25
 
from paste.httpexceptions import HTTPExceptionHandler
 
25
from paste.httpexceptions import HTTPExceptionHandler, HTTPInternalServerError
26
26
from paste.translogger import TransLogger
27
27
 
28
28
from loggerhead import __version__
29
29
from loggerhead.apps.filesystem import (
30
30
    BranchesFromFileSystemRoot, UserBranchesFromFileSystemRoot)
 
31
from loggerhead.config import LoggerheadConfig
31
32
from loggerhead.util import Reloader
32
33
from loggerhead.apps.error import ErrorHandlerApp
33
34
 
34
35
 
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
36
def main(args):
63
 
    parser = command_line_parser()
64
 
    (options, args) = parser.parse_args(sys.argv[1:])
 
37
    config = LoggerheadConfig()
65
38
 
66
 
    if options.show_version:
 
39
    if config.get_option('show_version'):
67
40
        print "loggerhead %s" % __version__
68
41
        sys.exit(0)
69
42
 
70
 
    if len(args) > 1:
71
 
        parser.print_help()
 
43
    if config.arg_count > 1:
 
44
        config.print_help()
72
45
        sys.exit(1)
73
 
    elif len(args) == 1:
74
 
        [path] = args
 
46
    elif config.arg_count == 1:
 
47
        path = config.get_arg(0)
75
48
    else:
76
49
        path = '.'
77
50
 
79
52
        print "%s is not a directory" % path
80
53
        sys.exit(1)
81
54
 
82
 
    if options.trunk_dir and not options.user_dirs:
 
55
    if config.get_option('trunk_dir') and not config.get_option('user_dirs'):
83
56
        print "--trunk-dir is only valid with --user-dirs"
84
57
        sys.exit(1)
85
58
 
86
 
    if options.reload:
 
59
    if config.get_option('reload'):
87
60
        if Reloader.is_installed():
88
61
            Reloader.install()
89
62
        else:
90
63
            return Reloader.restart_with_reloader()
91
64
 
92
 
    if options.user_dirs:
93
 
        if not options.trunk_dir:
 
65
    if config.get_option('user_dirs'):
 
66
        if not config.get_option('trunk_dir'):
94
67
            print "You didn't specify a directory for the trunk directories."
95
68
            sys.exit(1)
96
 
        app = UserBranchesFromFileSystemRoot(path, options.trunk_dir)
 
69
        app = UserBranchesFromFileSystemRoot(path, config)
97
70
    else:
98
 
        app = BranchesFromFileSystemRoot(path)
 
71
        app = BranchesFromFileSystemRoot(path, config)
99
72
 
100
73
    # setup_logging()
101
74
    logging.basicConfig()
102
75
    logging.getLogger('').setLevel(logging.DEBUG)
103
76
    logger = getattr(app, 'log', logging.getLogger('loggerhead'))
104
 
    if options.log_folder:
105
 
        logfile_path = os.path.join(options.log_folder, 'serve-branches.log')
 
77
    if config.get_option('log_folder'):
 
78
        logfile_path = os.path.join(
 
79
            config.get_option('log_folder'), 'serve-branches.log')
106
80
    else:
107
81
        logfile_path = 'serve-branches.log'
108
82
    logfile = logging.FileHandler(logfile_path, 'a')
111
85
    logfile.setFormatter(formatter)
112
86
    logfile.setLevel(logging.DEBUG)
113
87
    logger.addHandler(logfile)
 
88
 
 
89
    if config.get_option('memory_profile'):
 
90
        memprofile = logging.getLogger('loggerhead-memprofile')
 
91
        memprofile.setLevel(logging.DEBUG)
 
92
        memprofile.addHandler(logging.FileHandler('loggerhead-memprofile'))
 
93
 
114
94
    # setup_logging() #end
115
 
    app = ErrorHandlerApp(app)
116
 
    app = HTTPExceptionHandler(app)
 
95
 
117
96
    app = TransLogger(app, logger=logger)
 
97
    if config.get_option('profile'):
 
98
        from loggerhead.middleware.profile import LSProfMiddleware
 
99
        app = LSProfMiddleware(app)
 
100
    if config.get_option('memory_profile'):
 
101
        from loggerhead.middleware.profile import MemoryProfileMiddleware
 
102
        app = MemoryProfileMiddleware(app)
118
103
 
119
 
    if not options.user_prefix:
 
104
    if not config.get_option('user_prefix'):
120
105
        prefix = '/'
121
106
    else:
122
 
        prefix = options.user_prefix
 
107
        prefix = config.get_option('user_prefix')
 
108
        if not prefix.startswith('/'):
 
109
            prefix = '/' + prefix
123
110
 
124
111
    try:
125
112
        from paste.deploy.config import PrefixMiddleware
126
113
    except ImportError:
127
 
        pass
 
114
        cant_proxy_correctly_message = (
 
115
            'Unsupported configuration: PasteDeploy not available, but '
 
116
            'loggerhead appears to be behind a proxy.')
 
117
        def check_not_proxied(app):
 
118
            def wrapped(environ, start_response):
 
119
                if 'HTTP_X_FORWARDED_SERVER' in environ:
 
120
                    exc = HTTPInternalServerError()
 
121
                    exc.explanation = cant_proxy_correctly_message
 
122
                    raise exc
 
123
                return app(environ, start_response)
 
124
            return wrapped
 
125
        app = check_not_proxied(app)
128
126
    else:
129
127
        app = PrefixMiddleware(app, prefix=prefix)
130
128
 
131
 
    if not options.user_port:
 
129
    app = HTTPExceptionHandler(app)
 
130
    app = ErrorHandlerApp(app)
 
131
 
 
132
    if not config.get_option('user_port'):
132
133
        port = '8080'
133
134
    else:
134
 
        port = options.user_port
 
135
        port = config.get_option('user_port')
135
136
 
136
 
    if not options.user_host:
 
137
    if not config.get_option('user_host'):
137
138
        host = '0.0.0.0'
138
139
    else:
139
 
        host = options.user_host
 
140
        host = config.get_option('user_host')
 
141
 
 
142
    load_plugins()
140
143
 
141
144
    httpserver.serve(app, host=host, port=port)
142
145