280 lines
9.6 KiB
Python
280 lines
9.6 KiB
Python
from pprint import pformat
|
|
import sys
|
|
from threading import Lock
|
|
try:
|
|
from cStringIO import StringIO
|
|
except ImportError:
|
|
from StringIO import StringIO
|
|
import socket
|
|
|
|
from django import http
|
|
from django.core import signals
|
|
from django.core.handlers import base
|
|
from django.core.urlresolvers import set_script_prefix
|
|
from django.utils import datastructures
|
|
from django.utils.encoding import force_unicode, iri_to_uri
|
|
from django.utils.log import getLogger
|
|
|
|
logger = getLogger('django.request')
|
|
|
|
|
|
# See http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
|
|
STATUS_CODE_TEXT = {
|
|
100: 'CONTINUE',
|
|
101: 'SWITCHING PROTOCOLS',
|
|
200: 'OK',
|
|
201: 'CREATED',
|
|
202: 'ACCEPTED',
|
|
203: 'NON-AUTHORITATIVE INFORMATION',
|
|
204: 'NO CONTENT',
|
|
205: 'RESET CONTENT',
|
|
206: 'PARTIAL CONTENT',
|
|
300: 'MULTIPLE CHOICES',
|
|
301: 'MOVED PERMANENTLY',
|
|
302: 'FOUND',
|
|
303: 'SEE OTHER',
|
|
304: 'NOT MODIFIED',
|
|
305: 'USE PROXY',
|
|
306: 'RESERVED',
|
|
307: 'TEMPORARY REDIRECT',
|
|
400: 'BAD REQUEST',
|
|
401: 'UNAUTHORIZED',
|
|
402: 'PAYMENT REQUIRED',
|
|
403: 'FORBIDDEN',
|
|
404: 'NOT FOUND',
|
|
405: 'METHOD NOT ALLOWED',
|
|
406: 'NOT ACCEPTABLE',
|
|
407: 'PROXY AUTHENTICATION REQUIRED',
|
|
408: 'REQUEST TIMEOUT',
|
|
409: 'CONFLICT',
|
|
410: 'GONE',
|
|
411: 'LENGTH REQUIRED',
|
|
412: 'PRECONDITION FAILED',
|
|
413: 'REQUEST ENTITY TOO LARGE',
|
|
414: 'REQUEST-URI TOO LONG',
|
|
415: 'UNSUPPORTED MEDIA TYPE',
|
|
416: 'REQUESTED RANGE NOT SATISFIABLE',
|
|
417: 'EXPECTATION FAILED',
|
|
500: 'INTERNAL SERVER ERROR',
|
|
501: 'NOT IMPLEMENTED',
|
|
502: 'BAD GATEWAY',
|
|
503: 'SERVICE UNAVAILABLE',
|
|
504: 'GATEWAY TIMEOUT',
|
|
505: 'HTTP VERSION NOT SUPPORTED',
|
|
}
|
|
|
|
class LimitedStream(object):
|
|
'''
|
|
LimitedStream wraps another stream in order to not allow reading from it
|
|
past specified amount of bytes.
|
|
'''
|
|
def __init__(self, stream, limit, buf_size=64 * 1024 * 1024):
|
|
self.stream = stream
|
|
self.remaining = limit
|
|
self.buffer = ''
|
|
self.buf_size = buf_size
|
|
|
|
def _read_limited(self, size=None):
|
|
if size is None or size > self.remaining:
|
|
size = self.remaining
|
|
if size == 0:
|
|
return ''
|
|
result = self.stream.read(size)
|
|
self.remaining -= len(result)
|
|
return result
|
|
|
|
def read(self, size=None):
|
|
if size is None:
|
|
result = self.buffer + self._read_limited()
|
|
self.buffer = ''
|
|
elif size < len(self.buffer):
|
|
result = self.buffer[:size]
|
|
self.buffer = self.buffer[size:]
|
|
else: # size >= len(self.buffer)
|
|
result = self.buffer + self._read_limited(size - len(self.buffer))
|
|
self.buffer = ''
|
|
return result
|
|
|
|
def readline(self, size=None):
|
|
while '\n' not in self.buffer or \
|
|
(size is not None and len(self.buffer) < size):
|
|
if size:
|
|
chunk = self._read_limited(size - len(self.buffer))
|
|
else:
|
|
chunk = self._read_limited()
|
|
if not chunk:
|
|
break
|
|
self.buffer += chunk
|
|
sio = StringIO(self.buffer)
|
|
if size:
|
|
line = sio.readline(size)
|
|
else:
|
|
line = sio.readline()
|
|
self.buffer = sio.read()
|
|
return line
|
|
|
|
class WSGIRequest(http.HttpRequest):
|
|
def __init__(self, environ):
|
|
script_name = base.get_script_name(environ)
|
|
path_info = force_unicode(environ.get('PATH_INFO', u'/'))
|
|
if not path_info or path_info == script_name:
|
|
# Sometimes PATH_INFO exists, but is empty (e.g. accessing
|
|
# the SCRIPT_NAME URL without a trailing slash). We really need to
|
|
# operate as if they'd requested '/'. Not amazingly nice to force
|
|
# the path like this, but should be harmless.
|
|
#
|
|
# (The comparison of path_info to script_name is to work around an
|
|
# apparent bug in flup 1.0.1. Se Django ticket #8490).
|
|
path_info = u'/'
|
|
self.environ = environ
|
|
self.path_info = path_info
|
|
self.path = '%s%s' % (script_name, path_info)
|
|
self.META = environ
|
|
self.META['PATH_INFO'] = path_info
|
|
self.META['SCRIPT_NAME'] = script_name
|
|
self.method = environ['REQUEST_METHOD'].upper()
|
|
self._post_parse_error = False
|
|
if type(socket._fileobject) is type and isinstance(self.environ['wsgi.input'], socket._fileobject):
|
|
# Under development server 'wsgi.input' is an instance of
|
|
# socket._fileobject which hangs indefinitely on reading bytes past
|
|
# available count. To prevent this it's wrapped in LimitedStream
|
|
# that doesn't read past Content-Length bytes.
|
|
#
|
|
# This is not done for other kinds of inputs (like flup's FastCGI
|
|
# streams) beacuse they don't suffer from this problem and we can
|
|
# avoid using another wrapper with its own .read and .readline
|
|
# implementation.
|
|
#
|
|
# The type check is done because for some reason, AppEngine
|
|
# implements _fileobject as a function, not a class.
|
|
try:
|
|
content_length = int(self.environ.get('CONTENT_LENGTH', 0))
|
|
except (ValueError, TypeError):
|
|
content_length = 0
|
|
self._stream = LimitedStream(self.environ['wsgi.input'], content_length)
|
|
else:
|
|
self._stream = self.environ['wsgi.input']
|
|
self._read_started = False
|
|
|
|
def __repr__(self):
|
|
# Since this is called as part of error handling, we need to be very
|
|
# robust against potentially malformed input.
|
|
try:
|
|
get = pformat(self.GET)
|
|
except:
|
|
get = '<could not parse>'
|
|
if self._post_parse_error:
|
|
post = '<could not parse>'
|
|
else:
|
|
try:
|
|
post = pformat(self.POST)
|
|
except:
|
|
post = '<could not parse>'
|
|
try:
|
|
cookies = pformat(self.COOKIES)
|
|
except:
|
|
cookies = '<could not parse>'
|
|
try:
|
|
meta = pformat(self.META)
|
|
except:
|
|
meta = '<could not parse>'
|
|
return '<WSGIRequest\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>' % \
|
|
(get, post, cookies, meta)
|
|
|
|
def get_full_path(self):
|
|
# RFC 3986 requires query string arguments to be in the ASCII range.
|
|
# Rather than crash if this doesn't happen, we encode defensively.
|
|
return '%s%s' % (self.path, self.environ.get('QUERY_STRING', '') and ('?' + iri_to_uri(self.environ.get('QUERY_STRING', ''))) or '')
|
|
|
|
def is_secure(self):
|
|
return 'wsgi.url_scheme' in self.environ \
|
|
and self.environ['wsgi.url_scheme'] == 'https'
|
|
|
|
def _get_request(self):
|
|
if not hasattr(self, '_request'):
|
|
self._request = datastructures.MergeDict(self.POST, self.GET)
|
|
return self._request
|
|
|
|
def _get_get(self):
|
|
if not hasattr(self, '_get'):
|
|
# The WSGI spec says 'QUERY_STRING' may be absent.
|
|
self._get = http.QueryDict(self.environ.get('QUERY_STRING', ''), encoding=self._encoding)
|
|
return self._get
|
|
|
|
def _set_get(self, get):
|
|
self._get = get
|
|
|
|
def _get_post(self):
|
|
if not hasattr(self, '_post'):
|
|
self._load_post_and_files()
|
|
return self._post
|
|
|
|
def _set_post(self, post):
|
|
self._post = post
|
|
|
|
def _get_cookies(self):
|
|
if not hasattr(self, '_cookies'):
|
|
self._cookies = http.parse_cookie(self.environ.get('HTTP_COOKIE', ''))
|
|
return self._cookies
|
|
|
|
def _set_cookies(self, cookies):
|
|
self._cookies = cookies
|
|
|
|
def _get_files(self):
|
|
if not hasattr(self, '_files'):
|
|
self._load_post_and_files()
|
|
return self._files
|
|
|
|
GET = property(_get_get, _set_get)
|
|
POST = property(_get_post, _set_post)
|
|
COOKIES = property(_get_cookies, _set_cookies)
|
|
FILES = property(_get_files)
|
|
REQUEST = property(_get_request)
|
|
|
|
class WSGIHandler(base.BaseHandler):
|
|
initLock = Lock()
|
|
request_class = WSGIRequest
|
|
|
|
def __call__(self, environ, start_response):
|
|
from django.conf import settings
|
|
|
|
# Set up middleware if needed. We couldn't do this earlier, because
|
|
# settings weren't available.
|
|
if self._request_middleware is None:
|
|
self.initLock.acquire()
|
|
# Check that middleware is still uninitialised.
|
|
if self._request_middleware is None:
|
|
self.load_middleware()
|
|
self.initLock.release()
|
|
|
|
set_script_prefix(base.get_script_name(environ))
|
|
signals.request_started.send(sender=self.__class__)
|
|
try:
|
|
try:
|
|
request = self.request_class(environ)
|
|
except UnicodeDecodeError:
|
|
logger.warning('Bad Request (UnicodeDecodeError): %s' % request.path,
|
|
exc_info=sys.exc_info(),
|
|
extra={
|
|
'status_code': 400,
|
|
'request': request
|
|
}
|
|
)
|
|
response = http.HttpResponseBadRequest()
|
|
else:
|
|
response = self.get_response(request)
|
|
finally:
|
|
signals.request_finished.send(sender=self.__class__)
|
|
|
|
try:
|
|
status_text = STATUS_CODE_TEXT[response.status_code]
|
|
except KeyError:
|
|
status_text = 'UNKNOWN STATUS CODE'
|
|
status = '%s %s' % (response.status_code, status_text)
|
|
response_headers = [(str(k), str(v)) for k, v in response.items()]
|
|
for c in response.cookies.values():
|
|
response_headers.append(('Set-Cookie', str(c.output(header=''))))
|
|
start_response(status, response_headers)
|
|
return response
|
|
|