mygpo/decorators.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # gPodder - A media aggregator and podcast client
   4 # Copyright (c) 2005-2009 Thomas Perl and the gPodder Team
   5 #
   6 # gPodder is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # gPodder is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 #
  19
  20 from functools import wraps
  21 import inspect
  22
  23 from couchdbkit import ResourceConflict
  24
  25 from django.http import Http404
  26 from django.shortcuts import render
  27 from django.http import HttpResponseForbidden, HttpResponseNotAllowed
  28
  29
  30 def requires_token(token_name, denied_template=None):
  31     """
  32     returns a decorator that checks if the security token in the 'token' GET
  33     parameter matches the requires token for the resource. The protected
  34     resource is indicated by
  35     * the username parameter passed to the decorated function
  36     * token_name passed to this method
  37
  38     The decorated method is returned, if
  39     * no token is required for the resource
  40     * the token in the 'token' GET parameter matches the required token
  41
  42     If the passed token does not match
  43     * the denied_template is rendered and returned if given
  44     * HttpResponseForbidden is returned, if denied_template is not given
  45     """
  46     def decorator(fn):
  47         @wraps(fn)
  48         def tmp(request, username, *args, **kwargs):
  49
  50             from mygpo.users.models import User
  51             user = User.get_user(username)
  52             if not user:
  53                 raise Http404
  54
  55             token = user.get_token(token_name)
  56             u_token = request.GET.get('token', '')
  57
  58             if token == '' or token == u_token:
  59                 return fn(request, username, *args, **kwargs)
  60
  61             else:
  62                 if denied_template:
  63                     return render(request, denied_template, {
  64                         'other_user': user
  65                     })
  66
  67                 else:
  68                     return HttpResponseForbidden()
  69
  70         return tmp
  71     return decorator
  72
  73
  74 def allowed_methods(methods):
  75     def decorator(fn):
  76         @wraps(fn)
  77         def tmp(request, *args, **kwargs):
  78             if request.method in methods:
  79                 return fn(request, *args, **kwargs)
  80             else:
  81                 return HttpResponseNotAllowed(methods)
  82
  83         return tmp
  84
  85     return decorator
  86
  87
  88 class repeat_on_conflict(object):
  89     """ Repeats an update operation in case of a ResourceConflict
  90
  91     In case of a CouchDB ResourceConflict, reloads the parameter with the given
  92     name and repeats the function call until it succeeds.  When calling the
  93     function, the parameter that should be reloaded must be given as a
  94     keyword-argument """
  95
  96     ARGSPEC = '__repeat_argspec__'
  97
  98     def __init__(self, obj_names=[], reload_f=None):
  99         self.obj_names = obj_names
 100         self.reload_f = reload_f or self.default_reload
 101
 102     def default_reload(self, obj):
 103         return obj.__class__.get(obj._id)
 104
 105     def build_locals(self, f, args, kwargs):
 106         argspec = getattr(f, self.ARGSPEC)
 107         if len(args) > len(argspec.args):
 108             varargs = args[len(args):]
 109             args = args[:len(args)]
 110         else:
 111             varargs = []
 112         locals = dict(zip(argspec.args, args))
 113         if argspec.varargs is not None:
 114             locals.update({argspec.varargs: varargs})
 115         if argspec.keywords is not None:
 116             locals.update({argspec.keywords: kwargs})
 117         locals.update(kwargs)
 118         return locals
 119
 120     def __call__(self, f):
 121
 122         if not hasattr(f, self.ARGSPEC):
 123             argspec = inspect.getargspec(f)
 124             setattr(f, self.ARGSPEC, argspec)
 125
 126         @wraps(f)
 127         def wrapper(*args, **kwargs):
 128             all_args = before = self.build_locals(f, args, kwargs)
 129
 130             # repeat until operation succeeds
 131             # TODO: adding an upper bound might make sense
 132             while True:
 133                 try:
 134                     return f(**all_args)
 135
 136                 except ResourceConflict:
 137                     for obj_name in self.obj_names:
 138                         obj = all_args[obj_name]
 139                         all_args[obj_name] = self.reload_f(obj)
 140
 141         return wrapper
 142
 143
 144 def query_if_required():
 145     """ If required, queries some resource before calling the function
 146
 147     The decorated method is expected to be bound and its class is
 148     expected to have define the methods _needs_query() and _query().
 149     """
 150
 151     def decorator(f):
 152         @wraps(f)
 153         def wrapper(self, *args, **kwargs):
 154
 155             if self._needs_query():
 156                 self._query()
 157
 158             return f(self, *args, **kwargs)
 159
 160         return wrapper
 161     return decorator