diff --git a/bolt/exceptions.py b/bolt/exceptions.py index d4354b388e..9c85a485e8 100644 --- a/bolt/exceptions.py +++ b/bolt/exceptions.py @@ -109,12 +109,6 @@ class ViewDoesNotExist(Exception): pass -class MiddlewareNotUsed(Exception): - """This middleware is not used in this server configuration""" - - pass - - class ImproperlyConfigured(Exception): """Bolt is somehow improperly configured""" diff --git a/bolt/internal/handlers/base.py b/bolt/internal/handlers/base.py index 0fa3fad91a..935fc12909 100644 --- a/bolt/internal/handlers/base.py +++ b/bolt/internal/handlers/base.py @@ -1,7 +1,7 @@ import logging import types -from bolt.exceptions import ImproperlyConfigured, MiddlewareNotUsed +from bolt.exceptions import ImproperlyConfigured from bolt.logs import log_response from bolt.runtime import settings from bolt.signals import request_finished @@ -15,7 +15,6 @@ class BaseHandler: _view_middleware = None - _exception_middleware = None _middleware_chain = None def load_middleware(self): @@ -25,29 +24,12 @@ def load_middleware(self): Must be called after the environment is fixed (see __call__ in subclasses). """ self._view_middleware = [] - self._exception_middleware = [] get_response = self._get_response handler = convert_exception_to_response(get_response) for middleware_path in reversed(settings.MIDDLEWARE): middleware = import_string(middleware_path) - try: - # Adapt handler, if needed. - adapted_handler = self.adapt_method_mode( - handler, - debug=settings.DEBUG, - name="middleware %s" % middleware_path, - ) - mw_instance = middleware(adapted_handler) - except MiddlewareNotUsed as exc: - if settings.DEBUG: - if str(exc): - logger.debug("MiddlewareNotUsed(%r): %s", middleware_path, exc) - else: - logger.debug("MiddlewareNotUsed: %r", middleware_path) - continue - else: - handler = adapted_handler + mw_instance = middleware(handler) if mw_instance is None: raise ImproperlyConfigured( @@ -57,42 +39,15 @@ def load_middleware(self): if hasattr(mw_instance, "process_view"): self._view_middleware.insert( 0, - self.adapt_method_mode(mw_instance.process_view), - ) - if hasattr(mw_instance, "process_exception"): - # The exception-handling stack is still always synchronous for - # now, so adapt that way. - self._exception_middleware.append( - self.adapt_method_mode(False, mw_instance.process_exception), + mw_instance.process_view, ) handler = convert_exception_to_response(mw_instance) - # Adapt the top of the stack, if needed. - handler = self.adapt_method_mode(handler) # We only assign to this when initialization is complete as it is used # as a flag for initialization being complete. self._middleware_chain = handler - def adapt_method_mode( - self, - method, - debug=False, - name=None, - ): - """ - Adapt a method to be in the correct "mode": - - If is_async is False: - - Synchronous methods are left alone - - Asynchronous methods are wrapped with async_to_sync - - If is_async is True: - - Synchronous methods are wrapped with sync_to_async() - - Asynchronous methods are left alone - """ - if debug and not name: - name = name or "method %s()" % method.__qualname__ - return method - def get_response(self, request): """Return an HttpResponse object for the given HttpRequest.""" # Setup default url resolver for this thread @@ -128,13 +83,7 @@ def _get_response(self, request): if response is None: wrapped_callback = self.make_view_atomic(callback) - - try: - response = wrapped_callback(request, *callback_args, **callback_kwargs) - except Exception as e: - response = self.process_exception_by_middleware(e, request) - if response is None: - raise + response = wrapped_callback(request, *callback_args, **callback_kwargs) # Complain if the view returned None (a common error). self.check_response(response, callback) @@ -189,17 +138,6 @@ def make_view_atomic(self, view): view = transaction.atomic(using=alias)(view) return view - def process_exception_by_middleware(self, exception, request): - """ - Pass the exception to the exception middleware. If no middleware - return a response for this exception, return None. - """ - for middleware_method in self._exception_middleware: - response = middleware_method(request, exception) - if response: - return response - return None - def reset_urlconf(sender, **kwargs): """Reset the URLconf after each request is finished.""" diff --git a/bolt/utils/decorators.py b/bolt/utils/decorators.py index bf704a296b..bafeb2a370 100644 --- a/bolt/utils/decorators.py +++ b/bolt/utils/decorators.py @@ -88,46 +88,3 @@ def _dec(obj): obj = decorator if hasattr(decorator, "__name__") else decorator.__class__ _dec.__name__ = "method_decorator(%s)" % obj.__name__ return _dec - - -def decorator_from_middleware(middleware_class): - """ - Given a middleware class (not an instance), return a view decorator. This - lets you use middleware functionality on a per-view basis. The middleware - is created with no params passed. - """ - return make_middleware_decorator(middleware_class)() - - -def make_middleware_decorator(middleware_class): - def _make_decorator(*m_args, **m_kwargs): - def _decorator(view_func): - middleware = middleware_class(view_func, *m_args, **m_kwargs) - - @wraps(view_func) - def _wrapper_view(request, *args, **kwargs): - if hasattr(middleware, "process_request"): - result = middleware.process_request(request) - if result is not None: - return result - if hasattr(middleware, "process_view"): - result = middleware.process_view(request, view_func, args, kwargs) - if result is not None: - return result - try: - response = view_func(request, *args, **kwargs) - except Exception as e: - if hasattr(middleware, "process_exception"): - result = middleware.process_exception(request, e) - if result is not None: - return result - raise - if hasattr(middleware, "process_response"): - return middleware.process_response(request, response) - return response - - return _wrapper_view - - return _decorator - - return _make_decorator