X-Git-Url: https://vcs.fsf.org/?a=blobdiff_plain;f=mediagoblin%2Fapp.py;h=345aa048dd70a36de5a18585e36de7a68a702752;hb=d61778a489f606f1bff4f01f250a0e3c4fb99e27;hp=bf0e0f13b87349546332b7fb3862503a03448736;hpb=94fadafe0908e497b9562f6e2689d83d07c5147d;p=mediagoblin.git diff --git a/mediagoblin/app.py b/mediagoblin/app.py index bf0e0f13..345aa048 100644 --- a/mediagoblin/app.py +++ b/mediagoblin/app.py @@ -16,6 +16,7 @@ import os import logging +from contextlib import contextmanager from mediagoblin.routing import get_url_map from mediagoblin.tools.routing import endpoint_to_controller @@ -23,12 +24,15 @@ from mediagoblin.tools.routing import endpoint_to_controller from werkzeug.wrappers import Request from werkzeug.exceptions import HTTPException from werkzeug.routing import RequestRedirect +from werkzeug.wsgi import SharedDataMiddleware from mediagoblin import meddleware, __version__ +from mediagoblin.db.util import check_db_up_to_date from mediagoblin.tools import common, session, translate, template from mediagoblin.tools.response import render_http_exception from mediagoblin.tools.theme import register_themes from mediagoblin.tools import request as mg_request +from mediagoblin.media_types.tools import media_type_warning from mediagoblin.mg_globals import setup_globals from mediagoblin.init.celery import setup_celery_from_config from mediagoblin.init.plugins import setup_plugins @@ -37,11 +41,27 @@ from mediagoblin.init import (get_jinja_loader, get_staticdirector, setup_storage) from mediagoblin.tools.pluginapi import PluginManager, hook_transform from mediagoblin.tools.crypto import setup_crypto +from mediagoblin.auth.tools import check_auth_enabled, no_auth_logout + +from mediagoblin.tools.transition import DISABLE_GLOBALS _log = logging.getLogger(__name__) +class Context(object): + """ + MediaGoblin context object. + + If a web request is being used, a Flask Request object is used + instead, otherwise (celery tasks, etc), attach things to this + object. + + Usually appears as "ctx" in utilities as first argument. + """ + pass + + class MediaGoblinApp(object): """ WSGI application of MediaGoblin @@ -65,9 +85,11 @@ class MediaGoblinApp(object): ############## # Open and setup the config - global_config, app_config = setup_global_and_app_config(config_path) + self.global_config, self.app_config = setup_global_and_app_config(config_path) - setup_crypto() + media_type_warning() + + setup_crypto(self.app_config) ########################################## # Setup other connections / useful objects @@ -85,18 +107,31 @@ class MediaGoblinApp(object): setup_plugins() # Set up the database - self.db = setup_database() + if DISABLE_GLOBALS: + self.db_manager = setup_database(self) + else: + self.db = setup_database(self) + + # Quit app if need to run dbupdate + ## NOTE: This is currently commented out due to session errors.. + ## We'd like to re-enable! + # check_db_up_to_date() # Register themes - self.theme_registry, self.current_theme = register_themes(app_config) + self.theme_registry, self.current_theme = register_themes(self.app_config) # Get the template environment self.template_loader = get_jinja_loader( - app_config.get('local_templates'), + self.app_config.get('local_templates'), self.current_theme, PluginManager().get_template_paths() ) + # Check if authentication plugin is enabled and respond accordingly. + self.auth = check_auth_enabled() + if not self.auth: + self.app_config['allow_comments'] = False + # Set up storage systems self.public_store, self.queue_store = setup_storage() @@ -104,16 +139,16 @@ class MediaGoblinApp(object): self.url_map = get_url_map() # set up staticdirector tool - self.staticdirector = get_staticdirector(app_config) + self.staticdirector = get_staticdirector(self.app_config) # Setup celery, if appropriate - if setup_celery and not app_config.get('celery_setup_elsewhere'): + if setup_celery and not self.app_config.get('celery_setup_elsewhere'): if os.environ.get('CELERY_ALWAYS_EAGER', 'false').lower() == 'true': setup_celery_from_config( - app_config, global_config, + self.app_config, self.global_config, force_celery_always_eager=True) else: - setup_celery_from_config(app_config, global_config) + setup_celery_from_config(self.app_config, self.global_config) ####################################################### # Insert appropriate things into mediagoblin.mg_globals @@ -121,27 +156,105 @@ class MediaGoblinApp(object): # certain properties need to be accessed globally eg from # validators, etc, which might not access to the request # object. + # + # Note, we are trying to transition this out; + # run with environment variable DISABLE_GLOBALS=true + # to work on it ####################################################### - setup_globals(app=self) + if not DISABLE_GLOBALS: + setup_globals(app=self) # Workbench *currently* only used by celery, so this only # matters in always eager mode :) - setup_workbench() + self.workbench_manager = setup_workbench() # instantiate application meddleware self.meddleware = [common.import_component(m)(self) for m in meddleware.ENABLED_MEDDLEWARE] + @contextmanager + def gen_context(self, ctx=None, **kwargs): + """ + Attach contextual information to request, or generate a context object + + This avoids global variables; various utilities and contextual + information (current translation, etc) are attached to this + object. + """ + if DISABLE_GLOBALS: + with self.db_manager.session_scope() as db: + yield self._gen_context(db, ctx) + else: + yield self._gen_context(self.db, ctx) + + def _gen_context(self, db, ctx, **kwargs): + # Set up context + # -------------- + + # Is a context provided? + if ctx is None: + ctx = Context() + + # Attach utilities + # ---------------- + + # Attach self as request.app + # Also attach a few utilities from request.app for convenience? + ctx.app = self + + ctx.db = db + + ctx.staticdirect = self.staticdirector + + # Do special things if this is a request + # -------------------------------------- + if isinstance(ctx, Request): + ctx = self._request_only_gen_context(ctx) + + return ctx + + def _request_only_gen_context(self, request): + """ + Requests get some extra stuff attached to them that's not relevant + otherwise. + """ + # Do we really want to load this via middleware? Maybe? + request.session = self.session_manager.load_session_from_cookie(request) + + request.locale = translate.get_locale_from_request(request) + + # This should be moved over for certain, but how to deal with + # request.locale? + request.template_env = template.get_jinja_env( + self, self.template_loader, request.locale) + + mg_request.setup_user_in_request(request) + + ## Routing / controller loading stuff + request.map_adapter = self.url_map.bind_to_environ(request.environ) + + def build_proxy(endpoint, **kw): + try: + qualified = kw.pop('qualified') + except KeyError: + qualified = False + + return request.map_adapter.build( + endpoint, + values=dict(**kw), + force_external=qualified) + + request.urlgen = build_proxy + + return request + def call_backend(self, environ, start_response): request = Request(environ) # Compatibility with django, use request.args preferrably request.GET = request.args - ## Routing / controller loading stuff - map_adapter = self.url_map.bind_to_environ(request.environ) - # By using fcgi, mediagoblin can run under a base path # like /mediagoblin/. request.path_info contains the # path inside mediagoblin. If the something needs the @@ -159,37 +272,16 @@ class MediaGoblinApp(object): environ.pop('HTTPS') ## Attach utilities to the request object - # Do we really want to load this via middleware? Maybe? - session_manager = self.session_manager - request.session = session_manager.load_session_from_cookie(request) - # Attach self as request.app - # Also attach a few utilities from request.app for convenience? - request.app = self + with self.gen_context(request) as request: + return self._finish_call_backend(request, environ, start_response) - request.db = self.db - request.staticdirect = self.staticdirector - - request.locale = translate.get_locale_from_request(request) - request.template_env = template.get_jinja_env( - self.template_loader, request.locale) - - def build_proxy(endpoint, **kw): - try: - qualified = kw.pop('qualified') - except KeyError: - qualified = False - - return map_adapter.build( - endpoint, - values=dict(**kw), - force_external=qualified) - - request.urlgen = build_proxy - - mg_request.setup_user_in_request(request) + def _finish_call_backend(self, request, environ, start_response): + # Log user out if authentication_disabled + no_auth_logout(request) + request.controller_name = None try: - found_rule, url_values = map_adapter.match(return_rule=True) + found_rule, url_values = request.map_adapter.match(return_rule=True) request.matchdict = url_values except RequestRedirect as response: # Deal with 301 responses eg due to missing final slash @@ -201,7 +293,11 @@ class MediaGoblinApp(object): exc.get_description(environ))(environ, start_response) controller = endpoint_to_controller(found_rule) + # Make a reference to the controller's symbolic name on the request... + # used for lazy context modification + request.controller_name = found_rule.endpoint + ## TODO: get rid of meddleware, turn it into hooks only # pass the request through our meddleware classes try: for m in self.meddleware: @@ -213,6 +309,8 @@ class MediaGoblinApp(object): request, e, e.get_description(environ))(environ, start_response) + request = hook_transform("modify_request", request) + request.start_response = start_response # get the Http response from the controller @@ -230,8 +328,9 @@ class MediaGoblinApp(object): response = render_http_exception( request, e, e.get_description(environ)) - session_manager.save_session_to_cookie(request.session, - request, response) + self.session_manager.save_session_to_cookie( + request.session, + request, response) return response(environ, start_response) @@ -242,9 +341,10 @@ class MediaGoblinApp(object): try: return self.call_backend(environ, start_response) finally: - # Reset the sql session, so that the next request - # gets a fresh session - self.db.reset_after_request() + if not DISABLE_GLOBALS: + # Reset the sql session, so that the next request + # gets a fresh session + self.db.reset_after_request() def paste_app_factory(global_config, **app_config): @@ -257,8 +357,11 @@ def paste_app_factory(global_config, **app_config): if not mediagoblin_config: raise IOError("Usable mediagoblin config not found.") + del app_config['config'] mgoblin_app = MediaGoblinApp(mediagoblin_config) + mgoblin_app.call_backend = SharedDataMiddleware(mgoblin_app.call_backend, + exports=app_config) mgoblin_app = hook_transform('wrap_wsgi', mgoblin_app) return mgoblin_app