X-Git-Url: https://vcs.fsf.org/?a=blobdiff_plain;f=mediagoblin%2Fapp.py;h=3a2d00f0663ad0d8f904015d0161fe8968e926d7;hb=dc0b39b74741e7f4a7ba975c7ee98953bbf38816;hp=0f25a4e517b67a8b3ef050bc71bea51614164b7e;hpb=b43b17fc2686f5524413a66f8e98f3ab0cc11a60;p=mediagoblin.git diff --git a/mediagoblin/app.py b/mediagoblin/app.py index 0f25a4e5..3a2d00f0 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,19 +15,28 @@ # along with this program. If not, see . import os -import urllib +import logging -import routes -from webob import Request, exc +from mediagoblin.routing import url_map, view_functions, add_route -from mediagoblin import routing, middleware -from mediagoblin.tools import common, translate, template, response +from werkzeug.wrappers import Request +from werkzeug.exceptions import HTTPException, NotFound + +from mediagoblin import meddleware, __version__ +from mediagoblin.tools import common, translate, template +from mediagoblin.tools.response import render_404 +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) +from mediagoblin.tools.pluginapi import PluginManager + + +_log = logging.getLogger(__name__) class MediaGoblinApp(object): @@ -46,6 +55,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 ############## @@ -57,18 +68,33 @@ class MediaGoblinApp(object): # Setup other connections / useful objects ########################################## + # 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() + # 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('user_template_path')) + 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 = url_map + + for route in PluginManager().get_routes(): + _log.debug('adding plugin route: {0}'.format(route)) + add_route(*route) # set up staticdirector tool self.staticdirector = get_staticdirector(app_config) @@ -78,7 +104,7 @@ class MediaGoblinApp(object): # 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) @@ -93,79 +119,134 @@ class MediaGoblinApp(object): # object. ####################################################### - setup_globals(app = self) + setup_globals(app=self) # Workbench *currently* only used by celery, so this only # matters in always eager mode :) setup_workbench() - # instantiate application middleware - self.middleware = [common.import_component(m)(self) - for m in middleware.ENABLED_MIDDLEWARE] - + # instantiate application meddleware + 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) - # pass the request through our middleware classes - for m in self.middleware: - response = m.process_request(request) - if response is not None: - return response(environ, start_response) + ## Compatibility webob -> werkzeug + request.GET = request.args + request.accept_language = request.accept_languages + request.accept = request.accept_mimetypes ## 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 + # path inside mediagoblin. If the something needs the + # 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 + # 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'] # 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 + 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 response.render_404(request)(environ, start_response) - - controller = common.import_component(route_match['controller']) + try: + endpoint, url_values = map_adapter.match() + request.matchdict = url_values + except NotFound as exc: + return render_404(request)(environ, start_response) + except HTTPException as exc: + # Support legacy webob.exc responses + return exc(environ, start_response) + + view_func = view_functions[endpoint] + + _log.debug('endpoint: {0} view_func: {1}'.format( + endpoint, + view_func)) + + # import the endpoint, or if it's already a callable, call that + if isinstance(view_func, unicode) \ + or isinstance(view_func, str): + controller = common.import_component(view_func) + else: + controller = view_func + + # 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) + request.start_response = start_response # get the response from the controller response = controller(request) - # pass the response through the middleware - for m in self.middleware[::-1]: + # pass the response through the meddleware + for m in self.meddleware[::-1]: m.process_response(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): - mgoblin_app = MediaGoblinApp(app_config['config']) + configs = app_config['config'].split() + mediagoblin_config = None + for config in configs: + if os.path.exists(config) and os.access(config, os.R_OK): + mediagoblin_config = config + break + + if not mediagoblin_config: + raise IOError("Usable mediagoblin config not found.") + + mgoblin_app = MediaGoblinApp(mediagoblin_config) return mgoblin_app