X-Git-Url: https://vcs.fsf.org/?a=blobdiff_plain;f=mediagoblin%2Fapp.py;h=51f5899a0538be7bf42417fd65b4c94798475302;hb=88a9662be4f97da5b04a3842c8d0caa2652be355;hp=6d6346d2ffa5d540a8c56b7bfe436d9eaccffafa;hpb=cca5d55d40fe5b4f097e015c72cbd8e6c4c3232a;p=mediagoblin.git diff --git a/mediagoblin/app.py b/mediagoblin/app.py index 6d6346d2..51f5899a 100644 --- a/mediagoblin/app.py +++ b/mediagoblin/app.py @@ -1,5 +1,5 @@ # GNU MediaGoblin -- federated, autonomous media hosting -# Copyright (C) 2011 Free Software Foundation, Inc +# 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 @@ -16,17 +16,26 @@ import os import urllib +import logging import routes from webob import Request, exc -from mediagoblin import routing, util, storage -from mediagoblin.db.open import setup_connection_and_db_from_config +from mediagoblin import routing, 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 import get_jinja_loader, get_staticdirector, \ - setup_global_and_app_config -from mediagoblin.workbench import WorkbenchManager +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): @@ -45,6 +54,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 ############## @@ -56,29 +67,39 @@ 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_connection_and_db_from_config( - app_config) + 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 = storage.storage_system_from_config( - app_config, 'publicstore') - self.queue_store = storage.storage_system_from_config( - app_config, 'queuestore') + self.public_store, self.queue_store = setup_storage() # set up routing - self.routing = routing.get_mapper() + self.routing = routing.get_mapper(PluginManager().get_routes()) # 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) @@ -93,27 +114,56 @@ class MediaGoblinApp(object): # object. ####################################################### - setup_globals( - # TODO: No need to set these two up as globals, we could - # just read them out of mg_globals.app_config - email_sender_address=app_config['email_sender_address'], - email_debug_mode=app_config['email_debug_mode'], + setup_globals(app=self) - # Actual, useful to everyone objects - app=self, - db_connection=self.connection, - database=self.db, - public_store=self.public_store, - queue_store=self.queue_store, - workbench_manager=WorkbenchManager(app_config['workbench_path'])) + # Workbench *currently* only used by celery, so this only + # matters in always eager mode :) + setup_workbench() - def __call__(self, environ, start_response): + # instantiate application meddleware + self.meddleware = [common.import_component(m)(self) + for m in meddleware.ENABLED_MEDDLEWARE] + + def call_backend(self, environ, start_response): request = Request(environ) - path_info = request.path_info ## Routing / controller loading stuff + path_info = request.path_info route_match = self.routing.match(path_info) + # 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_info + # 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 + + 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 @@ -129,32 +179,57 @@ class MediaGoblinApp(object): return request.get_response(redirect)(environ, start_response) # Okay, no matches. 404 time! - return exc.HTTPNotFound()(environ, start_response) + request.matchdict = {} # in case our template expects it + return render_404(request)(environ, start_response) + + # import the controller, or if it's already a callable, call that + route_controller = route_match['controller'] + if isinstance(route_controller, unicode) \ + or isinstance(route_controller, str): + controller = common.import_component(route_match['controller']) + else: + controller = route_match['controller'] + + # 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) - controller = util.import_component(route_match['controller']) request.start_response = start_response - ## 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 = util.get_locale_from_request(request) - - request.template_env = util.get_jinja_env( - self.template_loader, request.locale) - request.db = self.db - request.staticdirect = self.staticdirector + # get the response from the controller + response = controller(request) - util.setup_user_in_request(request) + # pass the response through the meddleware + for m in self.meddleware[::-1]: + m.process_response(request, response) - return controller(request)(environ, start_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