django-orchestra/orchestra/contrib/orchestration/middlewares.py

from threading import local

from django.contrib.admin.models import LogEntry
from django.db import transaction
from django.db.models.signals import m2m_changed, post_save, pre_delete
from django.dispatch import receiver
from django.http.response import HttpResponseServerError
from django.urls import resolve
from django.utils.deprecation import MiddlewareMixin
from orchestra.utils.python import OrderedSet

from . import Operation, manager
from .helpers import message_user
from .models import BackendLog, BackendOperation


@receiver(post_save, dispatch_uid='orchestration.post_save_collector')
def post_save_collector(sender, *args, **kwargs):
    if sender not in (BackendLog, BackendOperation, LogEntry):
        instance = kwargs.get('instance')
        OperationsMiddleware.collect(Operation.SAVE, **kwargs)


@receiver(pre_delete, dispatch_uid='orchestration.pre_delete_collector')
def pre_delete_collector(sender, *args, **kwargs):
    if sender not in (BackendLog, BackendOperation, LogEntry):
        OperationsMiddleware.collect(Operation.DELETE, **kwargs)


@receiver(m2m_changed, dispatch_uid='orchestration.m2m_collector')
def m2m_collector(sender, *args, **kwargs):
    # m2m relations without intermediary models are shit. Model.post_save is not sent and
    # by the time related.post_save is sent rel objects are not accessible via RelatedManager.all()
    if kwargs.pop('action') == 'post_add' and kwargs['pk_set']:
        OperationsMiddleware.collect(Operation.SAVE, **kwargs)


class OperationsMiddleware(MiddlewareMixin):
    """
    Stores all the operations derived from save and delete signals and executes them
    at the end of the request/response cycle

    It also works as a transaction middleware, making requets to run within an atomic block.
    """
    # Thread local is used because request object is not available on model signals
    thread_locals = local()

    @classmethod
    def get_pending_operations(cls):
        # Check if an error poped up before OperationsMiddleware.process_request()
        if hasattr(cls.thread_locals, 'request'):
            request = cls.thread_locals.request
            if not hasattr(request, 'pending_operations'):
                request.pending_operations = OrderedSet()
            return request.pending_operations
        return set()

    @classmethod
    def get_route_cache(cls):
        """ chache the routes to save sql queries """
        if hasattr(cls.thread_locals, 'request'):
            request = cls.thread_locals.request
            if not hasattr(request, 'route_cache'):
                request.route_cache = {}
            return request.route_cache
        return {}

    @classmethod
    def collect(cls, action, **kwargs):
        """ Collects all pending operations derived from model signals """
        request = getattr(cls.thread_locals, 'request', None)
        if request is None:
            return
        kwargs['operations'] = cls.get_pending_operations()
        kwargs['route_cache'] = cls.get_route_cache()
        instance = kwargs.pop('instance')
        manager.collect(instance, action, **kwargs)

    def enter_transaction_management(self):
        type(self).thread_locals.transaction = transaction.atomic()
        type(self).thread_locals.transaction.__enter__()

    def leave_transaction_management(self, exception=None):
        locals = type(self).thread_locals
        if hasattr(locals, 'transaction'):
            # Don't fucking know why sometimes thread_locals does not contain a transaction
            locals.transaction.__exit__(exception, None, None)

    def process_request(self, request):
        """ Store request on a thread local variable """
        type(self).thread_locals.request = request
        self.enter_transaction_management()

    def process_exception(self, request, exception):
        """Rolls back the database and leaves transaction management"""
        self.leave_transaction_management(exception)

    def process_response(self, request, response):
        """ Processes pending backend operations """
        if response.status_code != 500:
            operations = self.get_pending_operations()
            if operations:
                try:
                    scripts, serialize = manager.generate(operations)
                except Exception as exception:
                    self.leave_transaction_management(exception)
                    raise
                # We commit transaction just before executing operations
                # because here is when IntegrityError show up
                self.leave_transaction_management()
                logs = manager.execute(scripts, serialize=serialize)
                if logs and resolve(request.path).app_name == 'admin':
                    message_user(request, logs)
                return response
        self.leave_transaction_management()
        return response