Python wsgi.STATUS_CODE_TEXT类代码示例

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

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

 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 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 raise_http_error(url, code):
    raise HTTPError(url, code, STATUS_CODE_TEXT.get(code, ''), None, None)