X-Git-Url: https://vcs.fsf.org/?a=blobdiff_plain;f=mediagoblin%2Fapp.py;h=580583607f32f2ca3bd7558993ec5900f469ebf2;hb=6331e927e47afb937bfde503864b164d49b05abd;hp=04eb2acc8fa2de3efb1f0c85adea3f02710aa1dd;hpb=ea5a5b15a3d552eaefc4cf220ed155af06f7c8f7;p=mediagoblin.git diff --git a/mediagoblin/app.py b/mediagoblin/app.py index 04eb2acc..58058360 100644 --- a/mediagoblin/app.py +++ b/mediagoblin/app.py @@ -1,5 +1,5 @@ # GNU MediaGoblin -- federated, autonomous media hosting -# Copyright (C) 2011 MediaGoblin contributors. See AUTHORS. +# Copyright (C) 2011, 2012 MediaGoblin contributors. See AUTHORS. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by @@ -15,20 +15,32 @@ # along with this program. If not, see . import os -import urllib +import logging -import routes -from webob import Request, exc +from mediagoblin.routing import get_url_map +from mediagoblin.tools.routing import endpoint_to_controller -from mediagoblin import routing, meddleware -from mediagoblin.tools import common, translate, template -from mediagoblin.tools.response import render_404 +from werkzeug.wrappers import Request +from werkzeug.exceptions import HTTPException +from werkzeug.routing import RequestRedirect + +from mediagoblin import meddleware, __version__ +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.mg_globals import setup_globals from mediagoblin.init.celery import setup_celery_from_config +from mediagoblin.init.plugins import setup_plugins from mediagoblin.init import (get_jinja_loader, get_staticdirector, - setup_global_and_app_config, setup_workbench, setup_database, - setup_storage, setup_beaker_cache) + setup_global_and_app_config, setup_locales, setup_workbench, setup_database, + setup_storage) +from mediagoblin.tools.pluginapi import PluginManager, hook_transform +from mediagoblin.tools.crypto import setup_crypto +from mediagoblin import notifications + + +_log = logging.getLogger(__name__) class MediaGoblinApp(object): @@ -47,6 +59,8 @@ class MediaGoblinApp(object): (Note: setting 'celery_setup_elsewhere' also disables setting up celery.) """ + _log.info("GNU MediaGoblin %s main server starting", __version__) + _log.debug("Using config file %s", config_path) ############## # Setup config ############## @@ -54,32 +68,48 @@ class MediaGoblinApp(object): # Open and setup the config global_config, app_config = setup_global_and_app_config(config_path) + setup_crypto() + ########################################## # Setup other connections / useful objects ########################################## + # Setup Session Manager, not needed in celery + self.session_manager = session.SessionManager() + + # load all available locales + setup_locales() + + # Set up plugins -- need to do this early so that plugins can + # affect startup. + _log.info("Setting up plugins.") + setup_plugins() + # Set up the database - self.connection, self.db = setup_database() + self.db = setup_database() + + # Register themes + self.theme_registry, self.current_theme = register_themes(app_config) # Get the template environment self.template_loader = get_jinja_loader( - app_config.get('local_templates')) + app_config.get('local_templates'), + self.current_theme, + PluginManager().get_template_paths() + ) # Set up storage systems self.public_store, self.queue_store = setup_storage() # set up routing - self.routing = routing.get_mapper() + self.url_map = get_url_map() # set up staticdirector tool self.staticdirector = get_staticdirector(app_config) - # set up caching - self.cache = setup_beaker_cache() - # Setup celery, if appropriate if setup_celery and not app_config.get('celery_setup_elsewhere'): - if os.environ.get('CELERY_ALWAYS_EAGER'): + if os.environ.get('CELERY_ALWAYS_EAGER', 'false').lower() == 'true': setup_celery_from_config( app_config, global_config, force_celery_always_eager=True) @@ -104,12 +134,14 @@ class MediaGoblinApp(object): self.meddleware = [common.import_component(m)(self) for m in meddleware.ENABLED_MEDDLEWARE] - def __call__(self, environ, start_response): + 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 - path_info = request.path_info - route_match = self.routing.match(path_info) + 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 @@ -117,65 +149,110 @@ class MediaGoblinApp(object): # full path of the current page, that should include # the basepath. # Note: urlgen and routes are fine! - request.full_path = environ["SCRIPT_NAME"] + request.path_info + request.full_path = environ["SCRIPT_NAME"] + request.path # python-routes uses SCRIPT_NAME. So let's use that too. # The other option would be: # request.full_path = environ["SCRIPT_URL"] + # Fix up environ for urlgen + # See bug: https://bitbucket.org/bbangert/routes/issue/55/cache_hostinfo-breaks-on-https-off + if environ.get('HTTPS', '').lower() == 'off': + environ.pop('HTTPS') + ## Attach utilities to the request object - request.matchdict = route_match - request.urlgen = routes.URLGenerator(self.routing, environ) # Do we really want to load this via middleware? Maybe? - request.session = request.environ['beaker.session'] + 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 - request.locale = translate.get_locale_from_request(request) - request.template_env = template.get_jinja_env( - self.template_loader, request.locale) 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 + + request.notifications = notifications + mg_request.setup_user_in_request(request) - # No matching page? - if route_match is None: - # Try to do see if we have a match with a trailing slash - # added and if so, redirect - if not path_info.endswith('/') \ - and request.method == 'GET' \ - and self.routing.match(path_info + '/'): - new_path_info = path_info + '/' - if request.GET: - new_path_info = '%s?%s' % ( - new_path_info, urllib.urlencode(request.GET)) - redirect = exc.HTTPFound(location=new_path_info) - return request.get_response(redirect)(environ, start_response) - - # Okay, no matches. 404 time! - request.matchdict = {} # in case our template expects it - return render_404(request)(environ, start_response) - - controller = common.import_component(route_match['controller']) + request.controller_name = None + try: + found_rule, url_values = map_adapter.match(return_rule=True) + request.matchdict = url_values + except RequestRedirect as response: + # Deal with 301 responses eg due to missing final slash + return response(environ, start_response) + except HTTPException as exc: + # Stop and render exception + return render_http_exception( + request, exc, + 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 # pass the request through our meddleware classes - for m in self.meddleware: - response = m.process_request(request, controller) - if response is not None: - return response(environ, start_response) + try: + for m in self.meddleware: + response = m.process_request(request, controller) + if response is not None: + return response(environ, start_response) + except HTTPException as e: + return render_http_exception( + request, e, + e.get_description(environ))(environ, start_response) request.start_response = start_response - # get the response from the controller - response = controller(request) + # get the Http response from the controller + try: + response = controller(request) + except HTTPException as e: + response = render_http_exception( + request, e, e.get_description(environ)) + + # pass the response through the meddlewares + try: + for m in self.meddleware[::-1]: + m.process_response(request, response) + except HTTPException as e: + response = render_http_exception( + request, e, e.get_description(environ)) - # pass the response through the meddleware - for m in self.meddleware[::-1]: - m.process_response(request, response) + session_manager.save_session_to_cookie(request.session, + request, response) return response(environ, start_response) + def __call__(self, environ, start_response): + ## If more errors happen that look like unclean sessions: + # self.db.check_session_clean() + + 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() + def paste_app_factory(global_config, **app_config): configs = app_config['config'].split() @@ -189,5 +266,6 @@ def paste_app_factory(global_config, **app_config): raise IOError("Usable mediagoblin config not found.") mgoblin_app = MediaGoblinApp(mediagoblin_config) + mgoblin_app = hook_transform('wrap_wsgi', mgoblin_app) return mgoblin_app