def before_wiki():
"""
Setup environment for wiki requests, start timers.
"""
logging.debug("running before_wiki")
flaskg.clock = Clock()
flaskg.clock.start('total')
flaskg.clock.start('init')
try:
flaskg.unprotected_storage = app.storage
flaskg.user = setup_user()
flaskg.storage = protecting.ProtectingMiddleware(
app.storage, flaskg.user, app.cfg.acl_mapping)
flaskg.dicts = app.cfg.dicts()
flaskg.groups = app.cfg.groups()
flaskg.content_lang = app.cfg.language_default
flaskg.current_lang = app.cfg.language_default
setup_jinja_env()
# request.user_agent == '' if this is pytest
flaskg.add_lineno_attr = request.user_agent and flaskg.user.edit_on_doubleclick
finally:
flaskg.clock.stop('init')
def before_wiki():
"""
Setup environment for wiki requests, start timers.
"""
logging.debug("running before_wiki")
flaskg.clock = Clock()
flaskg.clock.start('total')
flaskg.clock.start('init')
try:
set_umask() # do it once per request because maybe some server
# software sets own umask
flaskg.unprotected_storage = app.unprotected_storage
try:
flaskg.user = setup_user()
except HTTPException, e:
# this makes stuff like abort(redirect(...)) work
return app.handle_http_exception(e)
flaskg.dicts = app.cfg.dicts()
flaskg.groups = app.cfg.groups()
flaskg.content_lang = app.cfg.language_default
flaskg.current_lang = app.cfg.language_default
flaskg.storage = app.storage
setup_jinja_env()
def __init__(self, request):
self.request = request
self.clock = Clock()
# This is broken - tests that need correct content_lang will fail
self.content_lang = None
self.current_lang = None
self.form = {}
self._page_headings = {}
self.result = []
def create_app_ext(flask_config_file=None, flask_config_dict=None,
moin_config_class=None, warn_default=True, **kwargs):
"""
Factory for moin wsgi apps
:param flask_config_file: a flask config file name (may have a MOINCFG class),
if not given, a config pointed to by MOINCFG env var
will be loaded (if possible).
:param flask_config_dict: a dict used to update flask config (applied after
flask_config_file was loaded [if given])
:param moin_config_class: if you give this, it'll be instantiated as app.cfg,
otherwise it'll use MOINCFG from flask config. If that
also is not there, it'll use the DefaultConfig built
into MoinMoin.
:param warn_default: emit a warning if moin falls back to its builtin default
config (maybe user forgot to specify MOINCFG?)
:param kwargs: if you give additional keyword args, the keys/values will get patched
into the moin configuration class (before its instance is created)
"""
clock = Clock()
clock.start('create_app total')
app = Flask('MoinMoin')
clock.start('create_app load config')
if flask_config_file:
app.config.from_pyfile(flask_config_file)
else:
if not app.config.from_envvar('MOINCFG', silent=True):
# no MOINCFG env variable set, try stuff in cwd:
from os import path
flask_config_file = path.abspath('wikiconfig_local.py')
if not path.exists(flask_config_file):
flask_config_file = path.abspath('wikiconfig.py')
if not path.exists(flask_config_file):
flask_config_file = None
if flask_config_file:
app.config.from_pyfile(flask_config_file)
if flask_config_dict:
app.config.update(flask_config_dict)
Config = moin_config_class
if not Config:
Config = app.config.get('MOINCFG')
if not Config:
if warn_default:
logging.warning("using builtin default configuration")
from MoinMoin.config.default import DefaultConfig as Config
for key, value in kwargs.iteritems():
setattr(Config, key, value)
if Config.secrets is None:
# reuse the secret configured for flask (which is required for sessions)
Config.secrets = app.config.get('SECRET_KEY')
app.cfg = Config()
clock.stop('create_app load config')
clock.start('create_app register')
# register converters
from werkzeug.routing import BaseConverter
class ItemNameConverter(BaseConverter):
"""Like the default :class:`UnicodeConverter`, but it also matches
slashes (except at the beginning AND end).
This is useful for wikis and similar applications::
Rule('/<itemname:wikipage>')
Rule('/<itemname:wikipage>/edit')
"""
regex = '[^/]+?(/[^/]+?)*'
weight = 200
app.url_map.converters['itemname'] = ItemNameConverter
# register modules, before/after request functions
from MoinMoin.apps.frontend import frontend
frontend.before_request(before_wiki)
frontend.teardown_request(teardown_wiki)
app.register_blueprint(frontend)
from MoinMoin.apps.admin import admin
admin.before_request(before_wiki)
admin.teardown_request(teardown_wiki)
app.register_blueprint(admin, url_prefix='/+admin')
from MoinMoin.apps.feed import feed
feed.before_request(before_wiki)
feed.teardown_request(teardown_wiki)
app.register_blueprint(feed, url_prefix='/+feed')
from MoinMoin.apps.misc import misc
misc.before_request(before_wiki)
misc.teardown_request(teardown_wiki)
app.register_blueprint(misc, url_prefix='/+misc')
from MoinMoin.apps.serve import serve
app.register_blueprint(serve, url_prefix='/+serve')
clock.stop('create_app register')
clock.start('create_app flask-cache')
cache = Cache()
cache.init_app(app)
app.cache = cache
clock.stop('create_app flask-cache')
# init storage
clock.start('create_app init backends')
init_backends(app)
clock.stop('create_app init backends')
clock.start('create_app flask-babel')
i18n_init(app)
clock.stop('create_app flask-babel')
# configure templates
clock.start('create_app flask-themes')
setup_themes(app)
if app.cfg.template_dirs:
app.jinja_env.loader = ChoiceLoader([
FileSystemLoader(app.cfg.template_dirs),
app.jinja_env.loader,
])
app.register_error_handler(403, themed_error)
clock.stop('create_app flask-themes')
clock.stop('create_app total')
del clock
return app
class BaseContext(Context):
""" Implements a basic context, that provides some common attributes.
Most attributes are lazily initialized via descriptors. """
# first the trivial attributes
action = EnvironProxy('action', lambda o: o.request.values.get('action', 'show'))
clock = EnvironProxy('clock', lambda o: Clock())
user = EnvironProxy('user', lambda o: user.User(o, auth_method='request:invalid'))
lang = EnvironProxy('lang')
content_lang = EnvironProxy('content_lang', lambda o: o.cfg.language_default)
current_lang = EnvironProxy('current_lang')
html_formatter = EnvironProxy('html_formatter', lambda o: text_html.Formatter(o))
formatter = EnvironProxy('formatter', lambda o: o.html_formatter)
page = EnvironProxy('page', None)
# now the more complex factories
def cfg(self):
if self.request.given_config is not None:
return self.request.given_config('MoinMoin._tests.wikiconfig')
try:
self.clock.start('load_multi_cfg')
cfg = multiconfig.getConfig(self.request.url)
self.clock.stop('load_multi_cfg')
return cfg
except error.NoConfigMatchedError:
raise NotFound('<p>No wiki configuration matching the URL found!</p>')
cfg = EnvironProxy(cfg)
def getText(self):
lang = self.lang
def _(text, i18n=i18n, request=self, lang=lang, **kw):
return i18n.getText(text, request, lang, **kw)
return _
getText = property(getText)
_ = getText
def isSpiderAgent(self):
""" Simple check if useragent is a spider bot. """
cfg = self.cfg
user_agent = self.http_user_agent
if user_agent and cfg.cache.ua_spiders:
return cfg.cache.ua_spiders.search(user_agent) is not None
return False
isSpiderAgent = EnvironProxy(isSpiderAgent)
def rootpage(self):
from MoinMoin.Page import RootPage
return RootPage(self)
rootpage = EnvironProxy(rootpage)
def rev(self):
try:
return int(self.values['rev'])
except:
return None
rev = EnvironProxy(rev)
def _theme(self):
self.initTheme()
return self.theme
theme = EnvironProxy('theme', _theme)
# finally some methods to act on those attributes
def setContentLanguage(self, lang):
""" Set the content language, used for the content div
Actions that generate content in the user language, like search,
should set the content direction to the user language before they
call send_title!
"""
self.content_lang = lang
self.current_lang = lang
def initTheme(self):
""" Set theme - forced theme, user theme or wiki default """
if self.cfg.theme_force:
theme_name = self.cfg.theme_default
else:
theme_name = self.user.theme_name
load_theme_fallback(self, theme_name)
def create_app_ext(flask_config_file=None,
flask_config_dict=None,
moin_config_class=None,
warn_default=True,
**kwargs):
"""
Factory for moin wsgi apps
:param flask_config_file: a flask config file name (may have a MOINCFG class),
if not given, a config pointed to by MOINCFG env var
will be loaded (if possible).
:param flask_config_dict: a dict used to update flask config (applied after
flask_config_file was loaded [if given])
:param moin_config_class: if you give this, it'll be instantiated as app.cfg,
otherwise it'll use MOINCFG from flask config. If that
also is not there, it'll use the DefaultConfig built
into MoinMoin.
:param warn_default: emit a warning if moin falls back to its builtin default
config (maybe user forgot to specify MOINCFG?)
:param kwargs: if you give additional keyword args, the keys/values will get patched
into the moin configuration class (before its instance is created)
"""
clock = Clock()
clock.start('create_app total')
app = Flask('MoinMoin')
clock.start('create_app load config')
if flask_config_file:
app.config.from_pyfile(flask_config_file)
else:
if not app.config.from_envvar('MOINCFG', silent=True):
# no MOINCFG env variable set, try stuff in cwd:
from os import path
flask_config_file = path.abspath('wikiconfig_local.py')
if not path.exists(flask_config_file):
flask_config_file = path.abspath('wikiconfig.py')
if not path.exists(flask_config_file):
flask_config_file = None
if flask_config_file:
app.config.from_pyfile(flask_config_file)
if flask_config_dict:
app.config.update(flask_config_dict)
Config = moin_config_class
if not Config:
Config = app.config.get('MOINCFG')
if not Config:
if warn_default:
logging.warning("using builtin default configuration")
from MoinMoin.config.default import DefaultConfig as Config
for key, value in kwargs.iteritems():
setattr(Config, key, value)
if Config.secrets is None:
# reuse the secret configured for flask (which is required for sessions)
Config.secrets = app.config.get('SECRET_KEY')
app.cfg = Config()
clock.stop('create_app load config')
clock.start('create_app register')
# register converters
from werkzeug.routing import BaseConverter
class ItemNameConverter(BaseConverter):
"""Like the default :class:`UnicodeConverter`, but it also matches
slashes (except at the beginning AND end).
This is useful for wikis and similar applications::
Rule('/<itemname:wikipage>')
Rule('/<itemname:wikipage>/edit')
"""
regex = '[^/]+?(/[^/]+?)*'
weight = 200
app.url_map.converters['itemname'] = ItemNameConverter
# register modules, before/after request functions
from MoinMoin.apps.frontend import frontend
frontend.before_request(before_wiki)
frontend.teardown_request(teardown_wiki)
app.register_blueprint(frontend)
from MoinMoin.apps.admin import admin
admin.before_request(before_wiki)
admin.teardown_request(teardown_wiki)
app.register_blueprint(admin, url_prefix='/+admin')
from MoinMoin.apps.feed import feed
feed.before_request(before_wiki)
feed.teardown_request(teardown_wiki)
app.register_blueprint(feed, url_prefix='/+feed')
from MoinMoin.apps.misc import misc
misc.before_request(before_wiki)
misc.teardown_request(teardown_wiki)
app.register_blueprint(misc, url_prefix='/+misc')
from MoinMoin.apps.serve import serve
app.register_blueprint(serve, url_prefix='/+serve')
clock.stop('create_app register')
clock.start('create_app flask-cache')
cache = Cache()
cache.init_app(app)
app.cache = cache
clock.stop('create_app flask-cache')
# init storage
clock.start('create_app init backends')
init_backends(app)
clock.stop('create_app init backends')
clock.start('create_app flask-babel')
i18n_init(app)
clock.stop('create_app flask-babel')
# configure templates
clock.start('create_app flask-themes')
setup_themes(app)
if app.cfg.template_dirs:
app.jinja_env.loader = ChoiceLoader([
FileSystemLoader(app.cfg.template_dirs),
app.jinja_env.loader,
])
app.register_error_handler(403, themed_error)
clock.stop('create_app flask-themes')
clock.stop('create_app total')
del clock
return app
def create_app_ext(flask_config_file=None,
flask_config_dict=None,
moin_config_class=None,
warn_default=True,
**kwargs):
"""
Factory for moin wsgi apps
@param flask_config_file: a flask config file name (may have a MOINCFG class),
if not given, a config pointed to by MOINCFG env var
will be loaded (if possible).
@param flask_config_dict: a dict used to update flask config (applied after
flask_config_file was loaded [if given])
@param moin_config_class: if you give this, it'll be instantiated as app.cfg,
otherwise it'll use MOINCFG from flask config. If that
also is not there, it'll use the DefaultConfig built
into MoinMoin.
@oaram warn_default: emit a warning if moin falls back to its builtin default
config (maybe user forgot to specify MOINCFG?)
@param **kwargs: if you give additional key/values here, they'll get patched
into the moin configuration class (before it instance is created)
"""
clock = Clock()
clock.start('create_app total')
app = Flask('MoinMoin')
clock.start('create_app load config')
if flask_config_file:
app.config.from_pyfile(flask_config_file)
else:
app.config.from_envvar('MOINCFG', silent=True)
if flask_config_dict:
app.config.update(flask_config_dict)
Config = moin_config_class
if not Config:
Config = app.config.get('MOINCFG')
if not Config:
if warn_default:
logging.warning("using builtin default configuration")
from MoinMoin.config.default import DefaultConfig as Config
for key, value in kwargs.iteritems():
setattr(Config, key, value)
if Config.secrets is None:
# reuse the secret configured for flask (which is required for sessions)
Config.secrets = app.config.get('SECRET_KEY')
app.cfg = Config()
clock.stop('create_app load config')
clock.start('create_app register')
# register converters
from werkzeug.routing import PathConverter
app.url_map.converters['itemname'] = PathConverter
# register modules, before/after request functions
from MoinMoin.apps.frontend import frontend
frontend.before_request(before_wiki)
frontend.after_request(after_wiki)
app.register_module(frontend)
from MoinMoin.apps.admin import admin
admin.before_request(before_wiki)
admin.after_request(after_wiki)
app.register_module(admin, url_prefix='/+admin')
from MoinMoin.apps.feed import feed
feed.before_request(before_wiki)
feed.after_request(after_wiki)
app.register_module(feed, url_prefix='/+feed')
from MoinMoin.apps.misc import misc
misc.before_request(before_wiki)
misc.after_request(after_wiki)
app.register_module(misc, url_prefix='/+misc')
from MoinMoin.apps.serve import serve
app.register_module(serve, url_prefix='/+serve')
clock.stop('create_app register')
clock.start('create_app flask-cache')
cache = Cache()
cache.init_app(app)
app.cache = cache
clock.stop('create_app flask-cache')
# init storage
clock.start('create_app init backends')
app.unprotected_storage, app.storage = init_backends(app)
clock.stop('create_app init backends')
clock.start('create_app index rebuild')
if app.cfg.index_rebuild:
app.unprotected_storage.index_rebuild() # XXX run this from a script
clock.stop('create_app index rebuild')
clock.start('create_app load/save xml')
import_export_xml(app)
clock.stop('create_app load/save xml')
clock.start('create_app flask-babel')
i18n_init(app)
clock.stop('create_app flask-babel')
# configure templates
clock.start('create_app flask-themes')
setup_themes(app)
if app.cfg.template_dirs:
app.jinja_env.loader = ChoiceLoader([
FileSystemLoader(app.cfg.template_dirs),
app.jinja_env.loader,
])
app.error_handlers[403] = themed_error
clock.stop('create_app flask-themes')
clock.stop('create_app total')
del clock
return app