twisted.web.http.UNAUTHORIZED

Here are the examples of the python api twisted.web.http.UNAUTHORIZED taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

23 Examples 7

Example 1

Project: vumi Source File: test_http_relay.py
    @inlineCallbacks
    def test_http_relay_with_bad_basic_auth(self):
        def cb(request):
            request.setResponseCode(http.UNAUTHORIZED)
            return 'Not Authorized'

        yield self.setup_resource_with_callback(cb)
        yield self.app_helper.make_dispatch_inbound("hi")
        self.assertEqual([], self.app_helper.get_dispatched_outbound())

Example 2

Project: vumi Source File: test_rapidsms_relay.py
    @inlineCallbacks
    def test_rapidsms_relay_with_bad_basic_auth(self):
        def cb(request):
            request.setResponseCode(http.UNAUTHORIZED)
            return 'Not Authorized'

        yield self.setup_resource(cb)
        yield self.app_helper.make_dispatch_inbound("hi")
        self.assertEqual([], self.app_helper.get_dispatched_outbound())

Example 3

Project: vumi-go Source File: test_conversation_api.py
    @inlineCallbacks
    def test_invalid_auth(self):
        resp = yield http_request_full(
            self.get_conversation_url(self.conversation.key), data='',
            method='GET', headers={})
        self.assertEqual(resp.code, http.UNAUTHORIZED)

Example 4

Project: vumi-go Source File: test_conversation_api.py
    @inlineCallbacks
    def test_valid_auth(self):
        resp = yield http_request_full(
            self.get_conversation_url(self.conversation.key), data='',
            method='GET', headers=self.auth_headers)
        self.assertNotEqual(resp.code, http.UNAUTHORIZED)

Example 5

Project: vumi-go Source File: test_vumi_app.py
    @inlineCallbacks
    def test_missing_auth(self):
        url = '%s/%s/messages.json' % (self.url, self.conversation.key)

        queue = DeferredQueue()
        receiver = self.client.stream(
            TransportUserMessage, queue.put, queue.put, url)
        response = yield receiver.get_response()
        self.assertEqual(response.code, http.UNAUTHORIZED)
        self.assertEqual(response.headers.getRawHeaders('www-authenticate'), [
            'basic realm="Conversation Realm"'])

Example 6

Project: vumi-go Source File: test_vumi_app.py
    @inlineCallbacks
    def test_invalid_auth(self):
        url = '%s/%s/messages.json' % (self.url, self.conversation.key)

        queue = DeferredQueue()

        headers = Headers({
            'Authorization': ['Basic %s' % (base64.b64encode('foo:bar'),)],
        })

        receiver = self.client.stream(
            TransportUserMessage, queue.put, queue.put, url, headers)
        response = yield receiver.get_response()
        self.assertEqual(response.code, http.UNAUTHORIZED)
        self.assertEqual(response.headers.getRawHeaders('www-authenticate'), [
            'basic realm="Conversation Realm"'])

Example 7

Project: flumotion Source File: http.py
Function: handle_unauthorized
    def _handleUnauthorized(self, request, code):
        self.debug('client from %s is unauthorized, returning code %r' %
                   (request.getClientIP(), code))
        request.setHeader('content-type', 'text/html')
        request.setHeader('server', HTTP_SERVER_VERSION)
        request.setHeader('Connection', 'close')
        if self._domain and code == http.UNAUTHORIZED:
            request.setHeader('WWW-Authenticate',
                              'Basic realm="%s"' % self._domain)

        request.setResponseCode(code)

        # we have to write data ourselves,
        # since we already returned NOT_DONE_YET
        html = ERROR_TEMPLATE % {'code': code,
                                 'error': http.RESPONSES[code]}
        request.write(html)
        request.finish()

Example 8

Project: petmail Source File: web.py
    def getChild(self, esid, request):
        try:
            # esid tokens are single-use
            self.unclaimed_event_channels.remove(esid) # can raise KeyError
            return self.event_channels[esid]
        except KeyError:
            return resource.ErrorPage(http.UNAUTHORIZED, "bad esid",
                                      "Invalid esid")

Example 9

Project: petmail Source File: web.py
    def getChild(self, path, request):
        if path == "events":
            # Server-Sent Events use a GET with a use-once URL, not a token
            return self.event_dispatcher
        # everything else requires a token, check it here
        payload = json.loads(request.content.read())
        if not equal(payload["token"], self.access_token):
            return resource.ErrorPage(http.UNAUTHORIZED, "bad token",
                                      "Invalid token")
        rclass = handlers.get(path)
        if not rclass:
            return resource.ErrorPage(http.NOT_FOUND, "unknown method",
                                      "Unknown method")
        r = rclass(self.db, self.agent, self.event_dispatcher, payload)
        return r

Example 10

Project: e2openplugin-OpenWebif Source File: httpserver.py
	def render(self, request):
		host = request.getHost().host

		if (host == "localhost" or host == "127.0.0.1" or host == "::ffff:127.0.0.1") and not config.OpenWebif.auth_for_streaming.value:
			return self.resource.render(request)
		if self.login(request.getUser(), request.getPassword(), request.transport.socket.getpeername()[0]) == False:
			request.setHeader('WWW-authenticate', 'Basic realm="%s"' % ("OpenWebif"))
			errpage = resource.ErrorPage(http.UNAUTHORIZED,"Unauthorized","401 Authentication required")
			return errpage.render(request)
		else:
			return self.resource.render(request)

Example 11

Project: e2openplugin-OpenWebif Source File: httpserver.py
	def getChildWithDefault(self, path, request):
		session = request.getSession().sessionNamespaces
		host = request.getHost().host

		if ((host == "localhost" or host == "127.0.0.1" or host == "::ffff:127.0.0.1") and not config.OpenWebif.auth_for_streaming.value) or request.uri == "/web/getipv6":
			return self.resource.getChildWithDefault(path, request)
		if "logged" in session.keys() and session["logged"]:
			return self.resource.getChildWithDefault(path, request)
		if self.login(request.getUser(), request.getPassword(), request.transport.socket.getpeername()[0]) == False:
			request.setHeader('WWW-authenticate', 'Basic realm="%s"' % ("OpenWebif"))
			errpage = resource.ErrorPage(http.UNAUTHORIZED,"Unauthorized","401 Authentication required")
			return errpage
		else:
			session["logged"] = True
			return self.resource.getChildWithDefault(path, request)

Example 12

Project: vumi Source File: oldapi.py
Function: handle_raw_inbound_message
    def handle_raw_inbound_message(self, request_id, request):
        authorized, username = self.check_authorization(request)
        if not authorized:
            return self.finish_request(request_id, 'Not Authorized',
                                        code=http.UNAUTHORIZED)
        message = request.args.get('message', [None])[0]
        to_msisdns = request.args.get('to_msisdn', [])
        from_msisdn = request.args.get('from_msisdn', [None])[0]
        return_list = []
        for to_msisdn in to_msisdns:
            message_id = self.generate_message_id()
            content = message
            to_addr = to_msisdn
            from_addr = from_msisdn
            log.msg(
                'OldSimpleHttpTransport sending from %s to %s message "%s"' % (
                    from_addr, to_addr, content))

            self.publish_message(
                message_id=message_id,
                content=content,
                to_addr=to_addr,
                from_addr=from_addr,
                provider='vumi',
                transport_type='old_simple_http',
                transport_metadata={
                    'http_user': username,
                }
            )
            return_list.append({
                "message": message,
                "to_msisdn": to_msisdn,
                "from_msisdn": from_msisdn,
                "id": message_id,
                })
        return self.finish_request(request_id, json.dumps(return_list))

Example 13

Project: vumi Source File: oldapi.py
Function: handle_raw_inbound_message
    def handle_raw_inbound_message(self, request_id, request):
        authorized, username = self.check_authorization(request)
        if not authorized:
            return self.finish_request(request_id, 'Not Authorized',
                                        code=http.UNAUTHORIZED)
        opener = re.compile('{{ *')
        closer = re.compile(' *}}')
        template = request.args.get('template', [None])[0]
        template = opener.sub('%(template_', template)
        template = closer.sub(')s', template)
        to_msisdns = request.args.get('to_msisdn', [])
        from_msisdn = request.args.get('from_msisdn', [None])[0]
        template_args = self.extract_template_args(request.args,
                                                   len(to_msisdns))
        return_list = []
        for i, to_msisdn in enumerate(to_msisdns):
            message_id = self.generate_message_id()
            message = content = template % template_args[i]
            to_addr = to_msisdn
            from_addr = from_msisdn
            log.msg(('OldTemplateHttpTransport sending from %s to %s '
                     'message "%s"') % (from_addr, to_addr, content))
            self.publish_message(
                message_id=message_id,
                content=content,
                to_addr=to_addr,
                from_addr=from_addr,
                provider='vumi',
                transport_type='old_template_http',
                transport_metadata={
                    'http_user': username,
                }
            )
            return_list.append({
                "message": message,
                "to_msisdn": to_msisdn,
                "from_msisdn": from_msisdn,
                "id": message_id,
                })
        return self.finish_request(request_id, json.dumps(return_list))

Example 14

Project: vumi Source File: test_oldapi.py
    @inlineCallbacks
    def test_http_basic_auth(self):
        http_auth_config = self.config.copy()
        http_auth_config.update({
            'identities': {
                'username': 'password',
            }
        })
        transport = yield self.tx_helper.get_transport(http_auth_config)
        url = '%s%s?%s' % (
            transport.get_transport_url(),
            self.config['web_path'],
            urlencode({
                'to_msisdn': '123',
                'from_msisdn': '456',
                'message': 'hello',
            }))

        response = yield http_request_full(url, '', method='GET')
        self.assertEqual(response.code, http.UNAUTHORIZED)
        self.assertEqual([], self.tx_helper.get_dispatched_inbound())

        response = yield http_request_full(url, '', headers={
            'Authorization': ['Basic %s' % b64encode('username:password')]
        }, method='GET')
        self.assertEqual(response.code, http.OK)
        [msg] = self.tx_helper.get_dispatched_inbound()
        self.assertEqual(msg['content'], 'hello')
        self.assertEqual(msg['transport_metadata'], {
            'http_user': 'username',
        })

Example 15

Project: mamba-framework Source File: test_response.py
    def test_response_unauthorized_code_is_401(self):
        result = response.Unauthorized()
        self.assertEqual(result.code, http.UNAUTHORIZED)

Example 16

Project: mamba-framework Source File: response.py
Function: init
    def __init__(self, subject='Unauthorized', headers={}):
        super(Unauthorized, self).__init__(http.UNAUTHORIZED, subject, headers)

Example 17

Project: flumotion Source File: http.py
    def _authenticatedErrback(self, failure, request):
        failure.trap(errors.NotAuthenticatedError)
        self._handleUnauthorized(request, http.UNAUTHORIZED)
        return failure

Example 18

Project: flumotion Source File: test_http.py
    def deferAssertUnauthorized(self, httpauth, request):
        # make the resource authenticate the request, and verify
        # the request is not authorized

        def checkResult(res):
            errorCode = http.UNAUTHORIZED
            self.assertEquals(request.headers.get('content-type', ''),
                'text/html')
            self.assertEquals(request.headers.get('server', ''), HTTP_VERSION)
            self.assertEquals(request.response, errorCode)

            expected = ERROR_TEMPLATE % {
                'code': errorCode,
                'error': http.RESPONSES[errorCode]}
            self.assertEquals(request.data, expected)

            # don't swallow failures!
            return res

        d = httpauth.startAuthentication(request)
        d.addCallbacks(checkResult, checkResult)
        # make sure we get the authentication exception, too
        d = self.assertFailure(d, errors.NotAuthenticatedError)
        return d

Example 19

Project: flud Source File: ClientPrimitives.py
    def _getSendStore2(self, response, httpconn, nKu, host, port,
            filekey, datafile, metadata, params, headers):
        httpconn.close()
        if response.status == http.UNAUTHORIZED:
            loggerstor.info("SENDSTORE unauthorized, sending credentials")
            challenge = response.reason
            d = answerChallengeDeferred(challenge, self.node.config.Kr,
                    self.node.config.groupIDu, nKu.id(), headers)
            d.addCallback(self._sendRequest, nKu, host, port, filekey,
                    datafile, metadata, params)
            d.addErrback(self._errSendStore, "Couldn't answerChallenge", 
                    headers, nKu, host, port, filekey, datafile, metadata,
                    params, httpconn)
            return d
        elif response.status == http.CONFLICT:
            result = response.read()
            # XXX: client should check key before ever sending request
            raise BadCASKeyException("%s %s" 
                    % (response.status, response.reason))
        elif response.status != http.OK:
            result = response.read()
            raise failure.DefaultException( 
                    "received %s in SENDSTORE response: %s"
                    % (response.status, result))
        else:
            result = response.read()
            updateNode(self.node.client, self.config, host, port, nKu)
            loggerstor.info("received SENDSTORE response from %s: %s" 
                    % (self.dest, str(result)))
            return result

Example 20

Project: flud Source File: ClientPrimitives.py
    def _errSendRetrieve(self, err, nKu, host, port, factory, url, headers):
        loggerrtrv.info("_errSendRetrieve from %s:%s" % (host, str(port)))
        if err.check('twisted.internet.error.TimeoutError') or \
                err.check('twisted.internet.error.ConnectionLost'): #or \
                #err.check('twisted.internet.error.ConnectBindError'):
            loggerrtrv.info("_errSendRetrieve timeout/connlost from %s:%s" 
                    % (host, str(port)))
            self.timeoutcount += 1
            if self.timeoutcount < MAXTIMEOUTS:
                #print "RETR trying again [#%d]..." % self.timeoutcount
                return self._sendRequest(headers, nKu, host, port, url)
            else:
                #print "RETR timeout exceeded: %d" % self.timeoutcount
                pass
        elif hasattr(factory, 'status') and \
                eval(factory.status) == http.UNAUTHORIZED:
            loggerrtrv.info("SENDRETRIEVE unauthorized, sending credentials")
            challenge = err.getErrorMessage()[4:]
            d = answerChallengeDeferred(challenge, self.node.config.Kr,
                    self.node.config.groupIDu, nKu.id(), headers)
            d.addCallback(self._sendRequest, nKu, host, port, url)
            #d.addErrback(self._errSendRetrieve, nKu, host, port, factory,
            #       url, headers)
            return d
            #extraheaders = answerChallenge(challenge, self.node.config.Kr,
            #       self.node.config.groupIDu, nKu.id(), self.headers)
            #return self._sendRequest(nKu, host, port, url, extraheaders)
        # XXX: these remaining else clauses are really just for debugging...
        elif hasattr(factory, 'status'):
            if eval(factory.status) == http.NOT_FOUND:
                err = NotFoundException(err)
            elif eval(factory.status) == http.BAD_REQUEST:
                err = BadRequestException(err)
        elif err.check('twisted.internet.error.ConnectionRefusedError'):
            pass # fall through to return err
        else:
            print "non-timeout, non-UNAUTH RETR request error: %s" % err
        # XXX: updateNode
        loggerrtrv.info("SENDRETRIEVE failed")
        raise err

Example 21

Project: flud Source File: ClientPrimitives.py
    def _errSendDelete(self, err, nKu, host, port, factory, url, headers):
        if err.check('twisted.internet.error.TimeoutError') or \
                err.check('twisted.internet.error.ConnectionLost'):
            #print "DELETE request error: %s" % err.__class__.__name__
            self.timeoutcount += 1
            if self.timeoutcount < MAXTIMEOUTS:
                #print "trying again [#%d]...." % self.timeoutcount
                return self._sendRequest(headers, nKu, host, port, url) 
        elif hasattr(factory, 'status') and \
                eval(factory.status) == http.UNAUTHORIZED and \
                self.authRetry < MAXAUTHRETRY:
            # XXX: add this authRetry stuff to all the other op classes (so
            # that we don't DOS ourselves and another node
            self.authRetry += 1
            loggerdele.info("SENDDELETE unauthorized, sending credentials")
            challenge = err.getErrorMessage()[4:]
            d = answerChallengeDeferred(challenge, self.node.config.Kr,
                    self.node.config.groupIDu, nKu.id(), headers)
            d.addCallback(self._sendRequest, nKu, host, port, url)
            d.addErrback(self._errSendDelete, nKu, host, port, factory,
                    url, headers)
            return d
        elif hasattr(factory, 'status'):
            # XXX: updateNode
            loggerdele.info("SENDDELETE failed")
            if eval(factory.status) == http.NOT_FOUND:
                err = NotFoundException(err)
            elif eval(factory.status) == http.BAD_REQUEST:
                err = BadRequestException(err)
            raise err
        return err

Example 22

Project: flud Source File: ClientPrimitives.py
    def _errSendVerify(self, err, nKu, host, port, factory, url, headers):
        loggervrfy.debug("got vrfy err")
        if err.check('twisted.internet.error.TimeoutError') or \
                err.check('twisted.internet.error.ConnectionLost'):
            #print "VERIFY request error: %s" % err.__class__.__name__
            self.timeoutcount += 1
            if self.timeoutcount < MAXTIMEOUTS:
                #print "trying again [#%d]...." % self.timeoutcount
                return self._sendRequest(headers, nKu, host, port, url) 
        elif hasattr(factory, 'status') and \
                eval(factory.status) == http.UNAUTHORIZED:
            loggervrfy.info("SENDVERIFY unauthorized, sending credentials")
            challenge = err.getErrorMessage()[4:]
            d = answerChallengeDeferred(challenge, self.node.config.Kr,
                    self.node.config.groupIDu, nKu.id(), headers)
            d.addCallback(self._sendRequest, nKu, host, port, url)
            d.addErrback(self._errVerify, nKu, host, port, factory,
                    url, headers, challenge)
            #d.addErrback(self._errSendVerify, nKu, host, port, factory,
            #       url, headers)
            return d
        elif hasattr(factory, 'status'):
            # XXX: updateNode
            loggervrfy.info("SENDVERIFY failed: %s" % err.getErrorMessage())
            if eval(factory.status) == http.NOT_FOUND:
                err = NotFoundException(err)
            elif eval(factory.status) == http.BAD_REQUEST:
                err = BadRequestException(err)
        raise err

Example 23

Project: txloadbalancer Source File: pages.py
Function: render
    def render(self, request):
        request.setResponseCode(http.UNAUTHORIZED)
        request.setHeader(
            'WWW-authenticate', 'basic realm="PyDirector"')
        return self.unauthorizedPage.render(request)