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
3
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())
3
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())
3
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)
3
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)
3
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"'])
3
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"'])
3
Example 7
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()
3
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")
3
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
3
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)
3
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)
0
Example 12
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))
0
Example 13
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))
0
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',
})
0
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)
0
Example 16
def __init__(self, subject='Unauthorized', headers={}):
super(Unauthorized, self).__init__(http.UNAUTHORIZED, subject, headers)
0
Example 17
Project: flumotion Source File: http.py
def _authenticatedErrback(self, failure, request):
failure.trap(errors.NotAuthenticatedError)
self._handleUnauthorized(request, http.UNAUTHORIZED)
return failure
0
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
0
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
0
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
0
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
0
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
0
Example 23
def render(self, request):
request.setResponseCode(http.UNAUTHORIZED)
request.setHeader(
'WWW-authenticate', 'basic realm="PyDirector"')
return self.unauthorizedPage.render(request)