common-decorators.py

from django.contrib.auth import REDIRECT_FIELD_NAME
from django.http import HttpResponseRedirect
from django.utils.http import urlquote
from django.utils.decorators import available_attrs
from functools import wraps

import time
import logging

from lockfile import FileLock, AlreadyLocked, LockTimeout
from django.conf import settings


def request_passes_test(test_func, login_url=None, redirect_field_name=REDIRECT_FIELD_NAME):
    """
    Decorator for views that checks that the user passes the given test,
    redirecting to the log-in page if necessary. The test should be a callable
    that takes the request object and returns True if the user passes.

    Request object have user :)
    
    Thx to caio to make it in manutencao module.
    """
    if not login_url:
        from django.conf import settings
        login_url = settings.LOGIN_URL

    def decorator(view_func):
        def _wrapped_view(request, *args, **kwargs):
            if test_func(request, *args, **kwargs):
                return view_func(request, *args, **kwargs)
            path = urlquote(request.get_full_path())
            tup = login_url, redirect_field_name, path
            return HttpResponseRedirect('%s?%s=%s' % tup)
        return wraps(view_func, assigned=available_attrs(view_func))(_wrapped_view)
    return decorator

# Lock timeout value - how long to wait for the lock to become available.
# Default behavior is to never wait for the lock to be available (fail fast)
LOCK_WAIT_TIMEOUT = getattr(settings, "DEFAULT_LOCK_WAIT_TIMEOUT", -1)

def handle_lock(handle):
    """
    A decorator for management commands (or any class method) to ensure that there is
    only ever one process running the method at any one time.

    Requires lockfile - (pip install lockfile)

    Author: Ross Lawley http://rosslawley.co.uk/2010/10/locking-django-management-commands.html

    Decorate the handle method with a file lock to ensure there is only ever
    one process running at any one time.
    """
    
    def wrapper(self, *args, **options):
        #import pdb
        #pdb.set_trace()
        start_time = time.time()
        verbosity = options.get('verbosity', 0)
        if verbosity == 0:
            level = logging.WARNING
        elif verbosity == 1:
            level = logging.INFO
        else:
            level = logging.DEBUG
        
        logging.basicConfig(level=level, format="%(message)s")
        logging.debug("-" * 72)
        
        lock_name = self.__module__.split('.').pop()
        lock = FileLock(lock_name)
        
        logging.debug("%s - acquiring lock... File: %s" % (lock_name,lock.lock_file))
        try:
            lock.acquire(LOCK_WAIT_TIMEOUT)
        except AlreadyLocked:
            logging.debug("lock already in place. quitting.")
            raise # original has return here
        except LockTimeout:
            logging.debug("waiting for the lock timed out. quitting.")
            return
        logging.debug("acquired.")
        
        try:
            handle(self, *args, **options)
        except:
            import traceback
            logging.warn("Command Failed")
            logging.warn('==' * 72)
            logging.warn(traceback.format_exc())
            logging.warn('==' * 72)
        
        logging.debug("releasing lock...")
        lock.release()
        logging.debug("released.")
        
        logging.info("done in %.2f seconds" % (time.time() - start_time))
        return
        
    return wrapper

some-management-command.py

# coding: utf-8
import sys

from django.core.management.base import BaseCommand, CommandError
from optparse import make_option

from rh.models import LOG_CRITICAL
from common.decorators import handle_lock
from lockfile import AlreadyLocked

from portal.rh import sentry_cli

import logging
logging.basicConfig(format="%(asctime)s :: %(levelname)s :: %(message)s")
logger = logging.getLogger()


class Command(BaseCommand):

    help = u""""""

    def handle(self, *args, **options):
        """ execute the command """

        # set log messages
        logger.setLevel(logging.WARNING)
        if int(options.get('verbosity')) > 0: logger.setLevel(logging.INFO)
        if options.get('verbosity') == '2': logger.setLevel(logging.DEBUG)

        try:
            self.run_import(**options)
        except AlreadyLocked:
            logger.info(u"Already have a %s running, wait.",sys.arv[1])

    @handle_lock
    def run_import(self,**options):
        # do everything
        pass