Here are the examples of the python api django.core.handlers.wsgi.WSGIRequest taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
59 Examples
3
Example 1
def run(self, meta, *args, **kwargs):
# TODO: subclass WSGIRequest so all of the wsgi stuff is actually gone
request = WSGIRequest(meta)
request._cache_update_cache = True
if not self.should_rebuild(request):
return
handler = AsyncHandler()
response = handler(request)
3
Example 2
def __call__(self, environ):
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.load_middleware()
request = WSGIRequest(environ)
response = self.get_response(request)
return response
3
Example 3
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
'wsgi.input': StringIO(),
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
3
Example 4
def _make_request(path):
req = WSGIRequest({
'REQUEST_METHOD': 'GET',
'PATH_INFO': path,
'wsgi.input': StringIO()})
req.user = AnonymousUser()
return req
3
Example 5
def __call__(self, environ, start_response):
if not self.should_run(environ):
return self.application(environ, start_response)
request = WSGIRequest(environ)
timer = threading.Timer(self.threshold, self.log_request, args=[thread.get_ident(), request])
timer.start()
try:
return list(self.application(environ, start_response))
finally:
timer.cancel()
3
Example 6
def __init__(self, request=None, locale=None):
self.request = request or WSGIRequest(
{'REQUEST_METHOD': 'bogus', 'wsgi.input': None})
split = split_path(self.request.path_info)
self.locale, self.shortened_path = split
if locale:
self.locale = locale
3
Example 7
Project: raven-python Source File: tests.py
def make_request():
return WSGIRequest(environ={
'wsgi.input': StringIO(),
'REQUEST_METHOD': 'POST',
'SERVER_NAME': 'testserver',
'SERVER_PORT': '80',
'CONTENT_TYPE': 'text/html',
'ACCEPT': 'text/html',
})
3
Example 8
Project: opbeat_python Source File: django_tests.py
def test_post_data(self):
request = WSGIRequest(environ={
'wsgi.input': six.BytesIO(),
'REQUEST_METHOD': 'POST',
'SERVER_NAME': 'testserver',
'SERVER_PORT': '80',
'CONTENT_TYPE': 'application/octet-stream',
'ACCEPT': 'application/json',
})
request.POST = QueryDict("x=1&y=2")
self.opbeat.capture('Message', message='foo', request=request)
self.assertEquals(len(self.opbeat.events), 1)
event = self.opbeat.events.pop(0)
self.assertTrue('http' in event)
http = event['http']
self.assertEquals(http['method'], 'POST')
self.assertEquals(http['data'], {'x': '1', 'y': '2'})
3
Example 9
Project: opbeat_python Source File: django_tests.py
def test_post_raw_data(self):
request = WSGIRequest(environ={
'wsgi.input': six.BytesIO(six.b('foobar')),
'REQUEST_METHOD': 'POST',
'SERVER_NAME': 'testserver',
'SERVER_PORT': '80',
'CONTENT_TYPE': 'application/octet-stream',
'ACCEPT': 'application/json',
'CONTENT_LENGTH': '6',
})
self.opbeat.capture('Message', message='foo', request=request)
self.assertEquals(len(self.opbeat.events), 1)
event = self.opbeat.events.pop(0)
self.assertTrue('http' in event)
http = event['http']
self.assertEquals(http['method'], 'POST')
self.assertEquals(http['data'], six.b('foobar'))
3
Example 10
def __call__(self, environ, start_response):
request = WSGIRequest(environ)
response = self.view(request)
response = self.apply_response_fixes(request, response)
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
3
Example 11
Project: editorsnotes-server Source File: utils.py
def make_dummy_request():
parsed = urlparse(settings.SITE_URL)
request = WSGIRequest({
'wsgi.input': '',
'wsgi.url_scheme': parsed.scheme,
'REQUEST_METHOD': 'GET',
'SERVER_NAME': parsed.hostname,
'SERVER_PORT': parsed.port or (443 if parsed.scheme == 'https' else 80)
})
return request
3
Example 12
Project: django-pagination-bootstrap Source File: tests.py
def test_append_page_property(self):
middleware = PaginationMiddleware()
request = WSGIRequest({'REQUEST_METHOD': 'POST', 'CONTENT_TYPE': 'multipart', 'wsgi.input': StringIO()})
middleware.process_request(request)
self.assertTrue(hasattr(request, 'page'))
request.upload_handlers.append('asdf')
3
Example 13
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
'wsgi.input': StringIO(""),
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
3
Example 14
def __call__(self, environ, start_response):
if not self.should_run(environ):
return self.application(environ, start_response)
state = State()
cursor = get_cursor_wrapper(state, queries=self.queries)
with Patcher('django.db.backends.BaseDatabaseWrapper.cursor', cursor):
try:
return list(self.application(environ, start_response))
finally:
if state.count > self.threshold:
self.log_request(WSGIRequest(environ), state)
3
Example 15
def request(self, **request):
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
3
Example 16
def make_request():
environ = {
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
"wsgi.input": sys.stdin
}
return WSGIRequest(environ)
3
Example 17
Project: django-html5-appcache Source File: base.py
def get_request(self, path, data={}, **extra):
"Construct a GET request."
parsed = urlparse(path)
r = {
'CONTENT_TYPE': str('text/html; charset=utf-8'),
'PATH_INFO': self._get_path(parsed),
'QUERY_STRING': urlencode(data, doseq=True) or force_unicode(parsed[4]),
'REQUEST_METHOD': str('GET'),
}
r.update(extra)
return WSGIRequest(self._base_environ(**r))
3
Example 18
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
3
Example 19
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
0
Example 20
Project: zulip Source File: runtornado.py
def get(self, *args, **kwargs):
# type: (*Any, **Any) -> None
environ = WSGIContainer.environ(self.request)
environ['PATH_INFO'] = urllib.parse.unquote(environ['PATH_INFO'])
request = WSGIRequest(environ)
request._tornado_handler = self
set_script_prefix(get_script_name(environ))
signals.request_started.send(sender=self.__class__)
try:
response = self.get_response(request)
if not response:
return
finally:
signals.request_finished.send(sender=self.__class__)
self.set_status(response.status_code)
for h in response.items():
self.set_header(h[0], h[1])
if not hasattr(self, "_new_cookies"):
self._new_cookies = [] # type: List[http.cookie.SimpleCookie]
self._new_cookies.append(response.cookies)
self.write(response.content)
self.finish()
0
Example 21
Project: lettuce Source File: client.py
def __call__(self, environ):
from django.conf import settings
from django.core import signals
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._request_middleware is None:
self.load_middleware()
signals.request_started.send(sender=self.__class__)
try:
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
response = self.get_response(request)
# Apply response middleware.
for middleware_method in self._response_middleware:
response = middleware_method(request, response)
response = self.apply_response_fixes(request, response)
finally:
signals.request_finished.disconnect(close_connection)
signals.request_finished.send(sender=self.__class__)
signals.request_finished.connect(close_connection)
return response
0
Example 22
Project: raven-python Source File: tests.py
def test_request_kwarg(self):
handler = SentryHandler()
logger = self.logger
logger.handlers = []
logger.addHandler(handler)
logger.error('This is a test error', extra={
'request': WSGIRequest(environ={
'wsgi.input': StringIO(),
'REQUEST_METHOD': 'POST',
'SERVER_NAME': 'testserver',
'SERVER_PORT': '80',
'CONTENT_TYPE': 'application/octet-stream',
'ACCEPT': 'application/json',
})
})
assert len(self.raven.events) == 1
event = self.raven.events.pop(0)
assert 'request' in event
http = event['request']
assert http['method'] == 'POST'
0
Example 23
Project: Django--an-app-at-a-time Source File: client.py
def __call__(self, environ):
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._request_middleware is None:
self.load_middleware()
request_started.disconnect(close_old_connections)
request_started.send(sender=self.__class__, environ=environ)
request_started.connect(close_old_connections)
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
# Request goes through middleware.
response = self.get_response(request)
# Attach the originating request to the response so that it could be
# later retrieved.
response.wsgi_request = request
# We're emulating a WSGI server; we must call the close method
# on completion.
if response.streaming:
response.streaming_content = closing_iterator_wrapper(
response.streaming_content, response.close)
else:
request_finished.disconnect(close_old_connections)
response.close() # will fire request_finished
request_finished.connect(close_old_connections)
return response
0
Example 24
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
'wsgi.version': (1,0),
'wsgi.url_scheme': 'http',
'wsgi.input': FakePayload(''),
'wsgi.errors': self.errors,
'wsgi.multiprocess': True,
'wsgi.multithread': False,
'wsgi.run_once': False,
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
0
Example 25
def request(self, **request):
"""
Returns a request simliar to one from a browser which wants to upgrade
to a websocket connection.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
# WebSocket specific headers
'HTTP_CONNECTION': 'Upgrade',
'HTTP_UPGRADE': 'WebSocket',
}
if self.protocol_version == 76:
raise NotImplementedError(u'This version is not yet supported.')
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
0
Example 26
Project: django-ddp Source File: websocket.py
def on_open(self):
"""Handle new websocket connection."""
this.request = WSGIRequest(self.ws.environ)
this.ws = self
this.send = self.send
this.reply = self.reply
self.logger = self.ws.logger
self.remote_ids = collections.defaultdict(set)
# `_tx_buffer` collects outgoing messages which must be sent in order
self._tx_buffer = {}
# track the head of the queue (buffer) and the next msg to be sent
self._tx_buffer_id_gen = itertools.cycle(irange(sys.maxint))
self._tx_next_id_gen = itertools.cycle(irange(sys.maxint))
# start by waiting for the very first message
self._tx_next_id = next(self._tx_next_id_gen)
this.remote_addr = self.remote_addr = \
'{0[REMOTE_ADDR]}:{0[REMOTE_PORT]}'.format(
self.ws.environ,
)
this.subs = {}
safe_call(self.logger.info, '+ %s OPEN', self)
self.send('o')
self.send('a["{\\"server_id\\":\\"0\\"}"]')
0
Example 27
def __call__(self, environ):
from django.conf import settings
from django.core import signals
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._request_middleware is None:
self.load_middleware()
signals.request_started.send(sender=self.__class__)
try:
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
response = self.get_response(request)
finally:
signals.request_finished.disconnect(close_connection)
signals.request_finished.send(sender=self.__class__)
signals.request_finished.connect(close_connection)
return response
0
Example 28
def __call__(self, environ):
from django.conf import settings
from django.core import signals
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._request_middleware is None:
self.load_middleware()
dispatcher.send(signal=signals.request_started)
try:
request = WSGIRequest(environ)
response = self.get_response(request)
# Apply response middleware.
for middleware_method in self._response_middleware:
response = middleware_method(request, response)
response = self.apply_response_fixes(request, response)
finally:
dispatcher.send(signal=signals.request_finished)
return response
0
Example 29
Project: devmason-server Source File: views.py
def add_results(info, results):
"Return sweet results"
build_dict = {'success': info.get('success', False),
'started': info.get('start_time', ''),
'finished': info.get('end_time', ''),
'tags': info['tags'],
'client': {
'arch': info.get('arch', ''),
'host':info.get('host', ''),
'user': 'pony-client',
},
'results': []
}
for result in results:
success = False
#Status code of 0 means successful
if result.get('status', False) == 0:
success = True
build_dict['results'].append(
{'success': success,
'name': result.get('name', ''),
'errout': result.get('errout', ''),
'output': result.get('output', ''),
'command': result.get('command', ''),
'type': result.get('type', ''),
'version_type': result.get('version_type', ''),
'version_info': result.get('version_info', ''),
}
)
environ = {
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
r = WSGIRequest(environ)
r.data = build_dict
r.META['CONTENT_TYPE'] = 'application/json'
package = unicode(info.get('package'))
try:
pro, created = Project.objects.get_or_create(name=package, slug=slugify(package))
except:
pass
ProjectBuildListHandler().create(r, package)
return "Processed Correctly"
0
Example 30
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
environ.update(self.defaults)
environ.update(request)
request = WSGIRequest(environ)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request object - "
"request middleware returned a response")
return request
0
Example 31
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
environ.update(self.defaults)
environ.update(request)
request = WSGIRequest(environ)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
middleware_method(request)
return request
0
Example 32
Project: hue Source File: client.py
def __call__(self, environ):
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.load_middleware()
request_started.disconnect(close_old_connections)
request_started.send(sender=self.__class__)
request_started.connect(close_old_connections)
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
response = self.get_response(request)
# We're emulating a WSGI server; we must call the close method
# on completion.
if response.streaming:
response.streaming_content = closing_iterator_wrapper(
response.streaming_content, response.close)
else:
request_finished.disconnect(close_old_connections)
response.close() # will fire request_finished
request_finished.connect(close_old_connections)
return response
0
Example 33
Project: firefox-flicks Source File: req.py
def request(self, **request):
"""Similar to parent class, but returns the request object as
soon as it has created it."""
environ = {
'HTTP_COOKIE': self.cookies,
'HTTP_USER_AGENT': 'Django UnitTest Client 1.0',
'REMOTE_ADDR': '127.0.0.1',
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
'wsgi.input': WhateverIO(),
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
0
Example 34
Project: inthe.am Source File: debug_utils.py
def artificial_login(**credentials):
from django.contrib.auth import authenticate, login
cookies = SimpleCookie()
user = authenticate(**credentials)
engine = import_module(settings.SESSION_ENGINE)
# Create a fake request that goes through request middleware
request = WSGIRequest(
{
'HTTP_COOKIE': cookies.output(header='', sep=';'),
'PATH_INFO': str('/'),
'REMOTE_ADDR': str('127.0.0.1'),
'REQUEST_METHOD': str('GET'),
'SCRIPT_NAME': str(''),
'SERVER_NAME': str('testserver'),
'SERVER_PORT': str('80'),
'SERVER_PROTOCOL': str('HTTP/1.1'),
'wsgi.version': (1, 0),
'wsgi.url_scheme': str('http'),
'wsgi.input': BytesIO(),
'wsgi.errors': BytesIO(),
'wsgi.multiprocess': True,
'wsgi.multithread': False,
'wsgi.run_once': False,
}
)
request.session = engine.SessionStore()
login(request, user)
# Save the session values.
request.session.save()
# Set the cookie to represent the session.
session_cookie = settings.SESSION_COOKIE_NAME
cookies[session_cookie] = request.session.session_key
cookie_data = {
'max-age': None,
'path': '/',
'domain': settings.SESSION_COOKIE_DOMAIN,
'secure': settings.SESSION_COOKIE_SECURE or None,
'expires': None,
}
cookies[session_cookie].update(cookie_data)
return {
session_cookie: cookies[session_cookie].value,
settings.CSRF_COOKIE_NAME: csrf._get_new_csrf_key(),
}
0
Example 35
Project: zulip Source File: queue_processors.py
def consume(self, event):
# type: (Mapping[str, Any]) -> None
server_meta = event['server_meta']
environ = {'REQUEST_METHOD': 'SOCKET',
'SCRIPT_NAME': '',
'PATH_INFO': '/json/messages',
'SERVER_NAME': '127.0.0.1',
'SERVER_PORT': 9993,
'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0',
'wsgi.version': (1, 0),
'wsgi.input': StringIO(),
'wsgi.errors': sys.stderr,
'wsgi.multithread': False,
'wsgi.multiprocess': True,
'wsgi.run_once': False,
'zulip.emulated_method': 'POST'}
# We're mostly using a WSGIRequest for convenience
environ.update(server_meta['request_environ'])
request = WSGIRequest(environ)
# Note: If we ever support non-POST methods, we'll need to change this.
request._post = event['request']
request.csrf_processing_done = True
user_profile = get_user_profile_by_id(server_meta['user_id'])
request._cached_user = user_profile
resp = self.handler.get_response(request)
server_meta['time_request_finished'] = time.time()
server_meta['worker_log_data'] = request._log_data
resp_content = resp.content.decode('utf-8')
result = {'response': ujson.loads(resp_content), 'req_id': event['req_id'],
'server_meta': server_meta}
redis_key = req_redis_key(event['req_id'])
self.redis_client.hmset(redis_key, {'status': 'complete',
'response': resp_content});
queue_json_publish(server_meta['return_queue'], result, lambda e: None)
0
Example 36
Project: vault Source File: fakes.py
def fake_request(path='/', method='GET', user=None, extra={}):
params = {
'REQUEST_METHOD': method,
'PATH_INFO': path,
'wsgi.input': StringIO()
}
params.update(extra)
req = WSGIRequest(params)
req.user = user or AnonymousUser()
req.user.id = ''
req.user.username = 'user'
req.user.first_name = 'mock_user'
req.user.is_superuser = True
req.user.groups.all = lambda: [GroupFactory(id=1)]
req.build_absolute_uri = lambda x=None: '/'
# for sessions middleware
req.session = build_fake_session()
# for messages middleware
req._messages = default_storage(req)
req.get_host = lambda x=None: 'localhost'
return req
0
Example 37
Project: djangae Source File: blobstore_service.py
def start_blobstore_service():
"""
When the blobstore files API was deprecated, the blobstore storage was switched
to use a POST request to the upload handler when storing files uploaded via Django.
Unfortunately this breaks in the local sandbox when you aren't running the dev_appserver
because there is no server to handle the blobstore upload. So, this service is kicked
off by the local sandbox and only handles blobstore uploads. When runserver kicks in
this service is stopped.
"""
global blobstore_service
global server
if blobstore_service:
return
from wsgiref.simple_server import make_server
from google.appengine.tools.devappserver2 import blob_upload
from google.appengine.tools.devappserver2 import blob_image
from google.appengine.tools.devappserver2 import gcs_server
from django.core.handlers.wsgi import WSGIRequest
from django.utils.encoding import force_str
from socket import error as socket_error
def call_internal_upload(environ, start_response):
# Otherwise, just assume it's our internalupload handler
request = WSGIRequest(environ)
from djangae.views import internalupload
response = internalupload(request)
status = '%s %s' % (response.status_code, response.reason_phrase)
response_headers = [(str(k), str(v)) for k, v in response.items()]
start_response(force_str(status), response_headers)
return response
def handler(environ, start_response):
path = environ["PATH_INFO"]
# If this is an image serving URL, then use use the blob_image WSGI app
if re.match(blob_image.BLOBIMAGE_URL_PATTERN, path.lstrip("/")):
return blob_image.Application()(environ, start_response)
elif re.match(gcs_server.GCS_URL_PATTERN, path.lstrip("/")):
return gcs_server.Application()(environ, start_response)
return blob_upload.Application(call_internal_upload)(environ, start_response)
port = int(os.environ['SERVER_PORT'])
host = os.environ['SERVER_NAME']
logging.info("Starting blobstore service on %s:%s", host, port)
try:
server = make_server(host, port, handler, handler_class=NoLogRequestHandler)
except socket_error:
logging.warning("Not starting blobstore service, it may already be running")
return
blobstore_service = threading.Thread(target=server.serve_forever)
blobstore_service.daemon = True
blobstore_service.start()
0
Example 38
Project: django-celery Source File: req.py
def request(self, **request):
"""Similar to parent class, but returns the request object as
soon as it has created it."""
environ = {
'HTTP_COOKIE': unicode(self.cookies),
'HTTP_USER_AGENT': 'Django UnitTest Client 1.0',
'REMOTE_ADDR': '127.0.0.1',
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
'wsgi.input': WhateverIO(),
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)
0
Example 39
Project: django-websocket-redis Source File: wsgi_server.py
def __call__(self, environ, start_response):
"""
Hijack the main loop from the original thread and listen on events on the Redis
and the Websocket filedescriptors.
"""
websocket = None
subscriber = self.Subscriber(self._redis_connection)
try:
self.assure_protocol_requirements(environ)
request = WSGIRequest(environ)
if callable(private_settings.WS4REDIS_PROCESS_REQUEST):
private_settings.WS4REDIS_PROCESS_REQUEST(request)
else:
self.process_request(request)
channels, echo_message = self.process_subscriptions(request)
if callable(private_settings.WS4REDIS_ALLOWED_CHANNELS):
channels = list(private_settings.WS4REDIS_ALLOWED_CHANNELS(request, channels))
elif private_settings.WS4REDIS_ALLOWED_CHANNELS is not None:
try:
mod, callback = private_settings.WS4REDIS_ALLOWED_CHANNELS.rsplit('.', 1)
callback = getattr(import_module(mod), callback, None)
if callable(callback):
channels = list(callback(request, channels))
except AttributeError:
pass
websocket = self.upgrade_websocket(environ, start_response)
self._websockets.add(websocket)
logger.debug('Subscribed to channels: {0}'.format(', '.join(channels)))
subscriber.set_pubsub_channels(request, channels)
websocket_fd = websocket.get_file_descriptor()
listening_fds = [websocket_fd]
redis_fd = subscriber.get_file_descriptor()
if redis_fd:
listening_fds.append(redis_fd)
subscriber.send_persited_messages(websocket)
recvmsg = None
while websocket and not websocket.closed:
ready = self.select(listening_fds, [], [], 4.0)[0]
if not ready:
# flush empty socket
websocket.flush()
for fd in ready:
if fd == websocket_fd:
recvmsg = RedisMessage(websocket.receive())
if recvmsg:
subscriber.publish_message(recvmsg)
elif fd == redis_fd:
sendmsg = RedisMessage(subscriber.parse_response())
if sendmsg and (echo_message or sendmsg != recvmsg):
websocket.send(sendmsg)
else:
logger.error('Invalid file descriptor: {0}'.format(fd))
# Check again that the websocket is closed before sending the heartbeat,
# because the websocket can closed previously in the loop.
if private_settings.WS4REDIS_HEARTBEAT and not websocket.closed:
websocket.send(private_settings.WS4REDIS_HEARTBEAT)
# Remove websocket from _websockets if closed
if websocket.closed:
self._websockets.remove(websocket)
except WebSocketError as excpt:
logger.warning('WebSocketError: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponse(status=1001, content='Websocket Closed')
except UpgradeRequiredError as excpt:
logger.info('Websocket upgrade required')
response = http.HttpResponseBadRequest(status=426, content=excpt)
except HandshakeError as excpt:
logger.warning('HandshakeError: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponseBadRequest(content=excpt)
except PermissionDenied as excpt:
logger.warning('PermissionDenied: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponseForbidden(content=excpt)
except Exception as excpt:
logger.error('Other Exception: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponseServerError(content=excpt)
else:
response = http.HttpResponse()
finally:
subscriber.release()
if websocket:
websocket.close(code=1001, message='Websocket Closed')
else:
logger.warning('Starting late response on websocket')
status_text = http_client.responses.get(response.status_code, 'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
headers = response._headers.values()
if six.PY3:
headers = list(headers)
start_response(force_str(status), headers)
logger.info('Finish non-websocket response with status code: {}'.format(response.status_code))
return response
0
Example 40
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
environ.update(self.defaults)
environ.update(request)
request = WSGIRequest(environ)
# Add request.user.
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
if middleware_method(request):
raise Exception("Couldn't create request mock object - "
"request middleware returned a response")
return request
0
Example 41
Project: GAE-Bulk-Mailer Source File: client.py
def __call__(self, environ):
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.load_middleware()
request_started.send(sender=self.__class__)
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
response = self.get_response(request)
# We're emulating a WSGI server; we must call the close method
# on completion.
if response.streaming:
response.streaming_content = closing_iterator_wrapper(
response.streaming_content, response.close)
else:
request_finished.disconnect(close_connection)
response.close() # will fire request_finished
request_finished.connect(close_connection)
return response
0
Example 42
def __call__(self, environ, start_response):
try:
request = WSGIRequest(environ)
except UnicodeDecodeError:
response = http.HttpResponseBadRequest()
else:
response = self.get_response(request)
# Apply response middleware
for middleware_method in self.response_middleware:
response = middleware_method(request, response)
response = self.apply_response_fixes(request, response)
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
0
Example 43
Project: django-compositepks Source File: client.py
def __call__(self, environ):
from django.conf import settings
from django.core import signals
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._request_middleware is None:
self.load_middleware()
signals.request_started.send(sender=self.__class__)
try:
request = WSGIRequest(environ)
response = self.get_response(request)
# Apply response middleware.
for middleware_method in self._response_middleware:
response = middleware_method(request, response)
response = self.apply_response_fixes(request, response)
finally:
signals.request_finished.send(sender=self.__class__)
return response
0
Example 44
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies,
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
}
environ.update(self.defaults)
environ.update(request)
request = WSGIRequest(environ)
handler = BaseHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
middleware_method(request)
return request
0
Example 45
Project: oioioi Source File: tests.py
def setUp(self):
"""Modify the client so that it follows to handler500 view on error,
retaining cookies."""
self._orig_handler = self.client.handler
self._orig_get = self.client.get
self._orig_login = self.client.login
self._orig_logout = self.client.logout
self._user = AnonymousUser()
self._req = None
def wrapped_handler500(request):
from oioioi.base.views import handler500
r = WSGIRequest(request)
r.session = import_module(settings.SESSION_ENGINE).SessionStore()
if self._user:
r.user = self._user
self._req = r
return handler500(r)
def custom_get(*args, **kwargs):
try:
return self._orig_get(*args, **kwargs)
except StandardError:
try:
self.client.handler = wrapped_handler500
resp = self._orig_get(*args, **kwargs)
resp.request = self._req
return resp
finally:
self.client.handler = self._orig_handler
def custom_logout(*args, **kwargs):
self._orig_logout(*args, **kwargs)
self._user = AnonymousUser()
def custom_login(*args, **kwargs):
self._orig_login(*args, **kwargs)
self._user = User.objects.get(**kwargs)
self.client.get = custom_get
self.client.logout = custom_logout
self.client.login = custom_login
0
Example 46
def __call__(self, environ):
from django.conf import settings
from django.core import signals
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._request_middleware is None:
self.load_middleware()
dispatcher.send(signal=signals.request_started)
try:
request = WSGIRequest(environ)
response = self.get_response(request)
# Apply response middleware
for middleware_method in self._response_middleware:
response = middleware_method(request, response)
response = self.apply_response_fixes(request, response)
finally:
dispatcher.send(signal=signals.request_finished)
return response
0
Example 47
def request(self, **request):
"Construct a generic request object."
return WSGIRequest(self._base_environ(**request))
0
Example 48
Project: PyClassLessons Source File: client.py
def __call__(self, environ):
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._request_middleware is None:
self.load_middleware()
request_started.disconnect(close_old_connections)
request_started.send(sender=self.__class__)
request_started.connect(close_old_connections)
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
# Request goes through middleware.
response = self.get_response(request)
# Attach the originating request to the response so that it could be
# later retrieved.
response.wsgi_request = request
# We're emulating a WSGI server; we must call the close method
# on completion.
if response.streaming:
response.streaming_content = closing_iterator_wrapper(
response.streaming_content, response.close)
else:
request_finished.disconnect(close_old_connections)
response.close() # will fire request_finished
request_finished.connect(close_old_connections)
return response
0
Example 49
Project: django Source File: client.py
def __call__(self, environ):
# Set up middleware if needed. We couldn't do this earlier, because
# settings weren't available.
if self._middleware_chain is None:
self.load_middleware()
request_started.disconnect(close_old_connections)
request_started.send(sender=self.__class__, environ=environ)
request_started.connect(close_old_connections)
request = WSGIRequest(environ)
# sneaky little hack so that we can easily get round
# CsrfViewMiddleware. This makes life easier, and is probably
# required for backwards compatibility with external tests against
# admin views.
request._dont_enforce_csrf_checks = not self.enforce_csrf_checks
# Request goes through middleware.
response = self.get_response(request)
# Simulate behaviors of most Web servers.
conditional_content_removal(request, response)
# Attach the originating request to the response so that it could be
# later retrieved.
response.wsgi_request = request
# We're emulating a WSGI server; we must call the close method
# on completion.
if response.streaming:
response.streaming_content = closing_iterator_wrapper(
response.streaming_content, response.close)
else:
request_finished.disconnect(close_old_connections)
response.close() # will fire request_finished
request_finished.connect(close_old_connections)
return response
0
Example 50
def request(self, **request):
"""
Similar to parent class, but returns the request object as soon as it
has created it.
"""
environ = {
'HTTP_COOKIE': self.cookies.output(header='', sep='; '),
'PATH_INFO': '/',
'QUERY_STRING': '',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': '',
'SERVER_NAME': 'testserver',
'SERVER_PORT': 80,
'SERVER_PROTOCOL': 'HTTP/1.1',
'wsgi.input': FakePayload(''),
}
environ.update(self.defaults)
environ.update(request)
return WSGIRequest(environ)