def make_app(mapper, controllers, template_dir=None, debug=False): app = Application(controllers, template_dir=template_dir) app = AuthenticateMiddleware(app) app = RoutesMiddleware(app, mapper) app = ErrorDocumentMiddleware(app) app = ErrorMiddleware(app, debug=debug) return app
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 do_request(app, expect_status=500):
app = lint.middleware(app)
app = ErrorMiddleware(app, {}, debug=True)
app = clear_middleware(app)
testapp = TestApp(app)
res = testapp.get('', status=expect_status, expect_errors=True)
return res
def make_app(global_conf=None):
from athemeweb.classpublisher import ClassPublisher
from athemeweb.webroot import WebRoot
real_app = ClassPublisher(WebRoot())
from paste.exceptions.errormiddleware import ErrorMiddleware
error_app = ErrorMiddleware(real_app, global_conf=global_conf)
from paste.session import SessionMiddleware
return SessionMiddleware(error_app, global_conf=global_conf)
def get_wsgi_server():
flower_app = Flower(capp=scheduler,
options=default_options,
handlers=handlers,
**settings)
wsgi_app = tornado.wsgi.WSGIAdapter(flower_app)
wsgi_app = ErrorMiddleware(wsgi_app, debug=debug_flag)
wsgi_app = TransLogger(wsgi_app, setup_console_handler=debug_flag)
return wsgi_app
def server_for_test_app(app):
try:
from paste.exceptions.errormiddleware import ErrorMiddleware
error_app = ErrorMiddleware(app.app, debug=True, error_log="errors.log")
except ImportError:
# paste.exceptions not available for Python 3.
error_app = app
server = StopableWSGIServer.create(error_app)
try:
server.wait()
yield server
finally:
server.shutdown()
def build_wsgiapp(self):
"""Build the wsgiapp callable wrapping self.dispatcher with WSGI middlewares"""
wsgiapp = self.dispatcher
if self.debug:
wsgiapp = EvalException(wsgiapp, debug=True)
elif 'debug_email' in self.config:
smtp_kwargs = self.config.getAttr('debug_email')
if 'error_subject_prefix' not in smtp_kwargs:
smtp_kwargs['error_subject_prefix'] = '[%s] ' % self.site_name
smtp_kwargs['error_email'] = smtp_kwargs['error_email'].replace(';', ',').split(',')
if 'smtp_use_tls' in smtp_kwargs:
smtp_kwargs['smtp_use_tls'] = (smtp_kwargs['smtp_use_tls'] in (True, 'true', 't', 'True', '1', 'TRUE'))
wsgiapp = ErrorMiddleware(wsgiapp, **smtp_kwargs)
return wsgiapp
def test_expected_exceptions_still_have_cors(self):
def raises_app(environ, start_response):
raise IOError('bad')
catching_app = ErrorMiddleware(raises_app)
app = cors_filter_factory(catching_app)
testapp = TestApp(app)
res = testapp.get('/the_path_doesnt_matter', status=500)
assert_that(res.normal_body, is_(b'Failed to handle request bad'))
# Errors set the right response headers
res = testapp.get('/',
extra_environ={
'HTTP_ORIGIN': 'http://example.org'},
status=500)
assert_that(res.headers, has_key('Access-Control-Allow-Origin'))
def server_for_test_app(app):
try:
from paste.exceptions.errormiddleware import ErrorMiddleware
error_app = ErrorMiddleware(app.app, debug=True, error_log="errors.log")
server = StopableWSGIServer.create(error_app)
except ImportError:
# paste.exceptions not available for Python 3.
error_app = app.app
server = StopableWSGIServer.create(error_app)
try:
server.wait()
yield server
finally:
server.shutdown()
# There seem to be persistent transient problems with the testing, sleeping
# between creation of test app instances for greater than .5 seconds seems
# to help (async loop length in code is .5 so this maybe makes some sense?)
if "TEST_WEBAPP_POST_SHUTDOWN_SLEEP" in environ:
time.sleep(int(environ.get("TEST_WEBAPP_POST_SHUTDOWN_SLEEP")))
def ErrorHandler(app, global_conf, **errorware):
"""ErrorHandler Toggle
If debug is enabled, this function will return the app wrapped in
our customized Paste EvalException middleware we have called the
``PylonsEvalException``.
Otherwise, the app will be wrapped in the Paste ErrorMiddleware, and
the ``errorware`` dict will be passed into it.
"""
if asbool(global_conf.get('debug')):
from pylons.error import PylonsEvalException
app = PylonsEvalException(app, global_conf, **errorware)
else:
from paste.exceptions.errormiddleware import ErrorMiddleware
if 'error_template' in errorware:
del errorware['error_template']
app = ErrorMiddleware(app, global_conf, **errorware)
return app
from pecan import conf
from pecan.deploy import deploy
app = deploy('/opt/web/draughtcraft/src/production.py')
from paste.exceptions.errormiddleware import ErrorMiddleware
app = ErrorMiddleware(app,
error_email=conf.error_email,
from_address=conf.error_email,
smtp_server=conf.error_smtp_server,
smtp_username=conf.error_email,
smtp_password=conf.error_password,
smtp_use_tls=True)
import sys, os
INTERP = "/usr/local/bin/python2.7"
if sys.executable != INTERP: os.execl(INTERP, INTERP, *sys.argv)
import os, sys, site
site.addsitedir('/home/achilles/site-packages')
site.addsitedir('/home/achilles/rails/khorlo')
#site.addsitedir('/home/achilles/rails')
#site.addsitedir('/home/oskkate/site-packages')
os.environ['LD_LIBRARY_PATH'] = '/usr/local/lib'
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
import django.core.handlers.wsgi
from paste.exceptions.errormiddleware import ErrorMiddleware
application = django.core.handlers.wsgi.WSGIHandler()
application = ErrorMiddleware(application, debug=True)
def main():
parser = optparse.OptionParser()
parser.add_option('-l',
'--location',
dest='location',
action='store',
type="string",
help='path prefix to store the database in',
default="dtg_")
parser.add_option('-i',
'--server-ip',
dest='server_ip',
action='store',
type="string",
help='ip/hostname to run the server on',
default="127.0.0.1")
parser.add_option('-p',
'--server-port',
dest='server_port',
action='store',
type="int",
help='port to run the server on',
default=5005)
parser.add_option('-e',
'--email',
dest='email',
action='store',
type="string",
help='e-mail address of the admin',
default=None)
parser.add_option(
'-P',
'--path',
dest='path',
action='store',
type="string",
help=
'Path of DTG below the HTTP root folder (e.g. PATH in http://SERVERIP:SERVERPORT/PATH/)',
default=None)
parser.add_option(
'-R',
'--proxy',
dest='proxy',
action='store_true',
help='Proxy mode (use when running behind an HTTP proxy)',
default=False)
parser.add_option('-D',
'--debug',
dest='debug',
action='store_true',
help='Debug mode',
default=False)
parser.add_option('-M',
'--allow-migrations',
dest='migrate',
action='store_true',
help='Allow DB migrations. Only use it with backups :-)',
default=False)
parser.add_option('--add-user',
dest='adduser',
action='store',
type="string",
help="Username to add, password will be asked for",
default="")
parser.add_option('--del-user',
dest='deluser',
action='store',
type="string",
help="Username to delete",
default="")
parser.add_option('--change-pwd',
dest='changepwd',
action='store',
type="string",
help="Username to change password of",
default="")
options, args = parser.parse_args()
if args:
parser.error("don't know what to do with additional arguments")
# HACK! :)
sys.dtg_db_path = lambda x: "sqlite:///" + os.path.abspath(options.location
+ x + ".db")
sys.dtg_do_upgrade = options.migrate
sys.dtg_debug = options.debug
from dtg.webapp import app, add_user, del_user, change_pwd
if options.debug:
app.secret_key = "insecure"
if options.adduser or options.changepwd:
password, password2 = getpass(), getpass("Password, again: ")
if password != password2:
print "Passwords do not match"
return
if options.adduser:
print add_user(options.adduser, password)
return
if options.deluser:
print del_user(options.deluser)
return
if options.changepwd:
print change_pwd(options.changepwd, password)
return
#app.wsgi_app = GzipMiddleware(app.wsgi_app)
if options.email is not None:
kwargs = dict(error_email=options.email,
from_address=options.email,
smtp_server="localhost")
else:
kwargs = {}
app.wsgi_app = ErrorMiddleware(app.wsgi_app, **kwargs)
if options.path:
if not options.path.startswith("/"):
options.path = "/" + options.path
print "Mounting DTG under", options.path
app.wsgi_app = DispatcherMiddleware(
lambda e, s: [s("404 Not found", []), "Not found"][1:],
mounts={options.path: app.wsgi_app})
if options.proxy:
app.wsgi_app = ProxyFix(app.wsgi_app)
app.run(host=options.server_ip,
port=options.server_port,
threaded=True,
use_reloader=options.debug,
passthrough_errors=True)
"""
WSGI config for testproject project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "testproject.settings")
app = get_wsgi_application()
from paste.exceptions.errormiddleware import ErrorMiddleware
application = ErrorMiddleware(app)
def getWSGIServer(self):
wsgi_app = tornado.wsgi.WSGIAdapter(self.flower)
wsgi_app = ErrorMiddleware(wsgi_app, debug=debug_flag)
wsgi_app = TransLogger(wsgi_app, setup_console_handler=debug_flag)
return wsgi_app
if sys.executable != INTERP:
os.execl(INTERP, INTERP, *sys.argv)
# Set up the path
sys.stdout = sys.stderr
sys.path.append(site_home)
sys.path.append(os.path.join(site_home,'..'))
sys.path.append(os.path.join(site_home,'project'))
sys.path.append(os.path.join(env_bin,'/lib/python2.6/site-packages'))
sys.path.append(os.getcwd())
os.environ['DJANGO_SETTINGS_MODULE'] = "%s.project.settings" % site_name
# Set up the django application
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
#Define a test application to check that the ErrorMiddleware is working
def testapplication(environ, start_response):
status = '200 OK'
output = 'Hello World! Running Python version %s\n\n' % (sys.version)
response_headers = [('Content-type', 'text/plain'),
('Content-Length', str(len(output)))]
#Check that the ErrorMiddleware works by uncommenting the next line
#raise("error")
start_response(status, response_headers)
return [output]
from paste.exceptions.errormiddleware import ErrorMiddleware
application = ErrorMiddleware(application, debug=DEBUG)
from objectpub import ObjectPublisher, Root
from paste.exceptions.errormiddleware import ErrorMiddleware
from paste.evalexception import EvalException
app = ObjectPublisher(Root())
#wrapped_app = EvalException(app)
exc_wrapped_app = ErrorMiddleware(app)
if __name__ == '__main__':
from paste import httpserver
httpserver.serve(exc_wrapped_app, host='127.0.0.1', port='8079')
time.tzset()
import controller
application = bottle.default_app()
application.catchall = False
if instanceconfig.debug == True:
from werkzeug.debug import DebuggedApplication
application = DebuggedApplication(application, evalex=True)
elif not instanceconfig.debug:
import paste.exceptions.errormiddleware
# monkey-patch in logging to datestamped files or gmail
# the latter is needed when access to datestamped files is impossible
import exception_logging
paste.exceptions.errormiddleware.reporter = exception_logging
from paste.exceptions.errormiddleware import ErrorMiddleware
application = ErrorMiddleware(
application,
debug=False,
error_log=instanceconfig.exceptionpath,
error_email=instanceconfig.smtp_to,
from_address=instanceconfig.smtp_from,
smtp_server=instanceconfig.smtp_server,
smtp_username=instanceconfig.smtp_user,
smtp_password=instanceconfig.smtp_pass,
error_subject_prefix=instanceconfig.host + ' error:')
except Exception, e:
print "Couldn't load main app, traceback follows. Starting config app instead."
import traceback
traceback.print_exc()
import config_app
application = config_app.app
import sys, os
sys.path.append(os.getcwd())
sys.path.append(os.getcwd() + '/huxley')
INTERP = os.path.join(os.getcwd(), 'env/bin/python')
if sys.executable != INTERP: os.execl(INTERP, INTERP, *sys.argv)
sys.path.insert(0, os.path.join(os.getcwd(), 'env/bin'))
sys.path.insert(
0, os.path.join(os.getcwd(), 'env/lib/python2.7/site-packages/django'))
sys.path.insert(0, os.path.join(os.getcwd(),
'env/lib/python2.7/site-packages'))
os.environ['DJANGO_SETTINGS_MODULE'] = "huxley.settings"
import django
django.setup()
from django.core.handlers.wsgi import WSGIHandler
from paste.exceptions.errormiddleware import ErrorMiddleware
application = ErrorMiddleware(WSGIHandler(), debug=True)
def make_app(global_conf={}, **app_conf):
import os, sys
# Cleanup the Python path (mainly to circumvent the systems SetupTools)
sys.path = [path for path in sys.path if ("site-packages" not in path) and ('pyxer' not in path) and ('/Extras/lib/python' not in path)]
# Add our local packages folder to the path
import site
here = app_conf.get('pyxer_here') or os.path.join(os.path.dirname(__file__), os.pardir, os.pardir)
if not os.path.isdir(os.path.join(here, 'public')):
here = os.getcwd()
site_lib = os.path.join(here, 'site-packages')
site.addsitedir(here)
site.addsitedir(site_lib)
# import pkg_resources
# import setuptools
# log.info(site.__file__)
# pprint.pprint(global_conf)
log.debug('\n'.join(sys.path))
try:
import beaker.middleware
global SessionMiddleware
SessionMiddleware = beaker.middleware.SessionMiddleware
log.debug("Beaker successfully loaded")
except ImportError:
log.debug("Beaker NOT loaded")
conf = AttrDict(pyxer={
"session": "",
"debug": False,
"root": "public",
})
root = os.getcwd()
try:
import ConfigParser
filename = os.path.abspath(global_conf.get("__file__", None)) or os.path.abspath("pyxer.ini")
# filename = os.path.abspath("pyxer.ini" )
root = os.path.dirname(filename)
cfile = ConfigParser.SafeConfigParser()
cfile.read(filename)
for section in cfile.sections():
if not conf.has_key(section):
conf[section] = AttrDict()
try:
for name, value in cfile.items(section):
conf[section][name] = value
except:
log.exception("Config items")
log.debug("Config: %r", conf)
except:
log.warning("Config file not found")
# Add current directory to sys path
# site.addsitedir(root)
# Here we expect all data
base = os.path.join(root, "public")
# app = App(global_conf=None, root="public", path=None, **app_conf)
app = PyxerApp()
if SessionMiddleware and (conf.get("pyxer.session", "beaker") == "beaker"):
log.debug("Beaker sessions")
if "google.appengine" in sys.modules:
# server = SessionMiddleware(server, type='ext:google', table_name="beaker_session", cookie_expires=False)
app = SessionMiddleware(app,
type='ext:google',
table_name='PyxerSession')
else:
app = SessionMiddleware(app,
type='dbm',
data_dir=os.path.join(root, 'cache'))
app = RegistryManager(app)
app = ConfigMiddleware(app, conf.copy())
# app = CgitbMiddleware(app)
if not stage:
app = ErrorMiddleware(app, debug=True)
#static = PyxerStatic(base)
#app = Cascade([app, static])
return app
guess = int(req.parameters.get("guess", [None])[0])
if guess < secret_number:
message = "You guessed %d - which is to low" % guess
elif guess > secret_number:
message = "You guessed %d - which is to high" % guess
else:
# They got it right so we're done
break
except TypeError:
guess = None
message = "You must guess a number!"
return """Yay - %d is the right number, you made it in %d guesses.<br />
<a href="/">Play again</a>""" % (
guess,
number_of_guesses,
)
if __name__ == "__main__":
import stacklesswsgi
from paste.exceptions.errormiddleware import ErrorMiddleware
exc_wrapped = ErrorMiddleware(SessionlessApp())
exc_wrapped.debug_mode = True
import wsgiref.validate
verify = wsgiref.validate.validator(exc_wrapped)
s = stacklesswsgi.Server(("127.0.0.1", int(sys.argv[1])), verify)
s.start()
CORS(app, resources={r"/*": {"origins": "*"}}, allow_headers=['X-Requested-With', 'Content-Type', 'Authorization', 'user-aws-key', 'Accept', 'Access-Control-Allow-Origin'])
from views.swagger import swagger_bp
from views.user_management import user_management_bp
from app.views.aws.account_management import aws_account_management_bp
from app.views.aws.cost.cost import aws_cost_cost_bp
from app.views.aws.cost.stats import aws_cost_stats_bp
from app.views.aws.forecast import aws_forecast_bp
from app.views.aws.usage import aws_usage_bp
from views.google import google_bp
from views.ms_azure import ms_azure_bp
from views.compare_providers import compare_providers_bp
import views.health
app.register_blueprint(swagger_bp)
app.register_blueprint(user_management_bp)
app.register_blueprint(aws_account_management_bp)
app.register_blueprint(aws_cost_cost_bp)
app.register_blueprint(aws_cost_stats_bp)
app.register_blueprint(aws_forecast_bp)
app.register_blueprint(aws_usage_bp)
app.register_blueprint(google_bp)
app.register_blueprint(ms_azure_bp)
app.register_blueprint(compare_providers_bp)
if app.debug:
from paste.exceptions.errormiddleware import ErrorMiddleware
wsgi = ErrorMiddleware(app, debug=True)
else:
wsgi = app
def _make_core_app(root, global_conf, full_stack=True, **app_conf):
"""
Set allura up with the settings found in the PasteDeploy configuration
file used.
:param root: The controller module containing the TG root
:param global_conf: The global settings for allura (those
defined under the ``[DEFAULT]`` section).
:type global_conf: dict
:param full_stack: Should the whole TG2 stack be set up?
:type full_stack: str or bool
:return: The allura application with all the relevant middleware
loaded.
This is the PasteDeploy factory for the allura application.
``app_conf`` contains all the application-specific settings (those defined
under ``[app:main]``.
"""
# Run all the initialization code here
mimetypes.init([pkg_resources.resource_filename('allura', 'etc/mime.types')] + mimetypes.knownfiles)
# Configure MongoDB
ming.configure(**app_conf)
# Configure ActivityStream
if asbool(app_conf.get('activitystream.recording.enabled', False)):
activitystream.configure(**h.convert_bools(app_conf, prefix='activitystream.'))
# Configure EW variable provider
ew.render.TemplateEngine.register_variable_provider(get_tg_vars)
# Set FormEncode language to english, as we don't support any other locales
formencode.api.set_stdtranslation(domain='FormEncode', languages=['en'])
# Create base app
base_config = ForgeConfig(root)
load_environment = base_config.make_load_environment()
# Code adapted from tg.configuration, replacing the following lines:
# make_base_app = base_config.setup_tg_wsgi_app(load_environment)
# app = make_base_app(global_conf, full_stack=True, **app_conf)
# Configure the TG environment
load_environment(global_conf, app_conf)
app = tg.TGApp()
for mw_ep in h.iter_entry_points('allura.middleware'):
Middleware = mw_ep.load()
if getattr(Middleware, 'when', 'inner') == 'inner':
app = Middleware(app, config)
# Required for sessions
app = SessionMiddleware(app, config, data_serializer=BeakerPickleSerializerWithLatin1())
# Handle "Remember me" functionality
app = RememberLoginMiddleware(app, config)
# Redirect 401 to the login page
app = LoginRedirectMiddleware(app)
# Add instrumentation
app = AlluraTimerMiddleware(app, app_conf)
# Clear cookies when the CSRF field isn't posted
if not app_conf.get('disable_csrf_protection'):
app = CSRFMiddleware(app, '_session_id')
if asbool(config.get('cors.enabled', False)):
# Handle CORS requests
allowed_methods = aslist(config.get('cors.methods'))
allowed_headers = aslist(config.get('cors.headers'))
cache_duration = asint(config.get('cors.cache_duration', 0))
app = CORSMiddleware(app, allowed_methods, allowed_headers, cache_duration)
# Setup the allura SOPs
app = allura_globals_middleware(app)
# Ensure http and https used per config
if config.get('override_root') != 'task':
app = SSLMiddleware(app, app_conf.get('no_redirect.pattern'),
app_conf.get('force_ssl.pattern'),
app_conf.get('force_ssl.logged_in'))
# Setup resource manager, widget context SOP
app = ew.WidgetMiddleware(
app,
compress=True,
use_cache=not asbool(global_conf['debug']),
script_name=app_conf.get('ew.script_name', '/_ew_resources/'),
url_base=app_conf.get('ew.url_base', '/_ew_resources/'),
extra_headers=ast.literal_eval(app_conf.get('ew.extra_headers', '[]')),
cache_max_age=asint(app_conf.get('ew.cache_header_seconds', 60*60*24*365)),
# settings to pass through to jinja Environment for EW core widgets
# these are for the easywidgets' own [easy_widgets.engines] entry point
# (the Allura [easy_widgets.engines] entry point is named "jinja" (not jinja2) but it doesn't need
# any settings since it is a class that uses the same jinja env as the rest of allura)
**{
'jinja2.auto_reload': asbool(config['auto_reload_templates']),
'jinja2.bytecode_cache': AlluraJinjaRenderer._setup_bytecode_cache(),
'jinja2.cache_size': asint(config.get('jinja_cache_size', -1)),
}
)
# Handle static files (by tool)
app = StaticFilesMiddleware(app, app_conf.get('static.script_name'))
# Handle setup and flushing of Ming ORM sessions
app = MingMiddleware(app)
# Set up the registry for stacked object proxies (SOPs).
# streaming=true ensures they won't be cleaned up till
# the WSGI application's iterator is exhausted
app = RegistryManager(app, streaming=True)
# "task" wsgi would get a 2nd request to /error/document if we used this middleware
if config.get('override_root') not in ('task', 'basetest_project_root'):
if asbool(config['debug']):
# Converts exceptions to HTTP errors, shows traceback in debug mode
# don't use TG footer with extra CSS & images that take time to load
tg.error.footer_html = '<!-- %s %s -->'
app = tg.error.ErrorHandler(app, global_conf, **config['tg.errorware'])
else:
app = ErrorMiddleware(app, config, **config['tg.errorware'])
app = SetRequestHostFromConfig(app, config)
# Redirect some status codes to /error/document
if asbool(config['debug']):
app = StatusCodeRedirect(app, base_config.handle_status_codes)
else:
app = StatusCodeRedirect(
app, base_config.handle_status_codes + [500])
for mw_ep in h.iter_entry_points('allura.middleware'):
Middleware = mw_ep.load()
if getattr(Middleware, 'when', 'inner') == 'outer':
app = Middleware(app, config)
return app
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import paste
import cherrypy
from server import app
from paste.exceptions.errormiddleware import ErrorMiddleware
from paste.translogger import TransLogger
if __name__ == "__main__":
app = ErrorMiddleware(app, debug=False)
app = TransLogger(app, setup_console_handler=True)
cherrypy.tree.graft(app, '')
cherrypy.config.update({
'engine.autoreload_on': False,
'server.socket_port': 4000,
'server.socket_host': '0.0.0.0',
'server.thread_pool': 5,
})
cherrypy.engine.signals.subscribe()
cherrypy.engine.start()
cherrypy.engine.block()