Commit: 2f8d060ff4313f707506c8043e392afe141ff380 - allura (git)

allura

Commit MetaInfo

• Revisión: 2f8d060ff4313f707506c8043e392afe141ff380 (tree)
• Tiempo: 2011-04-30 02:07:36
• Autor: Rick Copeland <rcopeland@geek...>
• Commiter: Rick Copeland

Log Message

[#1831] Remove pylons-isms

Signed-off-by: Rick Copeland <[e-mail]>

Cambiar Resumen

• delete: Allura/allura/config/app_cfg.py
• delete: Allura/allura/config/deployment.ini
• delete: Allura/allura/config/environment.py
• delete: Allura/allura/config/middleware.py

Diferencia incremental

--- a/Allura/allura/config/app_cfg.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Global configuration file for TG2-specific settings in allura.
-
-This file complements development/deployment.ini.
-
-Please note that **all the argument values are strings**. If you want to
-convert them into boolean, for example, you should use the
-:func:`paste.deploy.converters.asbool` function, as in::
-    
-    from paste.deploy.converters import asbool
-    setting = asbool(global_conf.get('the_setting'))
- 
-"""
-import pdb; pdb.set_trace()
-import logging
-import pkg_resources
-
-import tg
-import jinja2
-from tg.configuration import AppConfig, config
-from routes import Mapper
-from webhelpers.html import literal
-
-import ew
-
-import allura
-# needed for tg.configuration to work
-from allura.lib import app_globals
-
-log = logging.getLogger(__name__)
-
-class ForgeConfig(AppConfig):
-
-    def __init__(self, root_controller='root'):
-        AppConfig.__init__(self)
-        self.root_controller = root_controller
-        self.package = allura
-        self.renderers = [ 'json', 'genshi', 'mako', 'jinja' ]
-        self.default_renderer = 'genshi'
-        self.use_sqlalchemy = False
-        self.use_toscawidgets = True
-        self.use_transaction_manager = False
-        # self.handle_status_codes = [ 403, 404 ]
-        self.handle_status_codes = [ 403, 404 ]
-
-    def after_init_config(self):
-        config['pylons.strict_c'] = True
-
-    def setup_routes(self):
-        map = Mapper(directory=config['pylons.paths']['controllers'],
-                     always_scan=config['debug'])
-        # Setup a default route for the root of object dispatch
-        map.connect('*url', controller=self.root_controller,
-                    action='routes_placeholder')
-        config['routes.map'] = map
-
-    def setup_jinja_renderer(self):
-        config['pylons.app_globals'].jinja2_env = jinja2.Environment(
-            loader=PackagePathLoader(),
-            auto_reload=self.auto_reload_templates,
-            autoescape=True,
-            extensions=['jinja2.ext.do'])
-        # Jinja's unable to request c's attributes without strict_c
-        config['pylons.strict_c'] = True
-        self.render_functions.jinja = tg.render.render_jinja
-
-class JinjaEngine(ew.TemplateEngine):
-
-    @property
-    def _environ(self):
-        return config['pylons.app_globals'].jinja2_env
-
-    def load(self, template_name):
-        try:
-            return self._environ.get_template(template_name)
-        except jinja2.TemplateNotFound:
-            raise ew.errors.TemplateNotFound, '%s not found' % template_name
-
-    def parse(self, template_text, filepath=None):
-        return self._environ.from_string(template_text)
-
-    def render(self, template, context):
-        context = self.context(context)
-        with ew.utils.push_context(ew.widget_context, render_context=context):
-            text = template.render(**context)
-            return literal(text)
-
-class PackagePathLoader(jinja2.BaseLoader):
-
-    def __init__(self):
-        self.fs_loader = jinja2.FileSystemLoader(['/'])
-
-    def get_source(self, environment, template):
-        package, path = template.split(':')
-        filename = pkg_resources.resource_filename(package, path)
-        return self.fs_loader.get_source(environment, filename)
-
-
-base_config = ForgeConfig()

--- a/Allura/allura/config/deployment.ini
+++ /dev/null
@@ -1,88 +0,0 @@
-#
-# allura - TurboGears configuration
-#
-# The %(here)s variable will be replaced with the parent directory of this file
-#
-[DEFAULT]
-# WARGING == If debug is not set to false, you'll get the interactive
-# debugger on production, which is a huge security hole. 
-
-debug = false
-email_to = [e-mail]
-smtp_server = localhost
-error_email_from = paste@localhost
-
-[server:main]
-use = egg:Paste#http
-host = 0.0.0.0
-port = 8080
-
-[app:main]
-use = egg:Allura
-full_stack = true
-cache_dir = %(here)s/data
-beaker.session.key = allura
-beaker.session.secret = ${app_instance_secret}
-app_instance_uuid = ${app_instance_uuid}
-
-# If you'd like to fine-tune the individual locations of the cache data dirs
-# for the Cache data, or the Session saves, un-comment the desired settings
-# here:
-#beaker.cache.data_dir = %(here)s/data/cache
-#beaker.session.data_dir = %(here)s/data/sessions
-# Specify the database for SQLAlchemy to use via
-# turbogears.database
-# %(here) may include a ':' character on Windows environments; this can
-# invalidate the URI when specifying a SQLite db via path name
-sqlalchemy.url = sqlite:///%(here)s/somedb.db
-sqlalchemy.echo = False
-
-# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*
-# Debug mode will enable the interactive debugging tool, allowing ANYONE to
-# execute malicious code after an exception is raised.
-#set debug = false
-
-# Logging configuration
-# Add additional loggers, handlers, formatters here
-# Uses python's logging config file format
-# http://docs.python.org/lib/logging-config-fileformat.html
-
-[loggers]
-keys = root, allura, sqlalchemy
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-# If you create additional loggers, add them as a key to [loggers]
-[logger_root]
-level = INFO
-handlers = console
-
-[logger_allura]
-level = INFO
-handlers =
-qualname = allura
-
-[logger_sqlalchemy]
-level = WARN
-handlers =
-qualname = sqlalchemy.engine
-# "level = INFO" logs SQL queries.
-# "level = DEBUG" logs SQL queries and results.
-# "level = WARN" logs neither.  (Recommended for production systems.)
-
-
-# If you create additional handlers, add them as a key to [handlers]
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-# If you create additional formatters, add them as a key to [formatters]
-[formatter_generic]
-format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S

--- a/Allura/allura/config/environment.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# -*- coding: utf-8 -*-
-"""WSGI environment setup for allura."""
-
-from allura.config.app_cfg import base_config
-
-__all__ = ['load_environment']
-
-#Use base_config to setup the environment loader function
-load_environment = base_config.make_load_environment()
-

--- a/Allura/allura/config/middleware.py
+++ /dev/null
@@ -1,172 +0,0 @@
-# -*- coding: utf-8 -*-
-"""WSGI middleware initialization for the allura application."""
-import mimetypes
-
-import tg
-import pkg_resources
-from tg import config
-from paste.deploy.converters import asbool
-from paste.registry import RegistryManager
-from beaker.middleware import SessionMiddleware
-from routes.middleware import RoutesMiddleware
-from pylons.middleware import StatusCodeRedirect
-
-import ew
-import ming
-from ming.orm.middleware import MingMiddleware
-
-from allura.config.app_cfg import base_config
-from allura.config.environment import load_environment
-from allura.config.app_cfg import ForgeConfig
-from allura.lib.custom_middleware import StatsMiddleware
-from allura.lib.custom_middleware import SSLMiddleware
-from allura.lib.custom_middleware import StaticFilesMiddleware
-from allura.lib.custom_middleware import CSRFMiddleware
-from allura.lib.custom_middleware import LoginRedirectMiddleware
-from allura.lib import patches
-from allura.lib import helpers as h
-
-__all__ = ['make_app']
-
-# Use base_config to setup the necessary PasteDeploy application factory. 
-# make_base_app will wrap the TG2 app with all the middleware it needs. 
-make_base_app = base_config.setup_tg_wsgi_app(load_environment)
-
-
-def make_app(global_conf, full_stack=True, **app_conf):
-    root = app_conf.get('override_root', 'root')
-    return _make_core_app(root, global_conf, full_stack, **app_conf)
-
-def _make_core_app(root, global_conf, full_stack=True, **app_conf):
-    """
-    Set allura up with the settings found in the PasteDeploy configuration
-    file used.
-
-    :param root: The controller module containing the TG root
-    :param global_conf: The global settings for allura (those
-        defined under the ``[DEFAULT]`` section).
-    :type global_conf: dict
-    :param full_stack: Should the whole TG2 stack be set up?
-    :type full_stack: str or bool
-    :return: The allura application with all the relevant middleware
-        loaded.
-    
-    This is the PasteDeploy factory for the allura application.
-    
-    ``app_conf`` contains all the application-specific settings (those defined
-    under ``[app:main]``.
-    
-   
-    """
-    # Run all the initialization code here
-    mimetypes.init(
-        [pkg_resources.resource_filename('allura', 'etc/mime.types')]
-        + mimetypes.knownfiles)
-    patches.apply()
-    # Configure MongoDB
-    ming.configure(**app_conf)
-
-    # Configure EW variable provider
-    ew.render.TemplateEngine.register_variable_provider(get_tg_vars)
-    
-    # Create base app
-    base_config = ForgeConfig(root)
-    load_environment = base_config.make_load_environment()
-
-    # Code adapted from tg.configuration, replacing the following lines:
-    #     make_base_app = base_config.setup_tg_wsgi_app(load_environment)
-    #     app = make_base_app(global_conf, full_stack=True, **app_conf)
-
-    # Configure the Pylons environment
-    load_environment(global_conf, app_conf)
-
-    app = tg.TGApp()
-    if asbool(config.get('auth.method', 'local')=='sfx'):
-        import sfx.middleware
-        d = h.config_with_prefix(config, 'auth.')
-        d.update(h.config_with_prefix(config, 'sfx.'))
-        app = sfx.middleware.SfxMiddleware(app, d)
-    # Required for pylons
-    app = RoutesMiddleware(app, config['routes.map'])
-    # Required for sessions
-    app = SessionMiddleware(app, config)
-    # Converts exceptions to HTTP errors, shows traceback in debug mode
-    app = tg.error.ErrorHandler(app, global_conf, **config['pylons.errorware'])
-    # Redirect some status codes to /error/document
-    if asbool(config['debug']):
-        app = StatusCodeRedirect(app, base_config.handle_status_codes)
-    else:
-        app = StatusCodeRedirect(app, base_config.handle_status_codes + [500])
-    # Redirect 401 to the login page
-    app = LoginRedirectMiddleware(app)
-    # Add instrumentation
-    if app_conf.get('stats.sample_rate', '0.25') != '0':
-        stats_config = dict(global_conf, **app_conf)
-        app = StatsMiddleware(app, stats_config)
-    # Clear cookies when the CSRF field isn't posted
-    if not app_conf.get('disable_csrf_protection'):
-        app = CSRFMiddleware(app, '_session_id')
-    # Setup the allura SOPs
-    app = allura_globals_middleware(app)
-    # Ensure https for logged in users, http for anonymous ones
-    if asbool(app_conf.get('auth.method', 'local')=='sfx'):
-        app = SSLMiddleware(app, app_conf.get('no_redirect.pattern'))
-    # Setup resource manager, widget context SOP
-    app = ew.WidgetMiddleware(
-        app,
-        compress=not asbool(global_conf['debug']),
-        # compress=True,
-        script_name=app_conf.get('ew.script_name', '/_ew_resources/'),
-        url_base=app_conf.get('ew.url_base', '/_ew_resources/'))
-    # Make sure that the wsgi.scheme is set appropriately when we
-    # have the funky HTTP_X_SFINC_SSL  environ var
-    if asbool(app_conf.get('auth.method', 'local')=='sfx'):
-        app = set_scheme_middleware(app)
-    # Handle static files (by tool)
-    app = StaticFilesMiddleware(app, app_conf.get('static.script_name'))
-    # Handle setup and flushing of Ming ORM sessions
-    app = MingMiddleware(app)
-    # Set up the registry for stacked object proxies (SOPs).
-    #    streaming=true ensures they won't be cleaned up till
-    #    the WSGI application's iterator is exhausted
-    app = RegistryManager(app, streaming=True)
-    return app
-    
-def set_scheme_middleware(app):
-    def SchemeMiddleware(environ, start_response):
-        if asbool(environ.get('HTTP_X_SFINC_SSL', 'false')):
-            environ['wsgi.url_scheme'] = 'https'
-        return app(environ, start_response)
-    return SchemeMiddleware
-
-def allura_globals_middleware(app):
-    def AlluraGlobalsMiddleware(environ, start_response):
-        from allura import credentials
-        from allura.lib import security, app_globals
-        from tg import tg_globals
-        registry = environ['paste.registry']
-        registry.register(credentials, security.Credentials())
-        registry.register(tg_globals.environ, environ)
-        registry.register(tg_globals.c, EmptyClass())
-        registry.register(tg_globals.g, app_globals.Globals())
-        return app(environ, start_response)
-    return AlluraGlobalsMiddleware
-
-class EmptyClass(object): pass
-
-def get_tg_vars(context):
-    import pylons, tg
-    from allura.lib import helpers as h
-    from urllib import quote, quote_plus
-    context.setdefault('g', pylons.g)
-    context.setdefault('c', pylons.c)
-    context.setdefault('h', h)
-    context.setdefault('request', pylons.request)
-    context.setdefault('response', pylons.response)
-    context.setdefault('url', pylons.url)
-    context.setdefault('tg', dict(
-            config=tg.config,
-            flash_obj=tg.flash,
-            quote=quote,
-            quote_plus=quote_plus,
-            url=tg.url))