X-Git-Url: https://vcs.fsf.org/?a=blobdiff_plain;f=mediagoblin%2Fapp.py;h=0a57c09101e7db3944b59f10f594ec93aaf6fdb9;hb=ff6933fa4c63611f8e3d512d6608767cbdece6ec;hp=9454b40348f802e632a4ca25d44b79f96749c249;hpb=c0d532f04e91d97f92b06b15436140f704e8b8fe;p=mediagoblin.git

diff --git a/mediagoblin/app.py b/mediagoblin/app.py
index 9454b403..0a57c091 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,22 +16,23 @@
 
 import os
 import urllib
+import logging
 
 import routes
 from webob import Request, exc
 
-from mediagoblin import routing, util, storage, staticdirect
-from mediagoblin.init.config import (
-    read_mediagoblin_config, generate_validation_report)
-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 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
-from mediagoblin.workbench import WorkbenchManager
+from mediagoblin.init import (get_jinja_loader, get_staticdirector,
+    setup_global_and_app_config, setup_workbench, setup_database,
+    setup_storage, setup_beaker_cache)
 
 
-class Error(Exception): pass
-class ImproperlyConfigured(Error): pass
+_log = logging.getLogger(__name__)
 
 
 class MediaGoblinApp(object):
@@ -50,54 +51,36 @@ class MediaGoblinApp(object):
            (Note: setting 'celery_setup_elsewhere' also disables
            setting up celery.)
         """
+        _log.info("GNU MediaGoblin %s main server starting", __version__)
         ##############
         # Setup config
         ##############
 
         # Open and setup the config
-        global_config, validation_result = read_mediagoblin_config(config_path)
-        app_config = global_config['mediagoblin']
-        # report errors if necessary
-        validation_report = generate_validation_report(
-            global_config, validation_result)
-        if validation_report:
-            raise ImproperlyConfigured(validation_report)
+        global_config, app_config = setup_global_and_app_config(config_path)
 
         ##########################################
         # Setup other connections / useful objects
         ##########################################
 
         # Set up the database
-        self.connection, self.db = setup_connection_and_db_from_config(
-            app_config)
+        self.connection, self.db = setup_database()
 
         # Get the template environment
         self.template_loader = get_jinja_loader(
-            app_config.get('user_template_path'))
-        
+            app_config.get('local_templates'))
+
         # 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()
 
         # set up staticdirector tool
-        if app_config.has_key('direct_remote_path'):
-            self.staticdirector = staticdirect.RemoteStaticDirect(
-                app_config['direct_remote_path'].strip())
-        elif app_config.has_key('direct_remote_paths'):
-            direct_remote_path_lines = app_config[
-                'direct_remote_paths'].strip().splitlines()
-            self.staticdirector = staticdirect.MultiRemoteStaticDirect(
-                dict([line.strip().split(' ', 1)
-                      for line in direct_remote_path_lines]))
-        else:
-            raise ImproperlyConfigured(
-                "One of direct_remote_path or "
-                "direct_remote_paths must be provided")
+        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'):
@@ -116,30 +99,56 @@ class MediaGoblinApp(object):
         # object.
         #######################################################
 
-        setup_globals(
-            app_config=app_config,
-            global_config=global_config,
+        setup_globals(app=self)
 
-            # 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'],
+        # Workbench *currently* only used by celery, so this only
+        # matters in always eager mode :)
+        setup_workbench()
 
-            # 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']))
+        # instantiate application meddleware
+        self.meddleware = [common.import_component(m)(self)
+                           for m in meddleware.ENABLED_MEDDLEWARE]
 
     def __call__(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
@@ -155,32 +164,48 @@ 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)
+
+        controller = common.import_component(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)
+
+        # pass the response through the meddleware
+        for m in self.meddleware[::-1]:
+            m.process_response(request, response)
 
-        util.setup_user_in_request(request)
+        # Reset the sql session, so that the next request
+        # gets a fresh session
+        try:
+            self.db.reset_after_request()
+        except TypeError:
+            # We're still on mongo
+            pass
 
-        return controller(request)(environ, start_response)
+        return response(environ, start_response)
 
 
 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