def write_error(self, *args, **kwargs):
     '''
     Must override base write error to stop uncaught
     HTTP errors from clearing CORS headers
     '''
     self.write_cors_headers()
     RequestHandler.write_error(self, *args, **kwargs)

    def check_xsrf_cookie(self):
        if self.application.testing_key \
        and self.request.headers.get('X-Testing-Key') \
        == self.application.testing_key:
            return

        RequestHandler.check_xsrf_cookie(self)

 def finish(self, chunk=None):
     '''
     重写服务的finish,　并存储返回值
     '''
     
     RequestHandler.finish(self, chunk=chunk)
     self.return_value = chunk

    def render(self, template_name, **kwargs):
        params = dict()
        for key, val in self.request.arguments.items():
            params[key] = ','.join(val) if isinstance(val, list) else val

        kwargs["params"] = params
        kwargs["json_dict"] = json_to_dict
        RequestHandler.render(self, template_name, **kwargs)

 def write_error(self, status_code, **kwargs):
     try:
         error_env = Environment(loader = FileSystemLoader(self.__project_path + '/public'))
         temp = error_env.get_template(str(status_code) + '.html')
         self.write(temp.render())
     except TemplateNotFound:
         RequestHandler.write_error(self, status_code, **kwargs)

 def __init__(self, application, request):
     RequestHandler.__init__(self, application, request)
     self._current_user = None
     self.middleware_manager = MiddlewareManager(self)
     self._is_threaded = False
     self._is_whirlwind_finished = False
     self.view = {}

    def write(self, payload, passthru=False):
        if passthru:
            return RequestHandler.write(self, payload)

        self.set_header('Content-Type', 'application/json; charset=UTF-8')
        RequestHandler.write(self, json.dumps(payload, indent=options.debug and 2 or None,
                                              default=_ToJSONMixin.json_default))

    def _handle_request_exception(self, exc):

        options = {
            "user": {"id": self.request.remote_ip},
            "context": self._get_context(),
            "request": {
                "url": self.request.full_url(),
                "method": self.request.method,
                "arguments": self.request.arguments,
            },
            "severity_reason": {
                "type": "unhandledExceptionMiddleware",
                "attributes": {
                    "framework": "Tornado"
                }
            }
        }

        # Notify bugsnag, unless it's an HTTPError that we specifically want
        # to ignore
        should_notify_bugsnag = True
        if type(exc) == HTTPError:
            ignore_status_codes = self.bugsnag_ignore_status_codes()
            if ignore_status_codes and exc.status_code in ignore_status_codes:
                should_notify_bugsnag = False

        if should_notify_bugsnag:
            bugsnag.auto_notify(exc, **options)

        # Call the parent handler
        RequestHandler._handle_request_exception(self, exc)

 def write_error(self, status_code, **kwargs):
     if status_code == 404:
         self.render('404.html')
     elif status_code >= 500 and status_code < 600:
         self.render('500.html')
     else:
         RequestHandler.write_error(self, status_code, **kwargs)

 def initialize(self, html_template=None, js_template=None, cors_origins=None):
     RequestHandler.initialize(self)
     self.set_cors_methods("OPTIONS,GET,POST")
     if cors_origins:
         self.set_cors_whitelist(cors_origins)
     self._html_template = html_template
     self._js_template = js_template

 def prepare(self):
     """
         Prepare the request
     """
     RequestHandler.prepare(self)
     self.model.session.expunge_all() # Always start a request fresh.
     self._call_preprocessor()

    def test_on_request(self):

        app = Application()
        request = HTTPRequest('POST', '/collector?hello=world', body=b"foo=bar&bar=foo", headers={'Content-Type': 'application/x-www-form-urlencoded'}, connection=get_dummy_connection())

        handler = RequestHandler(app, request)
        handler.run = Run()

        self.collector.on_request(handler, handler.run)

        self.assertEquals({
            'body_arguments': {},
            'cookies': '',
            'headers': {'Content-Type': 'application/x-www-form-urlencoded'},
            'host': '127.0.0.1',
            'method': 'POST',
            'path': '/collector',
            'protocol': 'http',
            'query': 'hello=world',
            'body': 'foo=bar&bar=foo',
            'query_arguments': {'hello': ['world']},
            'remote_ip': '127.0.0.1',
            'uri': '/collector?hello=world',
            'version': 'HTTP/1.0',
            'controller': {'class': False, 'file': False, 'line': False, 'method': False},
            'route': False,
            'status_code': False,
        }, handler.run.get_metric('request'))

 def write(self, chunk):
     if isinstance(chunk, dict) and self.settings.get('debug'):
         RequestHandler.write(self, json.dumps(chunk, indent=4))
     else:
         RequestHandler.write(self, chunk)
     if isinstance(chunk, dict):
         self.set_header('Content-Type', self._ct('json'))

 def _execute(self, transforms, *args, **kwargs):
     ''' select base handler for self '''
     with LogicContext():
         if isinstance(self, WebSocketHandler):
             WebSocketHandler._execute(self, transforms, *args, **kwargs)
         elif isinstance(self, RequestHandler):
             RequestHandler._execute(self, transforms, *args, **kwargs)

def set_user_cookie(app, request, username):
    from tornado.web import RequestHandler
    r = RequestHandler(app, request)
    r.set_secure_cookie('user', username)
    authcookie = r._new_cookies[0]
    cookiestring = authcookie.items()[0][1]
    request.cookies.update({'user': cookiestring})
    return request

 def write_error(self, status_code, **kwargs):
     if 'exc_info' in kwargs:
         typ, value, tb = kwargs['exc_info']
         if isinstance(value, PermissionError):
             self.set_status(403)
             self.write('PermissionError')
             return
     RequestHandler.write_error(self, status_code, **kwargs)

 def write_error(self, code, **kwargs):
     exc_type, exc_value, _exc_tb = kwargs.get('exc_info', [None] * 3)
     if exc_type is not None and issubclass(exc_type, HTTPError):
         self.set_header('Content-Type', 'text/plain')
         if exc_value.log_message:
             self.write(exc_value.log_message + '\n')
     else:
         RequestHandler.write_error(self, code, **kwargs)

	def __init__(self, application, request):
		RequestHandler.__init__(self, application, request)
		self._current_user = None
		self.middleware_manager = MiddlewareManager(self)
		self._is_threaded = False
		self._is_whirlwind_finished = False
		self.view = dotdict()
		self.db = Mongo.db.ui #@UndefinedVariable

 def render(self, template_name, **kwargs):
     kwargs.update(session=self.session)
     kwargs.update(config=self.configuration)
     kwargs.update(current_page=self.current_page)
     kwargs.update(has_nav=self.has_nav)
     kwargs.update(html5=self.html5)
     kwargs.update(rendered_time=self.rendered_time)
     kwargs.update(prefix_url=self.prefix_url)
     RequestHandler.render(self, template_name, **kwargs)

 def __init__(self, application, request, **kwargs):
     RequestHandler.__init__(self, application, request, **kwargs)
     _headers = self.request.headers
     self.mn_server = _headers.get(MN_INSTANCE_SERVER,'')
     self.mn_port = _headers.get(MN_INSTANCE_PORT,'')
     self.ProductID = _headers.get(MN_PRODUCT_ID,'')
     self._instance = application._instance
     self._search_count = 2
     self._not_found_callback = self._response_no_agent