apps/piston/utils.py

   1 import time
   2 from django.http import HttpResponseNotAllowed, HttpResponseForbidden, HttpResponse, HttpResponseBadRequest
   3 from django.core.urlresolvers import reverse
   4 from django.core.cache import cache
   5 from django import get_version as django_version
   6 from django.core.mail import send_mail, mail_admins
   7 from django.conf import settings
   8 from django.utils.translation import ugettext as _
   9 from django.template import loader, TemplateDoesNotExist
  10 from django.contrib.sites.models import Site
  11 from decorator import decorator
  12
  13 from datetime import datetime, timedelta
  14
  15 __version__ = '0.2.3rc1'
  16
  17 def get_version():
  18     return __version__
  19
  20 def format_error(error):
  21     return u"Piston/%s (Django %s) crash report:\n\n%s" % \
  22         (get_version(), django_version(), error)
  23
  24 class rc_factory(object):
  25     """
  26     Status codes.
  27     """
  28     CODES = dict(ALL_OK = ('OK', 200),
  29                  CREATED = ('Created', 201),
  30                  DELETED = ('', 204), # 204 says "Don't send a body!"
  31                  BAD_REQUEST = ('Bad Request', 400),
  32                  FORBIDDEN = ('Forbidden', 401),
  33                  NOT_FOUND = ('Not Found', 404),
  34                  DUPLICATE_ENTRY = ('Conflict/Duplicate', 409),
  35                  NOT_HERE = ('Gone', 410),
  36                  INTERNAL_ERROR = ('Internal Error', 500),
  37                  NOT_IMPLEMENTED = ('Not Implemented', 501),
  38                  THROTTLED = ('Throttled', 503))
  39
  40     def __getattr__(self, attr):
  41         """
  42         Returns a fresh `HttpResponse` when getting
  43         an "attribute". This is backwards compatible
  44         with 0.2, which is important.
  45         """
  46         try:
  47             (r, c) = self.CODES.get(attr)
  48         except TypeError:
  49             raise AttributeError(attr)
  50
  51         return HttpResponse(r, content_type='text/plain', status=c)
  52
  53 rc = rc_factory()
  54
  55 class FormValidationError(Exception):
  56     def __init__(self, form):
  57         self.form = form
  58
  59 class HttpStatusCode(Exception):
  60     def __init__(self, response):
  61         self.response = response
  62
  63 def validate(v_form, operation='POST'):
  64     @decorator
  65     def wrap(f, self, request, *a, **kwa):
  66         form = v_form(getattr(request, operation))
  67
  68         if form.is_valid():
  69             return f(self, request, *a, **kwa)
  70         else:
  71             raise FormValidationError(form)
  72     return wrap
  73
  74 def throttle(max_requests, timeout=60*60, extra=''):
  75     """
  76     Simple throttling decorator, caches
  77     the amount of requests made in cache.
  78
  79     If used on a view where users are required to
  80     log in, the username is used, otherwise the
  81     IP address of the originating request is used.
  82
  83     Parameters::
  84      - `max_requests`: The maximum number of requests
  85      - `timeout`: The timeout for the cache entry (default: 1 hour)
  86     """
  87     @decorator
  88     def wrap(f, self, request, *args, **kwargs):
  89         if request.user.is_authenticated():
  90             ident = request.user.username
  91         else:
  92             ident = request.META.get('REMOTE_ADDR', None)
  93
  94         if hasattr(request, 'throttle_extra'):
  95             """
  96             Since we want to be able to throttle on a per-
  97             application basis, it's important that we realize
  98             that `throttle_extra` might be set on the request
  99             object. If so, append the identifier name with it.
 100             """
 101             ident += ':%s' % str(request.throttle_extra)
 102
 103         if ident:
 104             """
 105             Preferrably we'd use incr/decr here, since they're
 106             atomic in memcached, but it's in django-trunk so we
 107             can't use it yet. If someone sees this after it's in
 108             stable, you can change it here.
 109             """
 110             ident += ':%s' % extra
 111
 112             now = time.time()
 113             count, expiration = cache.get(ident, (1, None))
 114
 115             if expiration is None:
 116                 expiration = now + timeout
 117
 118             if count >= max_requests and expiration > now:
 119                 t = rc.THROTTLED
 120                 wait = int(expiration - now)
 121                 t.content = 'Throttled, wait %d seconds.' % wait
 122                 t['Retry-After'] = wait
 123                 return t
 124
 125             cache.set(ident, (count+1, expiration), (expiration - now))
 126
 127         return f(self, request, *args, **kwargs)
 128     return wrap
 129
 130 def coerce_put_post(request):
 131     """
 132     Django doesn't particularly understand REST.
 133     In case we send data over PUT, Django won't
 134     actually look at the data and load it. We need
 135     to twist its arm here.
 136
 137     The try/except abominiation here is due to a bug
 138     in mod_python. This should fix it.
 139     """
 140     if request.method == "PUT":
 141         try:
 142             request.method = "POST"
 143             request._load_post_and_files()
 144             request.method = "PUT"
 145         except AttributeError:
 146             request.META['REQUEST_METHOD'] = 'POST'
 147             request._load_post_and_files()
 148             request.META['REQUEST_METHOD'] = 'PUT'
 149
 150         request.PUT = request.POST
 151
 152
 153 class MimerDataException(Exception):
 154     """
 155     Raised if the content_type and data don't match
 156     """
 157     pass
 158
 159 class Mimer(object):
 160     TYPES = dict()
 161
 162     def __init__(self, request):
 163         self.request = request
 164
 165     def is_multipart(self):
 166         content_type = self.content_type()
 167
 168         if content_type is not None:
 169             return content_type.lstrip().startswith('multipart')
 170
 171         return False
 172
 173     def loader_for_type(self, ctype):
 174         """
 175         Gets a function ref to deserialize content
 176         for a certain mimetype.
 177         """
 178         for loadee, mimes in Mimer.TYPES.iteritems():
 179             for mime in mimes:
 180                 if ctype.startswith(mime):
 181                     return loadee
 182
 183     def content_type(self):
 184         """
 185         Returns the content type of the request in all cases where it is
 186         different than a submitted form - application/x-www-form-urlencoded
 187         """
 188         type_formencoded = "application/x-www-form-urlencoded"
 189
 190         ctype = self.request.META.get('CONTENT_TYPE', type_formencoded)
 191
 192         if type_formencoded in ctype:
 193             return None
 194
 195         return ctype
 196
 197     def translate(self):
 198         """
 199         Will look at the `Content-type` sent by the client, and maybe
 200         deserialize the contents into the format they sent. This will
 201         work for JSON, YAML, XML and Pickle. Since the data is not just
 202         key-value (and maybe just a list), the data will be placed on
 203         `request.data` instead, and the handler will have to read from
 204         there.
 205
 206         It will also set `request.content_type` so the handler has an easy
 207         way to tell what's going on. `request.content_type` will always be
 208         None for form-encoded and/or multipart form data (what your browser sends.)
 209         """
 210         ctype = self.content_type()
 211         self.request.content_type = ctype
 212
 213         if not self.is_multipart() and ctype:
 214             loadee = self.loader_for_type(ctype)
 215
 216             if loadee:
 217                 try:
 218                     self.request.data = loadee(self.request.raw_post_data)
 219
 220                     # Reset both POST and PUT from request, as its
 221                     # misleading having their presence around.
 222                     self.request.POST = self.request.PUT = dict()
 223                 except (TypeError, ValueError):
 224                     # This also catches if loadee is None.
 225                     raise MimerDataException
 226             else:
 227                 self.request.data = None
 228
 229         return self.request
 230
 231     @classmethod
 232     def register(cls, loadee, types):
 233         cls.TYPES[loadee] = types
 234
 235     @classmethod
 236     def unregister(cls, loadee):
 237         return cls.TYPES.pop(loadee)
 238
 239 def translate_mime(request):
 240     request = Mimer(request).translate()
 241
 242 def require_mime(*mimes):
 243     """
 244     Decorator requiring a certain mimetype. There's a nifty
 245     helper called `require_extended` below which requires everything
 246     we support except for post-data via form.
 247     """
 248     @decorator
 249     def wrap(f, self, request, *args, **kwargs):
 250         m = Mimer(request)
 251         realmimes = set()
 252
 253         rewrite = { 'json':   'application/json',
 254                     'yaml':   'application/x-yaml',
 255                     'xml':    'text/xml',
 256                     'pickle': 'application/python-pickle' }
 257
 258         for idx, mime in enumerate(mimes):
 259             realmimes.add(rewrite.get(mime, mime))
 260
 261         if not m.content_type() in realmimes:
 262             return rc.BAD_REQUEST
 263
 264         return f(self, request, *args, **kwargs)
 265     return wrap
 266
 267 require_extended = require_mime('json', 'yaml', 'xml', 'pickle')
 268
 269 def send_consumer_mail(consumer):
 270     """
 271     Send a consumer an email depending on what their status is.
 272     """
 273     try:
 274         subject = settings.PISTON_OAUTH_EMAIL_SUBJECTS[consumer.status]
 275     except AttributeError:
 276         subject = "Your API Consumer for %s " % Site.objects.get_current().name
 277         if consumer.status == "accepted":
 278             subject += "was accepted!"
 279         elif consumer.status == "canceled":
 280             subject += "has been canceled."
 281         elif consumer.status == "rejected":
 282             subject += "has been rejected."
 283         else:
 284             subject += "is awaiting approval."
 285
 286     template = "piston/mails/consumer_%s.txt" % consumer.status
 287
 288     try:
 289         body = loader.render_to_string(template,
 290             { 'consumer' : consumer, 'user' : consumer.user })
 291     except TemplateDoesNotExist:
 292         """
 293         They haven't set up the templates, which means they might not want
 294         these emails sent.
 295         """
 296         return
 297
 298     try:
 299         sender = settings.PISTON_FROM_EMAIL
 300     except AttributeError:
 301         sender = settings.DEFAULT_FROM_EMAIL
 302
 303     if consumer.user:
 304         send_mail(_(subject), body, sender, [consumer.user.email], fail_silently=True)
 305
 306     if consumer.status == 'pending' and len(settings.ADMINS):
 307         mail_admins(_(subject), body, fail_silently=True)
 308
 309     if settings.DEBUG and consumer.user:
 310         print "Mail being sent, to=%s" % consumer.user.email
 311         print "Subject: %s" % _(subject)
 312         print body
 313