def string_or_bool(self, value):
try:
lowervalue = value.lower()
except AttributeError:
return asbool(value)
if lowervalue in ('false', 'no', 'off', 'n', 'f', '0', 'true', 'yes',
'on', 'y', 't', '1'):
return asbool(value)
return value
def _add_middleware(self, conf, app):
errorware = conf['tg.slowreqs']
if errorware.get('enable') and not asbool(conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
if errorware.get('reporters', []):
for reporter in errorware['reporters']:
reporters.append(reporter)
try:
import backlash
except ImportError: # pragma: no cover
log.warning("backlash not installed, slow requests reporting won't be available")
else:
return backlash.TraceSlowRequestsMiddleware(
app, reporters, interval=errorware.get('interval', 25),
exclude_paths=errorware.get('exclude', None),
context_injectors=[_turbogears_backlash_context]
)
return app
def ErrorReporter(app, global_conf, **errorware):
if not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' email tracebacks won\'t be available')
else:
app = backlash.TraceErrorsMiddleware(
app,
reporters,
context_injectors=[_turbogears_backlash_context])
return app
def SlowReqsReporter(app, global_conf, **errorware):
if errorware.get('enable') and not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' slow requests reporting won\'t be available')
else:
app = backlash.TraceSlowRequestsMiddleware(
app,
reporters,
interval=errorware.get('interval', 25),
exclude_paths=errorware.get('exclude', None),
context_injectors=[_turbogears_backlash_context])
return app
def _add_middleware(self, conf, app):
errorware = conf['tg.slowreqs']
if errorware.get('enable') and not asbool(conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
if errorware.get('reporters', []):
for reporter in errorware['reporters']:
reporters.append(reporter)
try:
import backlash
except ImportError: # pragma: no cover
log.warning(
"backlash not installed, slow requests reporting won't be available"
)
else:
return backlash.TraceSlowRequestsMiddleware(
app,
reporters,
interval=errorware.get('interval', 25),
exclude_paths=errorware.get('exclude', None),
context_injectors=[_turbogears_backlash_context])
return app
def from_settings(cls, settings, prefix='mail.'):
"""Create a new instance of 'Mailer' from settings dict.
:param settings: a settings dict-like
:param prefix: prefix separating 'tgext.mailer' settings
"""
settings = settings or {}
kwarg_names = [
prefix + k for k in ('host', 'port', 'username', 'password', 'tls',
'ssl', 'keyfile', 'certfile', 'queue_path',
'debug', 'default_sender')
]
size = len(prefix)
kwargs = dict(((k[size:], settings[k]) for k in settings.keys()
if k in kwarg_names))
for key in ('tls', 'ssl'):
val = kwargs.get(key)
if val:
kwargs[key] = asbool(val)
return cls(**kwargs)
def ErrorHandler(app, global_conf, **errorware):
"""ErrorHandler Toggle
If debug is enabled, this function will return the app wrapped in
the WebError ``EvalException`` middleware which displays
interactive debugging sessions when a traceback occurs.
Otherwise, the app will be wrapped in the WebError
``ErrorMiddleware``, and the ``errorware`` dict will be passed into
it. The ``ErrorMiddleware`` handles sending an email to the address
listed in the .ini file, under ``email_to``.
"""
if asbool(global_conf.get('debug')):
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' debug mode won\'t be available')
else:
app = backlash.DebuggedApplication(
app, context_injectors=[_turbogears_backlash_context])
return app
def ErrorReporter(app, global_conf, **errorware):
if not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' email tracebacks won\'t be available')
else:
app = backlash.TraceErrorsMiddleware(
app, reporters,
context_injectors=[_turbogears_backlash_context])
return app
def _add_middleware(self, conf, app):
errorware = conf['tg.errorware']
if errorware.get('enable', True) and not asbool(conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
if errorware.get('reporters', []):
for reporter in errorware['reporters']:
reporters.append(reporter)
try:
import backlash
except ImportError: # pragma: no cover
log.warning("backlash not installed, email tracebacks won't be available")
else:
return backlash.TraceErrorsMiddleware(
app, reporters, context_injectors=[_turbogears_backlash_context]
)
return app
def SlowReqsReporter(app, global_conf, **errorware):
if errorware.get('enable') and not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' slow requests reporting won\'t be available')
else:
app = backlash.TraceSlowRequestsMiddleware(
app, reporters, interval=errorware.get('interval', 25),
exclude_paths=errorware.get('exclude', None),
context_injectors=[_turbogears_backlash_context])
return app
def ErrorHandler(app, global_conf, **errorware):
"""ErrorHandler Toggle
If debug is enabled, this function will return the app wrapped in
the WebError ``EvalException`` middleware which displays
interactive debugging sessions when a traceback occurs.
Otherwise, the app will be wrapped in the WebError
``ErrorMiddleware``, and the ``errorware`` dict will be passed into
it. The ``ErrorMiddleware`` handles sending an email to the address
listed in the .ini file, under ``email_to``.
"""
if asbool(global_conf.get('debug')):
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' debug mode won\'t be available')
else:
app = backlash.DebuggedApplication(
app, context_injectors=[_turbogears_backlash_context])
return app
def _add_middleware(self, conf, app):
errorware = conf['tg.errorware']
if errorware.get('enable', True) and not asbool(conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
if errorware.get('reporters', []):
for reporter in errorware['reporters']:
reporters.append(reporter)
try:
import backlash
except ImportError: # pragma: no cover
log.warning(
"backlash not installed, email tracebacks won't be available"
)
else:
return backlash.TraceErrorsMiddleware(
app,
reporters,
context_injectors=[_turbogears_backlash_context])
return app
def ErrorReporter(app, global_conf, **errorware):
"""Provides Error reporting through Backlash on TurboGears.
This is enabled/disabled through the ``debug`` configuration option.
Currently EMail and Sentry backlash reporters can be enabled.
All the options available for error reporting are configured
as ``trace_errors.*`` options in your ``app_cfg`` or ``.ini`` files.
The available options for **EMail** reporter are:
- ``trace_errors.enable`` -> Enable or disable error reporting,
by default is enabled if backlash is available and ``debug=false``
- ``trace_errors.smtp_server`` -> SMTP Server to connect to for sending emails
- ``trace_errors.smtp_port`` -> SMTP port to connect to
- ``trace_errors.from_address`` -> Address sending the error emails
- ``trace_errors.error_email`` -> Address the error emails should be sent to.
- ``trace_errors.smtp_username`` -> Username to authenticate on SMTP server.
- ``trace_errors.smtp_password`` -> Password to authenticate on SMTP server.
- ``trace_errors.smtp_use_tls`` -> Whenever to enable or not TLS for SMTP.
- ``trace_errors.error_subject_prefix`` -> Prefix to append to error emails,
by default ``WebApp Error:`` is prepended.
- ``trace_errors.dump_request`` -> Whenever to attach a request dump to the email so that
all request data is provided.
- ``trace_errors.dump_request_size`` -> Do not dump request if it's bigger than this value,
useful for uploaded files. By default 50K.
- ``trace_errors.dump_local_frames`` -> Enable dumping local variables in case of crashes.
- ``trace_errors.dump_local_frames_count`` -> Dump up to X frames when dumping local variables.
The default is 2
Available options for **Sentry** reporter are:
- ``trace_errors.sentry_dsn`` -> Sentry instance where to send the errors.
"""
if errorware.get('enable', True) and not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' email tracebacks won\'t be available')
else:
app = backlash.TraceErrorsMiddleware(
app, reporters,
context_injectors=[_turbogears_backlash_context])
return app
def ErrorReporter(app, global_conf, **errorware):
"""Provides Error reporting through Backlash on TurboGears.
This is enabled/disabled through the ``debug`` configuration option.
Currently EMail and Sentry backlash reporters can be enabled.
All the options available for error reporting are configured
as ``trace_errors.*`` options in your ``app_cfg`` or ``.ini`` files.
The available options for **EMail** reporter are:
- ``trace_errors.smtp_server`` -> SMTP Server to connect to for sending emails
- ``trace_errors.from_address`` -> Address sending the error emails
- ``trace_errors.error_email`` -> Address the error emails should be sent to.
- ``trace_errors.smtp_username`` -> Username to authenticate on SMTP server.
- ``trace_errors.smtp_password`` -> Password to authenticate on SMTP server.
- ``trace_errors.smtp_use_tls`` -> Whenever to enable or not TLS for SMTP.
- ``trace_errors.error_subject_prefix`` -> Prefix to append to error emails,
by default ``WebApp Error:`` is prepended.
- ``trace_errors.dump_request`` -> Whenever to attach a request dump to the email so that
all request data is provided.
- ``trace_errors.dump_request_size`` -> Do not dump request if it's bigger than this value,
useful for uploaded files. By default 50K.
- ``trace_errors.dump_local_frames`` -> Enable dumping local variables in case of crashes.
- ``trace_errors.dump_local_frames_count`` -> Dump up to X frames when dumping local variables.
The default is 2
Available options for **Sentry** reporter are:
- ``trace_errors.sentry_dsn`` -> Sentry instance where to send the errors.
"""
if not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' email tracebacks won\'t be available')
else:
app = backlash.TraceErrorsMiddleware(
app, reporters,
context_injectors=[_turbogears_backlash_context])
return app
def _add_middleware(self, conf, app):
if asbool(conf.get('debug')):
try:
import backlash
except ImportError: # pragma: no cover
log.warning("backlash not installed, debug mode won't be available")
else:
return backlash.DebuggedApplication(
app, context_injectors=[_turbogears_backlash_context]
)
return app
def _add_middleware(self, conf, app):
if asbool(conf.get('debug')):
try:
import backlash
except ImportError: # pragma: no cover
log.warning(
"backlash not installed, debug mode won't be available")
else:
return backlash.DebuggedApplication(
app, context_injectors=[_turbogears_backlash_context])
return app
def test_asbool_truthy(self):
assert asbool('true')
assert asbool('yes')
assert asbool('on')
assert asbool('y')
assert asbool('t')
assert asbool('1')
def test_asbool_falsy(self):
assert not asbool('false')
assert not asbool('no')
assert not asbool('off')
assert not asbool('n')
assert not asbool('f')
assert not asbool('0')
def test_asbool_falsy(self):
assert not asbool('false')
assert not asbool('no')
assert not asbool('off')
assert not asbool('n')
assert not asbool('f')
assert not asbool('0')
def test_asbool_truthy(self):
assert asbool('true')
assert asbool('yes')
assert asbool('on')
assert asbool('y')
assert asbool('t')
assert asbool('1')
def create(cls, config, app_globals):
"""Setup a renderer and loader for Genshi templates.
Override this to customize the way that the internationalization
filter, template loader
"""
if genshi is None: # pragma: no cover
# Genshi not available
return None
# Patch for Genshi on Python3.4
if asbool(config.get('templating.genshi.name_constant_patch', False)):
from genshi.template.astutil import ASTCodeGenerator
if not hasattr(ASTCodeGenerator, 'visit_NameConstant'):
def _visit_NameConstant(self, node):
if node.value is None:
self._write('None')
elif node.value is True:
self._write('True')
elif node.value is False:
self._write('False')
else:
raise Exception("Unknown NameConstant %r" %
(node.value, ))
ASTCodeGenerator.visit_NameConstant = _visit_NameConstant
if config.get('use_dotted_templatenames', True):
TemplateLoader = DottedTemplateLoader
template_loader_args = {
'dotted_finder': app_globals.dotted_filename_finder
}
else:
TemplateLoader = GenshiTemplateLoader
template_loader_args = {}
loader = TemplateLoader(search_path=config.paths.templates,
max_cache_size=asint(
config.get('genshi.max_cache_size', 30)),
auto_reload=config.auto_reload_templates,
callback=cls.on_template_loaded,
**template_loader_args)
return {'genshi': cls(loader, config)}
def SlowReqsReporter(app, global_conf, **errorware):
"""Provides slow requests reporting for TurboGears through BackLash.
This is enabled through the ``trace_slowreqs.enable`` option and
is only enabled when ``debug=false``.
All the options available for error reporting are configured
as ``trace_slowreqs.*`` options in your ``app_cfg`` or ``.ini`` files:
- ``trace_slowreqs.enable`` -> Enable/Disable slow requests reporting
- ``trace_slowreqs.interval`` -> Report requests slower than this value (default: 25s)
- ``trace_slowreqs.exclude`` -> List of urls that should be excluded
Slow requests are reported using *EMail* or *Sentry*, the same
options available in :class:`.ErrorReporter` apply with ``trace_slowreqs.``
instead of ``trace_errors.``.
"""
if errorware.get('enable') and not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' slow requests reporting won\'t be available')
else:
app = backlash.TraceSlowRequestsMiddleware(
app,
reporters,
interval=errorware.get('interval', 25),
exclude_paths=errorware.get('exclude', None),
context_injectors=[_turbogears_backlash_context])
return app
def setup_application(app):
config = app.config
# we want our low level middleware to get to the request ASAP. We don't
# need any stack middleware in them - especially no StatusCodeRedirect buffering
app = SimpleHg(app, config)
app = SimpleGit(app, config)
# Enable https redirects based on HTTP_X_URL_SCHEME set by proxy
if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):
app = HttpsFixup(app, config)
app = PermanentRepoUrl(app, config)
# Optional and undocumented wrapper - gives more verbose request/response logging, but has a slight overhead
if str2bool(config.get('use_wsgi_wrapper')):
app = RequestWrapper(app, config)
return app
def SlowReqsReporter(app, global_conf, **errorware):
"""Provides slow requests reporting for TurboGears through BackLash.
This is enabled through the ``trace_slowreqs.enable`` option and
is only enabled when ``debug=false``.
All the options available for error reporting are configured
as ``trace_slowreqs.*`` options in your ``app_cfg`` or ``.ini`` files:
- ``trace_slowreqs.enable`` -> Enable/Disable slow requests reporting
- ``trace_slowreqs.interval`` -> Report requests slower than this value (default: 25s)
- ``trace_slowreqs.exclude`` -> List of urls that should be excluded
Slow requests are reported using *EMail* or *Sentry*, the same
options available in :class:`.ErrorReporter` apply with ``trace_slowreqs.``
instead of ``trace_errors.``.
"""
if errorware.get('enable') and not asbool(global_conf.get('debug')):
reporters = []
if errorware.get('error_email'):
from backlash.tracing.reporters.mail import EmailReporter
reporters.append(EmailReporter(**errorware))
if errorware.get('sentry_dsn'):
from backlash.tracing.reporters.sentry import SentryReporter
reporters.append(SentryReporter(**errorware))
try:
import backlash
except ImportError: #pragma: no cover
log.warning('backlash not installed,'
' slow requests reporting won\'t be available')
else:
app = backlash.TraceSlowRequestsMiddleware(
app, reporters, interval=errorware.get('interval', 25),
exclude_paths=errorware.get('exclude', None),
context_injectors=[_turbogears_backlash_context])
return app
def create(cls, config, app_globals):
"""Setup a renderer and loader for Genshi templates.
Override this to customize the way that the internationalization
filter, template loader
"""
if genshi is None: # pragma: no cover
# Genshi not available
return None
# Patch for Genshi on Python3.4
if asbool(config.get('templating.genshi.name_constant_patch', False)):
from genshi.template.astutil import ASTCodeGenerator
if not hasattr(ASTCodeGenerator, 'visit_NameConstant'):
def _visit_NameConstant(self, node):
if node.value is None:
self._write('None')
elif node.value is True:
self._write('True')
elif node.value is False:
self._write('False')
else:
raise Exception("Unknown NameConstant %r" % (node.value,))
ASTCodeGenerator.visit_NameConstant = _visit_NameConstant
if config.get('use_dotted_templatenames', True):
TemplateLoader = DottedTemplateLoader
template_loader_args = {'dotted_finder': app_globals.dotted_filename_finder}
else:
TemplateLoader = GenshiTemplateLoader
template_loader_args = {}
loader = TemplateLoader(search_path=config.paths.templates,
max_cache_size=asint(config.get('genshi.max_cache_size', 30)),
auto_reload=config.auto_reload_templates,
callback=cls.on_template_loaded,
**template_loader_args)
return {'genshi': cls(loader, config)}
def __call__(self, app):
try:
# If specified on plugtime, force the specified one
# useful for tests or scripts.
using_debugmailer = self.options['debugmailer']
except KeyError:
# Otherwise use the option provided in configuration file.
using_debugmailer = config.get('mail.debugmailer', False)
if using_debugmailer == 'dummy':
mailer_factory = self._create_dummy_mailer
elif asbool(using_debugmailer):
mailer_factory = self._create_debug_mailer
else:
mailer_factory = self._create_standard_mailer
config['tg.app_globals']._mailer_factory = mailer_factory
global_mailer = mailer_factory(config)
config['tg.app_globals']._mailer = global_mailer
log.info('Configured %s', global_mailer.__class__.__name__)
return app
def __call__(self, app):
try:
# If specified on plugtime, force the specified one
# useful for tests or scripts.
using_debugmailer = self.options['debugmailer']
except KeyError:
# Otherwise use the option provided in configuration file.
using_debugmailer = config.get('mail.debugmailer', False)
if using_debugmailer == 'dummy':
mailer_factory = self._create_dummy_mailer
elif asbool(using_debugmailer):
mailer_factory = self._create_debug_mailer
else:
mailer_factory = self._create_standard_mailer
config['tg.app_globals']._mailer_factory = mailer_factory
global_mailer = mailer_factory(config)
config['tg.app_globals']._mailer = global_mailer
log.info('Configured %s', global_mailer.__class__.__name__)
return app
def wrapper(func, *args, **kwargs):
"""Decorator wrapper"""
tg_locals = tg.request.environ['tg.locals']
enabled = tg_locals.config.get("cache_enabled", "True")
if not asbool(enabled):
return func(*args, **kwargs)
if key:
key_dict = kwargs.copy()
key_dict.update(_make_dict_from_args(func, args))
if query_args:
key_dict.update(tg_locals.request.GET.mixed())
if key != "cache_default":
if isinstance(key, list):
key_dict = dict((k, key_dict[k]) for k in key)
else:
key_dict = {key: key_dict[key]}
else:
key_dict = None
self = None
if args:
self = args[0]
namespace, cache_key = create_cache_key(func, key_dict, self)
if type:
b_kwargs['type'] = type
cache_obj = getattr(tg_locals, 'cache', None)
if not cache_obj: # pragma: no cover
raise Exception('No CacheMiddleware or cache object on '
' app_globals was found')
my_cache = cache_obj.get_cache(namespace, **b_kwargs)
if expire == "never":
cache_expire = None
else:
cache_expire = expire
def create_func():
result = func(*args, **kwargs)
glob_response = tg_locals.response
headers = glob_response.headerlist
status = glob_response.status
full_response = dict(headers=headers, status=status,
cookies=None, content=result)
return full_response
response = my_cache.get_value(cache_key, createfunc=create_func,
expiretime=cache_expire,
starttime=starttime)
if cache_response:
glob_response = tg_locals.response
glob_response.headerlist = [header for header in response['headers']
if header[0].lower() in cache_headers]
glob_response.status = response['status']
return response['content']
def setup_auth(app,
authmetadata,
form_plugin=None,
form_identifies=True,
cookie_secret='secret',
cookie_name='authtkt',
login_url='/login',
login_handler='/login_handler',
post_login_url=None,
logout_handler='/logout_handler',
post_logout_url=None,
login_counter_name=None,
cookie_timeout=None,
cookie_reissue_time=None,
**who_args):
"""
Sets :mod:`repoze.who` up with the provided authenticators and
options to create FriendlyFormPlugin/FastFormPlugin.
It returns a middleware that provides identification,
authentication and authorization in a way that is compatible
with repoze.who and repoze.what.
"""
if 'charset' in who_args: #pragma: no cover
log.warn('charset argument in authentication setup is ignored')
who_args.pop('charset')
# If no identifiers are provided in repoze setup arguments
# then create a default one using AuthTktCookiePlugin.
if 'identifiers' not in who_args:
from repoze.who.plugins.auth_tkt import AuthTktCookiePlugin
cookie = AuthTktCookiePlugin(cookie_secret,
cookie_name,
timeout=cookie_timeout,
reissue_time=cookie_reissue_time)
who_args['identifiers'] = [('cookie', cookie)]
who_args['authenticators'].insert(0, ('cookie', cookie))
# If no form plugin is provided then create a default
# one using the provided options.
if form_plugin is None:
from tg.configuration.auth.fastform import FastFormPlugin
form = FastFormPlugin(login_url,
login_handler,
post_login_url,
logout_handler,
post_logout_url,
rememberer_name='cookie',
login_counter_name=login_counter_name)
else:
form = form_plugin
if form_identifies:
who_args['identifiers'].insert(0, ('main_identifier', form))
# Setting the repoze.who challengers:
if 'challengers' not in who_args:
who_args['challengers'] = []
who_args['challengers'].append(('form', form))
# Including logging
log_file = who_args.pop('log_file', None)
if log_file is not None:
if log_file.lower() == 'stdout':
log_stream = sys.stdout
elif log_file.lower() == 'stderr':
log_stream = sys.stderr
else:
log_stream = open(log_file, 'wb')
who_args['log_stream'] = log_stream
log_level = who_args.get('log_level', None)
if log_level is None:
log_level = logging.INFO
else:
log_level = _LEVELS[log_level.lower()]
who_args['log_level'] = log_level
# Setting up the metadata provider for the user informations
if 'mdproviders' not in who_args:
who_args['mdproviders'] = []
if authmetadata:
authmd = _AuthMetadataProvider(authmetadata)
who_args['mdproviders'].append(('authmd', authmd))
# Set up default classifier
if 'classifier' not in who_args:
who_args['classifier'] = default_request_classifier
# Set up default challenger decider
if 'challenge_decider' not in who_args:
who_args['challenge_decider'] = turbogears_challenge_decider
skip_authn = who_args.pop('skip_authentication', False)
if asbool(skip_authn):
return _AuthenticationForgerMiddleware(app, **who_args)
else:
return PluggableAuthenticationMiddleware(app, **who_args)
def _cached_call(func,
args,
kwargs,
namespace,
cache_key,
expire="never",
type=None,
starttime=None,
cache_headers=('content-type', 'content-length'),
cache_response=True,
cache_extra_args=None):
"""
Optional arguments:
``key_func``
Function used to genereate the cache key, the function name
and class will be used as the base for the cache key. If None
the ``func`` itself will be used. It's usually handy when
creating caches for decorated functions, for which we want the
cache key to be generated on the decorated function and not on
the decorator.
``key_dict``
Arguments used to generate the cache key, only the arguments
listed into this dictionary will be used to generate the
cache key together with the key_func.
``expire``
Time in seconds before cache expires, or the string "never".
Defaults to "never"
``type``
Type of cache to use: dbm, memory, file, memcached, or None for
Beaker's default
``cache_headers``
A tuple of header names indicating response headers that
will also be cached.
``invalidate_on_startup``
If True, the cache will be invalidated each time the application
starts or is restarted.
``cache_response``
Determines whether the response at the time beaker_cache is used
should be cached or not, defaults to True.
.. note::
When cache_response is set to False, the cache_headers
argument is ignored as none of the response is cached.
If cache.enabled is set to False in the .ini file, then cache is
disabled globally.
"""
tg_locals = tg.request.environ['tg.locals']
enabled = asbool(tg_locals.config.get("cache.enabled", True))
if not enabled:
return func(*args, **kwargs)
cache_extra_args = cache_extra_args or {}
if type:
cache_extra_args['type'] = type
cache_obj = getattr(tg_locals, 'cache', None)
if not cache_obj: # pragma: no cover
raise Exception(
'TurboGears Cache object not found, ensure cache.enabled=True')
my_cache = cache_obj.get_cache(namespace, **cache_extra_args)
if expire == "never":
cache_expire = None
else:
cache_expire = expire
def create_func():
result = func(*args, **kwargs)
glob_response = tg_locals.response
headers = glob_response.headerlist
status = glob_response.status
full_response = dict(headers=headers,
status=status,
cookies=None,
content=result)
return full_response
response = my_cache.get_value(cache_key,
createfunc=create_func,
expiretime=cache_expire,
starttime=starttime)
if cache_response:
glob_response = tg_locals.response
glob_response.headerlist = [
header for header in response['headers']
if header[0].lower() in cache_headers
]
glob_response.status = response['status']
return response['content']
def test_asbool_broken(self):
asbool('Test')
def _cached_call(func, args, kwargs, key_func, key_dict,
expire="never", type=None, starttime=None,
cache_headers=('content-type', 'content-length'),
cache_response=True, cache_extra_args=None):
"""
Optional arguments:
``key_func``
Function used to genereate the cache key, the function name
and class will be used as the base for the cache key. If None
the ``func`` itself will be used. It's usually handy when
creating caches for decorated functions, for which we want the
cache key to be generated on the decorated function and not on
the decorator.
``key_dict``
Arguments used to generate the cache key, only the arguments
listed into this dictionary will be used to generate the
cache key together with the key_func.
``expire``
Time in seconds before cache expires, or the string "never".
Defaults to "never"
``type``
Type of cache to use: dbm, memory, file, memcached, or None for
Beaker's default
``cache_headers``
A tuple of header names indicating response headers that
will also be cached.
``invalidate_on_startup``
If True, the cache will be invalidated each time the application
starts or is restarted.
``cache_response``
Determines whether the response at the time beaker_cache is used
should be cached or not, defaults to True.
.. note::
When cache_response is set to False, the cache_headers
argument is ignored as none of the response is cached.
If cache.enabled is set to False in the .ini file, then cache is
disabled globally.
"""
tg_locals = tg.request.environ['tg.locals']
enabled = asbool(tg_locals.config.get("cache.enabled", True))
if not enabled:
return func(*args, **kwargs)
cache_extra_args = cache_extra_args or {}
self = None
if args:
self = args[0]
namespace, cache_key = create_cache_key(key_func, key_dict, self)
if type:
cache_extra_args['type'] = type
cache_obj = getattr(tg_locals, 'cache', None)
if not cache_obj: # pragma: no cover
raise Exception('TurboGears Cache object not found, ensure cache.enabled=True')
my_cache = cache_obj.get_cache(namespace, **cache_extra_args)
if expire == "never":
cache_expire = None
else:
cache_expire = expire
def create_func():
result = func(*args, **kwargs)
glob_response = tg_locals.response
headers = glob_response.headerlist
status = glob_response.status
full_response = dict(headers=headers, status=status,
cookies=None, content=result)
return full_response
response = my_cache.get_value(cache_key,
createfunc=create_func,
expiretime=cache_expire,
starttime=starttime)
if cache_response:
glob_response = tg_locals.response
glob_response.headerlist = [header for header in response['headers']
if header[0].lower() in cache_headers]
glob_response.status = response['status']
return response['content']
def test_asbool_broken(self):
asbool('Test')
def setup_auth(app, form_plugin=None, form_identifies=True,
cookie_secret='secret', cookie_name='authtkt',
login_url='/login', login_handler='/login_handler',
post_login_url=None, logout_handler='/logout_handler',
post_logout_url=None, login_counter_name=None,
cookie_timeout=None, cookie_reissue_time=None,
**who_args):
"""
Sets :mod:`repoze.who` up with the provided authenticators and
options to create FriendlyFormPlugin/FastFormPlugin.
It returns a middleware that provides identification,
authentication and authorization in a way that is compatible
with repoze.who and repoze.what.
"""
if 'charset' in who_args: #pragma: no cover
log.warn('charset argument in authentication setup is ignored')
who_args.pop('charset')
# If no identifiers are provided in repoze setup arguments
# then create a default one using AuthTktCookiePlugin.
if 'identifiers' not in who_args:
from repoze.who.plugins.auth_tkt import AuthTktCookiePlugin
cookie = AuthTktCookiePlugin(cookie_secret, cookie_name,
timeout=cookie_timeout,
reissue_time=cookie_reissue_time)
who_args['identifiers'] = [('cookie', cookie)]
who_args['authenticators'].insert(0, ('cookie', cookie))
# If no form plugin is provided then create a default
# one using the provided options.
if form_plugin is None:
from tg.configuration.auth.fastform import FastFormPlugin
form = FastFormPlugin(login_url, login_handler, post_login_url,
logout_handler, post_logout_url,
rememberer_name='cookie',
login_counter_name=login_counter_name)
else:
form = form_plugin
if form_identifies:
who_args['identifiers'].insert(0, ('main_identifier', form))
# Setting the repoze.who challengers:
if 'challengers' not in who_args:
who_args['challengers'] = []
who_args['challengers'].append(('form', form))
# Including logging
log_file = who_args.pop('log_file', None)
if log_file is not None:
if log_file.lower() == 'stdout':
log_stream = sys.stdout
elif log_file.lower() == 'stderr':
log_stream = sys.stderr
else:
log_stream = open(log_file, 'wb')
who_args['log_stream'] = log_stream
log_level = who_args.get('log_level', None)
if log_level is None:
log_level = logging.INFO
else:
log_level = _LEVELS[log_level.lower()]
who_args['log_level'] = log_level
# Setting up the metadata provider for the user information
if 'mdproviders' not in who_args:
who_args['mdproviders'] = []
# Set up default classifier
if 'classifier' not in who_args:
who_args['classifier'] = default_request_classifier
# Set up default challenger decider
if 'challenge_decider' not in who_args:
who_args['challenge_decider'] = turbogears_challenge_decider
skip_authn = who_args.pop('skip_authentication', False)
if asbool(skip_authn):
return _AuthenticationForgerMiddleware(app, **who_args)
else:
return PluggableAuthenticationMiddleware(app, **who_args)
