django.core.handlers.wsgi.WSGIRequest

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 7

Page 1 Selected Page 2

Example 1

Project: django-better-cache Source File: tasks.py
Function: run
    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)

Example 2

Project: armstrong.esi Source File: http_client.py
Function: call
    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

Example 3

Project: django-moderation Source File: request_factory.py
Function: request
    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)

Example 4

Project: kuma Source File: test_misc.py
Function: make_request
def _make_request(path):
    req = WSGIRequest({
        'REQUEST_METHOD': 'GET',
        'PATH_INFO': path,
        'wsgi.input': StringIO()})
    req.user = AnonymousUser()
    return req

Example 5

Project: django-perftools Source File: slowreq.py
Function: call
    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()

Example 6

Project: fjord Source File: urlresolvers.py
Function: init
    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

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',
    })

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'})

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'))

Example 10

Project: djng Source File: wsgi.py
Function: call
    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

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

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')

Example 13

Project: django-lfc Source File: utils.py
Function: request
    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)

Example 14

Project: django-perftools Source File: querycount.py
Function: call
    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)

Example 15

Project: foodnetwork Source File: tests.py
Function: request
    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)

Example 16

Project: djangobench Source File: benchmark.py
Function: make_request
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)

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))

Example 18

Project: pytest_django Source File: client.py
Function: request
    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)

Example 19

Project: django-dataforms Source File: test_helpers.py
Function: request
	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)

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()

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

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'

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

Example 24

Project: django-localeurl Source File: test_utils.py
Function: request
    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)

Example 25

Project: django-websocket Source File: utils.py
Function: request
    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)

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\\"}"]')

Example 27

Project: django-nonrel Source File: client.py
Function: call
    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

Example 28

Project: geraldo Source File: client.py
Function: call
    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

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"

Example 30

Project: django-mothertongue Source File: test_utils.py
Function: request
    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

Example 31

Project: jmbo Source File: tests.py
Function: request
    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

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

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)

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(),
    }

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)

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

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()

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)

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

Example 40

Project: django-snippetscream Source File: _963.py
Function: request
    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

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

Example 42

Project: djng Source File: djng_old.py
Function: call
    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

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

Example 44

Project: panya Source File: tests.py
Function: request
    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

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

Example 46

Project: talk.org Source File: client.py
Function: call
    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

Example 47

Project: GAE-Bulk-Mailer Source File: client.py
Function: request
    def request(self, **request):
        "Construct a generic request object."
        return WSGIRequest(self._base_environ(**request))

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

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

Example 50

Project: djangobench Source File: benchmark.py
Function: request
    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)
See More Examples - Go to Next Page
Page 1 Selected Page 2