def get_args():
parser = argparse.ArgumentParser(description='An HTTP proxy, with cache.')
parser.add_argument('--local', default='localhost:8080',
help='host/port of the local proxy')
parser.add_argument('--distant', default='localhost:8000',
help='host/port of the distant server')
parser.add_argument('--cache', default=None,
help='host:port of the memcache server, if any')
parser.add_argument('--cache-timeout', default=5 * 60, type=int,
help='Cache timeout, in seconds')
parser.add_argument('--statsd', default=None,
help='host:port of the statsd server, if any')
parser.add_argument('--statsd-namespace', default='httpcache',
help='namespace to use when sending statsd messages')
parser.add_argument('--excluded-paths', default=None,
help='a comma-separated list of paths to exclude')
parser.add_argument('--backend', type=str, default='fastgevent',
choices=backends(),
help='The http backend to use to serve the requests.')
log_levels = LOG_LEVELS.keys() + [key.upper() for key in LOG_LEVELS.keys()]
parser.add_argument('--log-level', dest='loglevel', default='info',
choices=log_levels, help="log level")
parser.add_argument('--log-output', dest='logoutput', default='-',
help="log output")
return parser.parse_args()
def get_args():
parser = argparse.ArgumentParser(description='An HTTP proxy, with cache.')
parser.add_argument('--local', default='localhost:8080',
help='host/port of the local proxy')
parser.add_argument('--distant', default='localhost:8000',
help='host/port of the distant server')
parser.add_argument('--cache', default=None,
help='host:port of the memcache server, if any')
parser.add_argument('--cache-timeout', default=5 * 60, type=int,
help='Cache timeout, in seconds')
parser.add_argument('--statsd', default=None,
help='host:port of the statsd server, if any')
parser.add_argument('--statsd-namespace', default='httpcache',
help='namespace to use when sending statsd messages')
parser.add_argument('--excluded-paths', default=None,
help='a comma-separated list of paths to exclude')
parser.add_argument('--backend', type=str, default='gevent',
choices=backends(),
help='The http backend to use to serve the requests.')
log_levels = LOG_LEVELS.keys() + [key.upper() for key in LOG_LEVELS.keys()]
parser.add_argument('--log-level', dest='loglevel', default='info',
choices=log_levels, help="log level")
parser.add_argument('--log-output', dest='logoutput', default='-',
help="log output")
return parser.parse_args()
def main():
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend', type=str, default='waitress',
choices=backends())
parser.add_argument('application', default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('--django-settings', type=str, default=None)
args = parser.parse_args()
application = args.application
if application.startswith('django:'):
app = django_app(application.split(':')[-1], args.django_settings)
else:
app = resolve_name(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
httpd = make_server(app, host=host, port=args.port, backend=args.backend,
backlog=args.backlog)
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
def main():
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend', type=str, default='wsgiref',
choices=backends())
parser.add_argument('application', default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('--pre-hook', type=str, default=None)
parser.add_argument('--post-hook', type=str, default=None)
parser.add_argument('--django-settings', type=str, default=None)
parser.add_argument('--python-path', type=str, default=None)
args = parser.parse_args()
application = args.application
if application.startswith('django:'):
app = django_app(application.split(':')[-1], args.django_settings,
args.python_path)
elif application.startswith('paste:'):
from chaussette._paste import paste_app
app = paste_app(application.split(':')[-1])
else:
app = resolve_name(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = resolve_name(args.pre_hook)
print('Running the pre-hook %r' % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = resolve_name(args.post_hook)
else:
post_hook = None
try:
httpd = make_server(app, host=host, port=args.port,
backend=args.backend, backlog=args.backlog)
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
print('Running the post-hook %r' % post_hook)
post_hook(args)
def test_backends(self):
_backends = backends()
if sys.version_info[0] == 2:
if IS_PYPY:
expected = PYPY
else:
expected = PY2
else:
expected = PY3
self.assertEqual(_backends, expected)
def test_backends(self):
_backends = backends()
if sys.version_info[0] == 2:
if IS_PYPY:
expected = PYPY
else:
expected = PY2
else:
expected = PY3
self.assertEqual(_backends, expected)
def main():
sys.path.append(os.curdir)
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend', type=str, default='wsgiref',
choices=backends())
parser.add_argument('application', default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('--pre-hook', type=str, default=None)
parser.add_argument('--post-hook', type=str, default=None)
parser.add_argument('--python-path', type=str, default=None)
args = parser.parse_args()
application = args.application
if application.startswith('paste:'):
from chaussette._paste import paste_app
app = paste_app(application.split(':')[-1])
else:
app = import_string(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = import_string(args.pre_hook)
print('Running the pre-hook %r' % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = import_string(args.post_hook)
else:
post_hook = None
try:
httpd = make_server(app, host=host, port=args.port,
backend=args.backend, backlog=args.backlog)
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
print('Running the post-hook %r' % post_hook)
post_hook(args)
def test_make_server(self):
"""
Test all backends with default params
:return:
"""
# nose does not have great support for parameterized tests
for backend in backends():
self.tt = minimock.TraceTracker()
self._check_make_server(backend)
minimock.restore()
def test_main(self):
for backend in backends():
resp = None
server = self._launch(backend)
try:
# socketio is not a WSGI Server.
# So we check only it can be started.
if backend == 'socketio':
continue
resp = requests.get('http://localhost:8080')
status = resp.status_code
self.assertEqual(status, 200, backend)
self.assertEqual(resp.text, u"hello world")
finally:
server.terminate()
if resp is not None:
resp.connection.close()
def test_main(self):
_backends = backends()
def _handler(*args):
try:
self.assertEqual(status, 200, '%s returned %d' %
(backend, status))
finally:
raise KeyboardInterrupt()
for backend in _backends:
server = self._launch(backend)
if backend in ('socketio', 'eventlet'):
continue
try:
resp = requests.get('http://localhost:8080')
status = resp.status_code
self.assertEqual(status, 200, backend)
finally:
resp.connection.close()
server.terminate()
def test_main(self):
_backends = backends()
def _handler(*args):
try:
self.assertEqual(status, 200,
'%s returned %d' % (backend, status))
finally:
raise KeyboardInterrupt()
for backend in _backends:
server = self._launch(backend)
if backend in ('socketio', 'eventlet'):
continue
try:
resp = requests.get('http://localhost:8080')
status = resp.status_code
self.assertEqual(status, 200, backend)
finally:
resp.connection.close()
server.terminate()
def main():
sys.path.append(os.curdir)
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
parser.add_argument('--address-family', type=str, default='AF_INET',
choices=_ADDRESS_FAMILY.keys())
parser.add_argument('--socket-type', type=str, default='SOCK_STREAM',
choices=_SOCKET_TYPE.keys())
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend', type=str, default='wsgiref',
choices=backends())
parser.add_argument('application', default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('--pre-hook', type=str, default=None)
parser.add_argument('--post-hook', type=str, default=None)
parser.add_argument('--python-path', type=str, default=None)
log_levels = LOG_LEVELS.keys() + [key.upper() for key in LOG_LEVELS.keys()]
parser.add_argument('--log-level', dest='loglevel', default='info',
choices=log_levels, help="log level")
parser.add_argument('--log-output', dest='logoutput', default='-',
help="log output")
args = parser.parse_args()
application = args.application
logger = chaussette_logger
configure_logger(logger, args.loglevel, args.logoutput)
if application.startswith('paste:'):
from chaussette._paste import paste_app
app = paste_app(application.split(':')[-1])
else:
app = import_string(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = import_string(args.pre_hook)
logger.info('Running the pre-hook %r' % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = import_string(args.post_hook)
else:
post_hook = None
address_family = _ADDRESS_FAMILY[args.address_family]
if address_family == socket.AF_UNIX and args.backend in _NO_UNIX:
logger.info('Sorry %r does not support unix sockets' % args.backend)
sys.exit(0)
try:
httpd = make_server(app, host=host, port=args.port,
backend=args.backend, backlog=args.backlog,
logger=logger,
address_family=address_family,
socket_type=_SOCKET_TYPE[args.socket_type])
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
logger.info('Running the post-hook %r' % post_hook)
post_hook(args)
def main():
sys.path.append(os.curdir)
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
parser.add_argument('--address-family',
type=str,
default='AF_INET',
choices=sorted(_ADDRESS_FAMILY.keys()))
parser.add_argument('--socket-type',
type=str,
default='SOCK_STREAM',
choices=sorted(_SOCKET_TYPE.keys()))
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend',
type=str,
default='wsgiref',
choices=backends())
parser.add_argument('--use-reloader',
action='store_true',
help="Restart server when source files change")
parser.add_argument('--spawn',
type=int,
default=None,
help="Spawn type, only makes sense if the backend "
"supports it (gevent)")
parser.add_argument('application',
default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('--pre-hook', type=str, default=None)
parser.add_argument('--post-hook', type=str, default=None)
parser.add_argument('--python-path', type=str, default=None)
log_levels = itertools.chain.from_iterable(
(key.upper(), key) for key in LOG_LEVELS.keys())
parser.add_argument('--log-level',
dest='loglevel',
default='info',
choices=sorted(log_levels),
help="log level")
parser.add_argument('--log-output',
dest='logoutput',
default='-',
help="log output")
args = parser.parse_args()
application = args.application
logger = chaussette_logger
configure_logger(logger, args.loglevel, args.logoutput)
if application.startswith('paste:'):
from chaussette._paste import paste_app
app = paste_app(application.split(':')[-1])
else:
app = import_string(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = import_string(args.pre_hook)
logger.info('Running the pre-hook %r' % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = import_string(args.post_hook)
else:
post_hook = None
address_family = _ADDRESS_FAMILY[args.address_family]
if address_family == socket.AF_UNIX and args.backend in _NO_UNIX:
logger.info('Sorry %r does not support unix sockets' % args.backend)
sys.exit(0)
def inner():
try:
httpd = make_server(app,
host=host,
port=args.port,
backend=args.backend,
backlog=args.backlog,
spawn=args.spawn,
logger=logger,
address_family=address_family,
socket_type=_SOCKET_TYPE[args.socket_type])
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
logger.info('Running the post-hook %r' % post_hook)
post_hook(args)
if args.use_reloader:
try:
from werkzeug.serving import run_with_reloader
except ImportError:
logger.info("Reloader requires Werkzeug: "
"'pip install werkzeug'")
sys.exit(0)
run_with_reloader(inner)
else:
inner()
def test_backends(self):
_backends = backends()
if sys.version_info[0] == 2:
self.assertEqual(_backends, PY2)
else:
self.assertEqual(_backends, PY3)
def main():
sys.path.append(os.curdir)
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
parser.add_argument('--address-family', type=str, default='AF_INET',
choices=sorted(_ADDRESS_FAMILY.keys()))
parser.add_argument('--socket-type', type=str, default='SOCK_STREAM',
choices=sorted(_SOCKET_TYPE.keys()))
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend', type=str, default='wsgiref',
choices=backends())
parser.add_argument('--use-reloader', action='store_true',
help="Restart server when source files change")
parser.add_argument('--no-monkey', action='store_true',
help="Disable monkey patching from backend")
parser.add_argument('--spawn', type=int, default=None,
help="Spawn type, only makes sense if the backend "
"supports it (gevent)")
parser.add_argument('--graceful-timeout', type=int, default=None,
help="Graceful shutdown timeout for existing requests "
"to complete, only for backends that support it "
"(%s)" % ', '.join(_SUPPORTS_GRACEFUL_TIMEOUT))
parser.add_argument('application', default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('arguments', default=[], nargs='*',
help="Optional arguments you may need for your app")
parser.add_argument('--pre-hook', type=str, default=None)
parser.add_argument('--post-hook', type=str, default=None)
parser.add_argument('--python-path', type=str, default=None)
log_levels = itertools.chain.from_iterable((key.upper(), key)
for key in LOG_LEVELS.keys())
parser.add_argument('--log-level', dest='loglevel', default='info',
choices=sorted(log_levels), help="log level")
parser.add_argument('--log-output', dest='logoutput', default='-',
help="log output")
args = parser.parse_args()
if args.python_path is not None:
for path in args.python_path.split(os.pathsep):
sys.path.append(path)
if is_gevent_backend(args.backend) and not args.no_monkey:
from gevent import monkey
monkey.noisy = False
monkey.patch_all()
application = args.application
logger = chaussette_logger
configure_logger(logger, args.loglevel, args.logoutput)
if args.graceful_timeout is not None and \
args.backend not in _SUPPORTS_GRACEFUL_TIMEOUT:
logger.info('Sorry %r does not support --graceful_timeout' %
args.backend)
sys.exit(0)
if application.startswith('paste:'):
from chaussette._paste import paste_app
app = paste_app(application.split(':')[-1])
else:
app = import_string(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = import_string(args.pre_hook)
logger.info('Running the pre-hook %r' % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = import_string(args.post_hook)
else:
post_hook = None
address_family = _ADDRESS_FAMILY[args.address_family]
if address_family == socket.AF_UNIX and args.backend in _NO_UNIX:
logger.info('Sorry %r does not support unix sockets' % args.backend)
sys.exit(0)
def inner():
try:
# Assumes that all arguments are kwargs - refactor for args as required
webserver_kwargs = {}
for argument in args.arguments:
key, value = argument.split('=')
webserver_kwargs[key] = value
httpd = make_server(app, host=host, port=args.port,
backend=args.backend, backlog=args.backlog,
spawn=args.spawn,
graceful_timeout=args.graceful_timeout,
logger=logger,
address_family=address_family,
socket_type=_SOCKET_TYPE[args.socket_type],
disable_monkeypatch=args.no_monkey,
webserver_kwargs=webserver_kwargs)
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
logger.info('Running the post-hook %r' % post_hook)
post_hook(args)
if args.use_reloader:
try:
from werkzeug.serving import run_with_reloader
except ImportError:
logger.info("Reloader requires Werkzeug: "
"'pip install werkzeug'")
sys.exit(0)
run_with_reloader(inner)
else:
inner()
def test_backends(self):
_backends = backends()
if sys.version_info[0] == 2:
self.assertEqual(_backends, PY2)
else:
self.assertEqual(_backends, PY3)
def main():
sys.path.append(os.curdir)
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
parser.add_argument('--address-family', type=str, default='AF_INET',
choices=sorted(_ADDRESS_FAMILY.keys()))
parser.add_argument('--socket-type', type=str, default='SOCK_STREAM',
choices=sorted(_SOCKET_TYPE.keys()))
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend', type=str, default='wsgiref',
choices=backends())
parser.add_argument('--use-reloader', action='store_true',
help="Restart server when source files change")
parser.add_argument('--spawn', type=int, default=None,
help="Spawn type, only makes sense if the backend "
"supports it (gevent)")
parser.add_argument('--graceful-timeout', type=int, default=None,
help="Graceful shutdown timeout for existing requests "
"to complete, only for backends that support it "
"(%s)" % ', '.join(_SUPPORTS_GRACEFUL_TIMEOUT))
parser.add_argument('application', default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('arguments', default=[], nargs='*',
help="Optional arguments you may need for your app")
parser.add_argument('--pre-hook', type=str, default=None)
parser.add_argument('--post-hook', type=str, default=None)
parser.add_argument('--python-path', type=str, default=None)
log_levels = itertools.chain.from_iterable((key.upper(), key)
for key in LOG_LEVELS.keys())
parser.add_argument('--log-level', dest='loglevel', default='info',
choices=sorted(log_levels), help="log level")
parser.add_argument('--log-output', dest='logoutput', default='-',
help="log output")
args = parser.parse_args()
if is_gevent_backend(args.backend):
from gevent import monkey
monkey.noisy = False
monkey.patch_all()
application = args.application
logger = chaussette_logger
configure_logger(logger, args.loglevel, args.logoutput)
if args.graceful_timeout is not None and \
args.backend not in _SUPPORTS_GRACEFUL_TIMEOUT:
logger.info('Sorry %r does not support --graceful_timeout' %
args.backend)
sys.exit(0)
if application.startswith('paste:'):
from chaussette._paste import paste_app
app = paste_app(application.split(':')[-1])
else:
app = import_string(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = import_string(args.pre_hook)
logger.info('Running the pre-hook %r' % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = import_string(args.post_hook)
else:
post_hook = None
address_family = _ADDRESS_FAMILY[args.address_family]
if address_family == socket.AF_UNIX and args.backend in _NO_UNIX:
logger.info('Sorry %r does not support unix sockets' % args.backend)
sys.exit(0)
def inner():
try:
httpd = make_server(app, host=host, port=args.port,
backend=args.backend, backlog=args.backlog,
spawn=args.spawn,
graceful_timeout=args.graceful_timeout,
logger=logger,
address_family=address_family,
socket_type=_SOCKET_TYPE[args.socket_type])
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
logger.info('Running the post-hook %r' % post_hook)
post_hook(args)
if args.use_reloader:
try:
from werkzeug.serving import run_with_reloader
except ImportError:
logger.info("Reloader requires Werkzeug: "
"'pip install werkzeug'")
sys.exit(0)
run_with_reloader(inner)
else:
inner()
def main():
sys.path.append(os.curdir)
parser = argparse.ArgumentParser(description="Run some watchers.")
parser.add_argument("--port", type=int, default=8080)
parser.add_argument("--address-family", type=str, default="AF_INET", choices=sorted(_ADDRESS_FAMILY.keys()))
parser.add_argument("--socket-type", type=str, default="SOCK_STREAM", choices=sorted(_SOCKET_TYPE.keys()))
group = parser.add_mutually_exclusive_group()
group.add_argument("--host", default="localhost")
group.add_argument("--fd", type=int, default=-1)
group.add_argument("--backlog", type=int, default=2048)
parser.add_argument("--backend", type=str, default="wsgiref", choices=backends())
parser.add_argument("application", default="chaussette.util.hello_app", nargs="?")
parser.add_argument("--pre-hook", type=str, default=None)
parser.add_argument("--post-hook", type=str, default=None)
parser.add_argument("--python-path", type=str, default=None)
log_levels = itertools.chain.from_iterable((key.upper(), key) for key in LOG_LEVELS.keys())
parser.add_argument("--log-level", dest="loglevel", default="info", choices=sorted(log_levels), help="log level")
parser.add_argument("--log-output", dest="logoutput", default="-", help="log output")
args = parser.parse_args()
application = args.application
logger = chaussette_logger
configure_logger(logger, args.loglevel, args.logoutput)
if application.startswith("paste:"):
from chaussette._paste import paste_app
app = paste_app(application.split(":")[-1])
else:
app = import_string(application)
if args.fd != -1:
host = "fd://%d" % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = import_string(args.pre_hook)
logger.info("Running the pre-hook %r" % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = import_string(args.post_hook)
else:
post_hook = None
address_family = _ADDRESS_FAMILY[args.address_family]
if address_family == socket.AF_UNIX and args.backend in _NO_UNIX:
logger.info("Sorry %r does not support unix sockets" % args.backend)
sys.exit(0)
try:
httpd = make_server(
app,
host=host,
port=args.port,
backend=args.backend,
backlog=args.backlog,
logger=logger,
address_family=address_family,
socket_type=_SOCKET_TYPE[args.socket_type],
)
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
logger.info("Running the post-hook %r" % post_hook)
post_hook(args)
def main():
sys.path.append(os.curdir)
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--port', type=int, default=8080)
group = parser.add_mutually_exclusive_group()
group.add_argument('--host', default='localhost')
group.add_argument('--fd', type=int, default=-1)
group.add_argument('--backlog', type=int, default=2048)
parser.add_argument('--backend', type=str, default='wsgiref',
choices=backends())
parser.add_argument('application', default='chaussette.util.hello_app',
nargs='?')
parser.add_argument('--pre-hook', type=str, default=None)
parser.add_argument('--post-hook', type=str, default=None)
parser.add_argument('--python-path', type=str, default=None)
log_levels = LOG_LEVELS.keys() + [key.upper() for key in LOG_LEVELS.keys()]
parser.add_argument('--log-level', dest='loglevel', default='info',
choices=log_levels, help="log level")
parser.add_argument('--log-output', dest='logoutput', default='-',
help="log output")
args = parser.parse_args()
application = args.application
logger = chaussette_logger
configure_logger(logger)
if application.startswith('paste:'):
from chaussette._paste import paste_app
app = paste_app(application.split(':')[-1])
else:
app = import_string(application)
if args.fd != -1:
host = 'fd://%d' % args.fd
else:
host = args.host
# pre-hook ?
if args.pre_hook is not None:
pre_hook = import_string(args.pre_hook)
logger.info('Running the pre-hook %r' % pre_hook)
pre_hook(args)
# post-hook ?
if args.post_hook is not None:
post_hook = import_string(args.post_hook)
else:
post_hook = None
try:
httpd = make_server(app, host=host, port=args.port,
backend=args.backend, backlog=args.backlog,
logger=logger)
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
finally:
if post_hook is not None:
logger.info('Running the post-hook %r' % post_hook)
post_hook(args)
