def __init__(self, node=None, status=503, description=''):
HttpResponse.__init__(self, status=status)
Exception.__init__(self)
self.message = (STATUS_CODE_TEXT.get(status, 'Error %s' % status) +
'\n' + (description or ''))
self.__node = node
self.payload = {'error': STATUS_CODE_TEXT.get(status),
'description': description}
def get_context(self):
return {
'message': self.message,
'http_status_code': self.status_code,
'http_status_text': STATUS_CODE_TEXT.get(self.status_code, 'UNKNOWN'),
'http_exception': self,
}
def generate_docs_from_configuration(self, configuration):
docs = []
for c in configuration:
if c[-1]:
conf_value = c[-1].get('request_data', {})
if callable(conf_value):
request_data = conf_value.__name__
else:
request_data = conf_value
comment = c[-1].get('comment', None)
else:
comment = None
request_data = {}
doc = '%(method)s %(url)s %(status_code)s "%(status)s" ' \
'%(request_data)r' % {
'method': c[2],
'url': c[0],
'status_code': c[1],
'status': STATUS_CODE_TEXT.get(c[1], 'UNKNOWN'),
'request_data': request_data
}
if comment:
doc = '%s %s' % (doc, comment)
docs.append(doc)
return docs
def __new__(mcs, name, bases, attrs):
cls = super(GenerateTestMethodsMeta, mcs).__new__(
mcs, name, bases, attrs)
# If this metaclass is instantiating something found in one of these modules
# then we skip generation of test cases, etc. Without this, we will erroneously
# detect error case of TESTS_CONFIGURATION being None
# Also, skip certain classes based on class name
skip_modules = ['skd_smoke', ]
skip_names = ['NewBase', 'SmokeTestCase', ]
if attrs.get('__module__') in skip_modules or name in skip_names:
return cls
# Build a dict of all the 'defaults' they defined to go with their test class
defined_defaults = {}
for defaultable in DEFAULTABLE_PARAMS:
attr_name = "default_" + defaultable
if hasattr(cls, attr_name):
defined_defaults[attr_name] = getattr(cls, attr_name)
# noinspection PyBroadException
try:
config = prepare_configuration(cls.TESTS_CONFIGURATION, defined_defaults)
except Exception:
fail_method = generate_fail_test_method(traceback.format_exc())
fail_method_name = cls.FAIL_METHOD_NAME
fail_method.__name__ = str(fail_method_name)
setattr(cls, fail_method_name, fail_method)
else:
for urlname, status, method, data in config:
# For each config item, if it doesnt exist in config tuple's "data" then
# see if user has defined a default on the test class
find_conf = lambda name: data.get(name, getattr(cls, "default_" + name, None))
comment = find_conf('comment')
initialize = find_conf('initialize')
url_args = find_conf('url_args')
url_kwargs = find_conf('url_kwargs')
request_data = find_conf('request_data')
get_user_credentials = find_conf('user_credentials')
redirect_to = find_conf('redirect_to')
status_text = STATUS_CODE_TEXT.get(status, 'UNKNOWN')
test_method_name = prepare_test_name(urlname, method, status)
test_method = generate_test_method(
urlname, status, method, initialize, url_args, url_kwargs,
request_data, get_user_credentials, redirect_to
)
test_method.__name__ = str(test_method_name)
test_method.__doc__ = prepare_test_method_doc(
method, urlname, status, status_text, request_data,
comment
)
setattr(cls, test_method_name, test_method)
return cls
def status_text(self):
"""
Returns reason text corresponding to our HTTP response status code.
Provided for convenience.
"""
# TODO: Deprecate and use a template tag instead
# TODO: Status code text for RFC 6585 status codes
return STATUS_CODE_TEXT.get(self.status_code, '')
def request(self, host, handler, request_body, verbose=0):
self.verbose = verbose
response = self.client.post(handler, request_body, content_type="text/xml")
status_code, msg, headers = response.status_code, STATUS_CODE_TEXT.get(response.status_code, str(response.status_code)), response.items()
if response.status_code != 200:
raise ProtocolError(host + handler, status_code, msg, headers)
return self._parse_response(response.content, None)
def request(self, host, handler, request_body, verbose=0):
self.verbose = verbose
response = self.client.post(handler,
request_body,
content_type="text/xml")
status_code, msg, headers = response.status_code, STATUS_CODE_TEXT.get(
response.status_code, str(response.status_code)), response.items()
if response.status_code != 200:
raise ProtocolError(host + handler, status_code, msg, headers)
return self._parse_response(response.content, None)
def do_render(template=None):
if template:
template = 'http_responses/%s.html' % (template,)
else:
template = 'http_responses/%i.html' % (exception.http_code, ),
return self.render(
request,
template,
{
'http_code': exception.http_code,
'http_message': STATUS_CODE_TEXT.get(exception.http_code, 'UNKNOWN'), # TRANSLATE IN TEMPLATE
'http_response_exception': exception,
}
)
def process_response(self, request, response):
if 300 <= int(response.status_code) < 400:
redirect_to = response.get('Location', None)
if redirect_to:
try: # Django >= 1.6
reason_phrase = response.reason_phrase
except AttributeError:
reason_phrase = STATUS_CODE_TEXT.get(response.status_code,
'UNKNOWN STATUS CODE')
status_line = '%s %s' % (response.status_code, reason_phrase)
cookies = response.cookies
context = {'redirect_to': redirect_to, 'status_line': status_line}
response = render_to_response('debug_toolbar/redirect.html', context)
response.cookies = cookies
return response
def process_response(self, request, response):
if 300 <= int(response.status_code) < 400:
redirect_to = response.get('Location', None)
if redirect_to:
try: # Django >= 1.6
reason_phrase = response.reason_phrase
except AttributeError:
reason_phrase = STATUS_CODE_TEXT.get(
response.status_code, 'UNKNOWN STATUS CODE'
)
status_line = '%s %s' % (response.status_code, reason_phrase)
cookies = response.cookies
context = {'redirect_to': redirect_to, 'status_line': status_line}
response = render_to_response('debug_toolbar/redirect.html', context)
response.cookies = cookies
return response
def __new__(mcs, name, bases, attrs):
cls = super(GenerateTestMethodsMeta, mcs).__new__(
mcs, name, bases, attrs)
# Ensure test method generation is only performed for subclasses of
# GenerateTestMethodsMeta (excluding GenerateTestMethodsMeta class
# itself).
parents = [b for b in bases if isinstance(b, GenerateTestMethodsMeta)]
if not parents:
return cls
# noinspection PyBroadException
try:
config = prepare_configuration(cls.TESTS_CONFIGURATION)
except Exception:
fail_method = generate_fail_test_method(traceback.format_exc())
fail_method_name = cls.FAIL_METHOD_NAME
fail_method.__name__ = str(fail_method_name)
setattr(cls, fail_method_name, fail_method)
else:
for urlname, status, method, data in config:
comment = data.get('comment', None)
initialize = data.get('initialize', None)
url_args = data.get('url_args', None)
url_kwargs = data.get('url_kwargs', None)
request_data = data.get('request_data', None)
get_user_credentials = data.get('user_credentials', None)
redirect_to = data.get('redirect_to', None)
status_text = STATUS_CODE_TEXT.get(status, 'UNKNOWN')
test_method_name = prepare_test_name(urlname, method, status)
test_method = generate_test_method(
urlname, status, method, initialize, url_args, url_kwargs,
request_data, get_user_credentials, redirect_to
)
test_method.__name__ = str(test_method_name)
test_method.__doc__ = prepare_test_method_doc(
method, urlname, status, status_text, request_data,
comment
)
setattr(cls, test_method_name, test_method)
return cls
def __new__(mcs, name, bases, attrs):
cls = super(GenerateTestMethodsMeta,
mcs).__new__(mcs, name, bases, attrs)
# Ensure test method generation is only performed for subclasses of
# GenerateTestMethodsMeta (excluding GenerateTestMethodsMeta class
# itself).
parents = [b for b in bases if isinstance(b, GenerateTestMethodsMeta)]
if not parents:
return cls
# noinspection PyBroadException
try:
config = prepare_configuration(cls.TESTS_CONFIGURATION)
except Exception:
fail_method = generate_fail_test_method(traceback.format_exc())
fail_method_name = cls.FAIL_METHOD_NAME
fail_method.__name__ = str(fail_method_name)
setattr(cls, fail_method_name, fail_method)
else:
for urlname, status, method, data in config:
comment = data.get('comment', None)
initialize = data.get('initialize', None)
get_url_kwargs = data.get('url_kwargs', None)
request_data = data.get('request_data', None)
get_user_credentials = data.get('user_credentials', None)
redirect_to = data.get('redirect_to', None)
status_text = STATUS_CODE_TEXT.get(status, 'UNKNOWN')
test_method_name = prepare_test_name(urlname, method, status)
test_method = generate_test_method(urlname, status, method,
initialize, get_url_kwargs,
request_data,
get_user_credentials,
redirect_to)
test_method.__name__ = str(test_method_name)
test_method.__doc__ = prepare_test_method_doc(
method, urlname, status, status_text, request_data,
comment)
setattr(cls, test_method_name, test_method)
return cls
def process_response(self, request, response):
if 300 <= int(response.status_code) < 400:
redirect_to = response.get("Location", None)
if redirect_to:
try: # Django >= 1.6
reason_phrase = response.reason_phrase
except AttributeError:
reason_phrase = STATUS_CODE_TEXT.get(
response.status_code, "UNKNOWN STATUS CODE")
status_line = "%s %s" % (response.status_code, reason_phrase)
cookies = response.cookies
context = {
"redirect_to": redirect_to,
"status_line": status_line
}
response = render_to_response("debug_toolbar/redirect.html",
context)
response.cookies = cookies
return response
def raise_http_error(url, code):
raise HTTPError(url, code, STATUS_CODE_TEXT.get(code, ''), None, None)
def __call__(self, environ, start_response):
""" Hijack the main loop from the original thread and listen on events on Redis and Websockets"""
websocket = None
request = None
subscriber = self.Subscriber(self._redis_connection)
try:
self.assure_protocol_requirements(environ)
request = WSGIRequest(environ)
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))
websocket = self.upgrade_websocket(environ, start_response)
logger.debug('Subscribed to channels: {0}'.format(', '.join(channels)))
subscriber.set_pubsub_channels(request, channels)
subscriber.user_connect(request)
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))
if private_settings.WS4REDIS_HEARTBEAT:
websocket.send(private_settings.WS4REDIS_HEARTBEAT)
except WebSocketError as excpt:
logger.warning('WebSocketError: ', 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: ', exc_info=sys.exc_info())
response = http.HttpResponseBadRequest(content=excpt)
except PermissionDenied as excpt:
logger.warning('PermissionDenied: ', exc_info=sys.exc_info())
response = http.HttpResponseForbidden(content=excpt)
except Exception as excpt:
logger.error('Other Exception: ', exc_info=sys.exc_info())
response = http.HttpResponseServerError(content=excpt)
else:
response = http.HttpResponse()
if websocket:
subscriber.user_disconnect(request)
websocket.close(code=1001, message='Websocket Closed')
if hasattr(start_response, 'im_self') and not start_response.im_self.headers_sent:
logger.warning('Staring late response on websocket')
status_text = STATUS_CODE_TEXT.get(response.status_code, 'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
start_response(force_str(status), response._headers.values())
logger.info('Finish long living response with status code: '.format(response.status_code))
return response
def __init__(self, node=None, status=503, description=''):
HttpResponse.__init__(self, status=status)
Exception.__init__(self)
self.message = description or STATUS_CODE_TEXT.get(status)
self.__node = node
self.content = str(self)
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))
websocket = self.upgrade_websocket(environ, start_response)
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))
if private_settings.WS4REDIS_HEARTBEAT:
websocket.send(private_settings.WS4REDIS_HEARTBEAT)
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 = STATUS_CODE_TEXT.get(response.status_code, 'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
start_response(force_str(status), response._headers.values())
logger.info('Finish non-websocket response with status code: {}'.format(response.status_code))
return response
from django.core.handlers.wsgi import STATUS_CODE_TEXT
from restlib2.structures import AttrDict
# New codes - http://tools.ietf.org/html/draft-nottingham-http-new-status-04
STATUS_CODE_TEXT.setdefault(422, 'UNPROCESSABLE ENTITY')
STATUS_CODE_TEXT.setdefault(428, 'PRECONDITION REQUIRED')
STATUS_CODE_TEXT.setdefault(429, 'TOO MANY REQUESTS')
STATUS_CODE_TEXT.setdefault(431, 'REQUEST HEADER FIELDS TOO LARGE')
STATUS_CODE_TEXT.setdefault(511, 'NETWORK AUTHENTICATION REQUIRED')
# Invert dict for reference by name
codes = AttrDict('HTTP Status Codes', [
(y.lower().replace(' ', '_'), x) for x, y in STATUS_CODE_TEXT.items()
])
# PATCH Method introduced - http://tools.ietf.org/html/rfc5789
methods = AttrDict('HTTP Methods',
GET = 'GET',
HEAD = 'HEAD',
OPTIONS = 'OPTIONS',
POST = 'POST',
PUT = 'PUT',
DELETE = 'DELETE',
PATCH = 'PATCH',
)
def render_error(request, status_code, template_name='ui/error.html'):
"""Generic base for rendering error pages."""
message = status_text.get(status_code)
context = {'code': status_code, 'message': message}
return render(request, template_name, context, status=status_code)
def raise_http_error(url, code):
raise HTTPError(url, code, STATUS_CODE_TEXT.get(code, ''), None, None)
def status_text(self):
"""
Return reason text corresponding to our HTTP response status code.
Provided for convenience.
"""
return STATUS_CODE_TEXT.get(self.status, '')
def render_error(request, status_code, template_name='ui/error.html'):
"""Generic base for rendering error pages."""
message = status_text.get(status_code)
context = {'code': status_code, 'message': message}
return render(request, template_name, context, status=status_code)
elif fd == redis_fd:
response = redis_store.parse_response()
if response[0] == 'message':
message = response[2]
websocket.send(message)
else:
logger.error('Invalid file descriptor: {0}'.format(fd))
except WebSocketError, excpt:
logger.warning('WebSocketError: ', exc_info=sys.exc_info())
response = HttpResponse(status=1001, content='Websocket Closed')
except UpgradeRequiredError:
logger.info('Websocket upgrade required')
response = HttpResponseBadRequest(status=426, content=excpt)
except HandshakeError, excpt:
logger.warning('HandshakeError: ', exc_info=sys.exc_info())
response = HttpResponseBadRequest(content=excpt)
except Exception, excpt:
logger.error('Other Exception: ', exc_info=sys.exc_info())
response = HttpResponseServerError(content=excpt)
else:
response = HttpResponse()
if websocket:
websocket.close(code=1001, message='Websocket Closed')
if hasattr(start_response,
'im_self') and not start_response.im_self.headers_sent:
status_text = STATUS_CODE_TEXT.get(response.status_code,
'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
start_response(force_str(status), response._headers.values())
return response
def status_text(self):
"""
Return reason text corresponding to our HTTP response status code.
Provided for convenience.
"""
return STATUS_CODE_TEXT.get(self.status, '')
redis_store.publish_message(message)
elif fd == redis_fd:
response = redis_store.parse_response()
if response[0] == 'message':
message = response[2]
websocket.send(message)
else:
logger.error('Invalid file descriptor: {0}'.format(fd))
except WebSocketError, excpt:
logger.warning('WebSocketError: ', exc_info=sys.exc_info())
response = HttpResponse(status=1001, content='Websocket Closed')
except UpgradeRequiredError:
logger.info('Websocket upgrade required')
response = HttpResponseBadRequest(status=426, content=excpt)
except HandshakeError, excpt:
logger.warning('HandshakeError: ', exc_info=sys.exc_info())
response = HttpResponseBadRequest(content=excpt)
except Exception, excpt:
logger.error('Other Exception: ', exc_info=sys.exc_info())
response = HttpResponseServerError(content=excpt)
else:
response = HttpResponse()
if websocket:
redis_store.unsubscribe(request, access_key)
websocket.close(code=1001, message='Websocket Closed')
if hasattr(start_response, 'im_self') and not start_response.im_self.headers_sent:
status_text = STATUS_CODE_TEXT.get(response.status_code, 'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
start_response(force_str(status), response._headers.values())
return response
from django.core.handlers.wsgi import STATUS_CODE_TEXT
from restlib2.structures import AttrDict
STATUS_CODE_TEXT.setdefault(422, 'UNPROCESSABLE ENTITY')
# http://tools.ietf.org/html/rfc6585
STATUS_CODE_TEXT.setdefault(428, 'PRECONDITION REQUIRED')
STATUS_CODE_TEXT.setdefault(429, 'TOO MANY REQUESTS')
STATUS_CODE_TEXT.setdefault(431, 'REQUEST HEADER FIELDS TOO LARGE')
STATUS_CODE_TEXT.setdefault(511, 'NETWORK AUTHENTICATION REQUIRED')
# http://tools.ietf.org/html/draft-tbray-http-legally-restricted-status-02
STATUS_CODE_TEXT.setdefault(451, 'UNAVAILABLE FOR LEGAL REASONS')
# Invert dict for reference by name
codes = AttrDict('HTTP Status Codes',
[(y, x) for x, y in STATUS_CODE_TEXT.items()])
# PATCH Method introduced - http://tools.ietf.org/html/rfc5789
methods = AttrDict('HTTP Methods',
GET = 'GET',
HEAD = 'HEAD',
OPTIONS = 'OPTIONS',
POST = 'POST',
PUT = 'PUT',
DELETE = 'DELETE',
PATCH = 'PATCH',
)
def __init__(self, node=None, status=503, description=''):
HttpResponse.__init__(self, status=status)
Exception.__init__(self)
self.message = description or STATUS_CODE_TEXT.get(status)
self.__node = node
self.content = str(self)
