def make_middleware(app):
from repoze.profile.profiler import AccumulatingProfileMiddleware
return AccumulatingProfileMiddleware(app,
log_filename='/tmp/profile.log',
discard_first_request=True,
flush_at_shutdown=True,
path='/__profile__')
def make_app(global_conf, **app_conf):
"""Returns a Sync Server Application."""
global_conf.update(app_conf)
params = convert_config(global_conf)
app = klass(urls, controllers, params, auth_class)
if params.get('debug', False):
app = TransLogger(app, logger_name='syncserver',
setup_console_handler=True)
if params.get('profile', False):
from repoze.profile.profiler import AccumulatingProfileMiddleware
app = AccumulatingProfileMiddleware(app,
log_filename='profile.log',
cachegrind_filename='cachegrind.out',
discard_first_request=True,
flush_at_shutdown=True,
path='/__profile__')
if params.get('client_debug', False):
# errors are displayed in the user client
app = ErrorMiddleware(app, debug=True,
show_exceptions_in_wsgi_errors=True)
else:
# errors are logged and a 500 is returned with an empty body
# to avoid any security whole
app = CatchErrorMiddleware(app, logger_name='syncserver')
if wrapper is not None:
app = wrapper(app)
return app
def make_app(global_conf, full_stack=True, **app_conf):
from moksha.middleware import make_moksha_middleware
app = make_base_app(global_conf, wrap_app=make_moksha_middleware,
full_stack=True, **app_conf)
if base_config.squeeze:
from repoze.squeeze.processor import ResourceSqueezingMiddleware
app = ResourceSqueezingMiddleware(
app,
cache_dir='public/cache',
url_prefix='/cache/',
)
if base_config.profile:
from repoze.profile.profiler import AccumulatingProfileMiddleware
app = AccumulatingProfileMiddleware(
app,
log_filename='profile.log',
discard_first_request=True,
flush_at_shutdown=True,
path='/__profile__',
cachegrind_filename='moksha.cachegrind',
)
return app
def rocket_with_repoze_profiler(app, address, **options):
from rocket import HttpServer
from repoze.profile.profiler import AccumulatingProfileMiddleware
wrapped = AccumulatingProfileMiddleware(app,
log_filename='wsgi.prof',
discard_first_request=True,
flush_at_shutdown=True,
path='/__profile__')
server = HttpServer(wrapped, ip=address[0], port=address[1])
server.start()
def rocket_with_repoze_profiler(app, address, **options):
from gluon.rocket import CherryPyWSGIServer
from repoze.profile.profiler import AccumulatingProfileMiddleware
from gluon.settings import global_settings
global_settings.web2py_crontype = 'none'
wrapped = AccumulatingProfileMiddleware(app,
log_filename='wsgi.prof',
discard_first_request=True,
flush_at_shutdown=True,
path='/__profile__')
server = CherryPyWSGIServer(address, wrapped)
server.start()
def run_command(rule_filename, debug=False, interactive_debugger=False,
debug_headers=False, profile=False, memory_profile=False,
garbage_collect=False):
"""Actually runs the command from the parsed arguments"""
settings = ProxySettings.parse_file(rule_filename)
app = ReloadingApp(rule_filename, settings)
if profile:
try:
from repoze.profile.profiler import AccumulatingProfileMiddleware
except ImportError:
print('Error: you must manually install repoze.profiler to use --profile')
sys.exit(1)
app = AccumulatingProfileMiddleware(
app,
log_filename='/tmp/deliverance-proxy-profiling.log',
discard_first_request=True,
flush_at_shutdown=True,
path='/.deliverance/profile')
if memory_profile:
try:
from dozer import Dozer
except ImportError:
print('Error: you must manually install Dozer to use --memory-profile')
sys.exit(1)
app = Dozer(app)
if interactive_debugger:
from weberror.evalexception import EvalException
app = EvalException(app, debug=True)
else:
from weberror.errormiddleware import ErrorMiddleware
app = ErrorMiddleware(app, debug=debug)
if debug_headers:
from wsgifilter.proxyapp import DebugHeaders
app = DebugHeaders(app, show_body=debug_headers > 1)
if garbage_collect:
from deliverance.garbagecollect import GarbageCollectingMiddleware
app = GarbageCollectingMiddleware(app)
print('To see logging, visit %s/.deliverance/login' % settings.base_url)
print(' after login go to %s/?deliv_log' % settings.base_url)
if profile:
print('To see profiling information visit %s/.deliverance/profile' % settings.base_url)
serve(app, host=settings.host, port=settings.port)
def make_app(global_conf, full_stack=True, **app_conf):
from moksha.wsgi.middleware import make_moksha_middleware
from fedoracommunity.connectors.api.mw import FCommConnectorMiddleware
def make_middleware(app):
if tg_version_tuple < (2, 1):
app = base_config.add_tosca2_middleware(app)
app = FCommConnectorMiddleware(app)
app = make_moksha_middleware(app, tg.config)
return app
if tg_version_tuple >= (2, 1):
app_conf['custom_tw2_config'] = {
'script_name': global_conf.get('fedoracommunity.script_name', '/')
}
app = make_base_app(global_conf,
wrap_app=make_middleware,
full_stack=full_stack,
**app_conf)
if base_config.squeeze:
from repoze.squeeze.processor import ResourceSqueezingMiddleware
app = ResourceSqueezingMiddleware(
app,
cache_dir='public/cache',
url_prefix='/cache/',
)
if base_config.profile:
from repoze.profile.profiler import AccumulatingProfileMiddleware
app = AccumulatingProfileMiddleware(
app,
log_filename='profile.log',
discard_first_request=True,
cachegrind_filename='./cachegrind.out',
flush_at_shutdown=True,
path='/__profile__')
return app
def make_app(global_conf, **app_conf):
global app, log
logging.config.fileConfig(global_conf['__file__'])
log = logging.getLogger('solder')
import solder.logger
app = wrap = Solder(global_conf, **app_conf)
from beaker.middleware import SessionMiddleware
wrap = SessionMiddleware(wrap, app.config)
from beaker.middleware import CacheMiddleware
wrap = CacheMiddleware(wrap, app.config)
from routes.middleware import RoutesMiddleware
wrap = RoutesMiddleware(wrap, app)
if False and app.debug:
from repoze.profile.profiler import AccumulatingProfileMiddleware
wrap = AccumulatingProfileMiddleware(wrap,
log_filename='./logs/profile.log',
discard_first_request=True,
flush_at_shutdown=True,
path='/_profile_')
from weberror.evalexception import make_general_exception
wrap = make_general_exception(wrap, global_conf,
asbool(app.config['interactive']))
from paste.fileapp import DirectoryApp
public = DirectoryApp('./solder/public')
from paste.cascade import Cascade
wrap = Cascade([public, wrap], [403, 404])
return wrap
def _makeOne(self, *arg, **kw):
from repoze.profile.profiler import AccumulatingProfileMiddleware
return AccumulatingProfileMiddleware(*arg, **kw)
import sys
from wsgiref.simple_server import make_server
from repoze.profile.profiler import AccumulatingProfileMiddleware
import trac.web.main
if len(sys.argv) < 2:
logfile_name = 'profiling.log'
else:
logfile_name = sys.argv[1]
if len(sys.argv) < 3:
trac_env_dir = os.environ['TRAC_ENV']
else:
trac_env_dir = sys.argv[2]
assert os.path.isdir(
trac_env_dir
), 'Please point TRAC_ENV to the environment you want to profile'
os.environ['TRAC_ENV'] = trac_env_dir
app = trac.web.main.dispatch_request
middleware = AccumulatingProfileMiddleware(app,
log_filename=logfile_name,
discard_first_request=False,
flush_at_shutdown=False,
path='/profile')
httpd = make_server('', 8011, middleware)
print "Serving on port 8011..."
httpd.serve_forever()
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""
Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether this application provides a full WSGI stack (by default,
meaning it handles its own exceptions and errors). Disable
full_stack when this application is "managed" by another WSGI
middleware.
``static_files``
Whether this application serves its own static files; disable
when another web server is responsible for serving them.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
config = load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp()
# Profiling Middleware
if profile_load:
if asbool(config['profile']):
app = AccumulatingProfileMiddleware(
app,
log_filename='/var/log/linotp/profiling.log',
cachegrind_filename='/var/log/linotp/cachegrind.out',
discard_first_request=True,
flush_at_shutdown=True,
path='/__profile__')
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = SessionMiddleware(app, config)
app = CacheMiddleware(app, config)
# CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
if asbool(full_stack):
# Handle Python exceptions
app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# Display error documents for 401, 403, 404 status codes (and
# 500 when debug is disabled)
if asbool(config['debug']):
app = StatusCodeRedirect(app)
else:
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
# repoze.who
if repoze_load:
if 'who.generate_random_secret' in app_conf and not app_conf[
'who.generate_random_secret']:
app = make_who_with_config(app, global_conf,
app_conf['who.config_file'],
app_conf['who.log_file'],
app_conf['who.log_level'])
else:
# Read the current configuration file and replace "secret" keys in every line
who_config_lines = []
secret = binascii.hexlify(os.urandom(16))
if len(secret) != 32:
raise RuntimeError(
'Could not generate random repoze.who secret, no os.urandom support?'
)
with open(app_conf['who.config_file']) as f:
for line in f.readlines():
who_config_lines.append(
re.sub(r'^(secret)\s*=\s*.*$', r'\1 = %s' % secret,
line))
with tempinput(''.join(who_config_lines)) as who_config_file:
app = make_who_with_config(app, global_conf, who_config_file,
app_conf['who.log_file'],
app_conf['who.log_level'])
# this is a compatibility hack for pylons > 1.0!!!
conf = PyConf(config)
conf['global_conf'] = global_conf
conf['app_conf'] = app_conf
conf['__file__'] = global_conf['__file__']
conf['FILE'] = global_conf['__file__']
conf['routes.map'] = config['routes.map']
if not hasattr(conf, 'init_app'):
setattr(conf, 'init_app', config.init_app)
app.config = conf
return app
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""
Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether this application provides a full WSGI stack (by default,
meaning it handles its own exceptions and errors). Disable
full_stack when this application is "managed" by another WSGI
middleware.
``static_files``
Whether this application serves its own static files; disable
when another web server is responsible for serving them.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp()
# Profiling Middleware
if profile_load:
if asbool(config['profile']):
app = AccumulatingProfileMiddleware(
app,
log_filename='/var/log/linotp/profiling.log',
cachegrind_filename='/var/log/linotp/cachegrind.out',
discard_first_request=True,
flush_at_shutdown=True,
path='/__profile__'
)
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = SessionMiddleware(app, config)
app = CacheMiddleware(app, config)
# CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
if asbool(full_stack):
# Handle Python exceptions
app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# Display error documents for 401, 403, 404 status codes (and
# 500 when debug is disabled)
if asbool(config['debug']):
app = StatusCodeRedirect(app)
else:
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
# repoze.who
if repoze_load:
app = make_who_with_config(app, global_conf, app_conf['who.config_file'], app_conf['who.log_file'], app_conf['who.log_level'])
return app
from groundhog import Groundhog
from repoze.profile.profiler import AccumulatingProfileMiddleware
from paste.httpserver import serve
# application
app = Groundhog(__name__, 'seekrit')
@app.route('/')
def root():
return 'hello'
if __name__ == '__main__':
wsgiapp = app.get_wsgiapp()
wrapped = AccumulatingProfileMiddleware(wsgiapp)
serve(wrapped)
