def fetch(self, url, **kwargs):
        # init HTTPRequest
        session = HTTPRequest('', follow_redirects=False)
        self.init_request(session, url, **kwargs)

        instance_parameters = copy.deepcopy(self._req_params) # 参数

        http_client = AsyncHTTPClient()


        while True:
            self.pre_request(session, url, **kwargs)
            try:
                response = yield http_client.fetch(session, **instance_parameters)
                break
            except HTTPError as httperr:
                # redirects handler
                if httperr.code > 300 and httperr.code < 400:
                    self.post_request(session, httperr.response, url, **kwargs)
                    session.url = httperr.response.effective_url


        del instance_parameters
        self.post_request(session, response, url, **kwargs)

        raise gen.Return(response)

def open_root_url(step):
    request = HTTPRequest(ROOT_URL + 'user/state/')
    if world.cookie:
        request.headers["Cookie"] = world.cookie
    resp = world.browser.fetch(request)
    world.response = json_decode(resp.body)
    world.response_header = resp.headers

 def get_request(self, url, method='GET', body=None, headers=None):
     url = self.get_url(url)
     req = HTTPRequest(url, method=method, body=body)
     req.headers['Content-Type'] = 'application/json; charset=UTF-8'
     if headers:
         req.headers.update(headers)
     return req

 def getData(self,url,method,data,cookie):
     try:
         client = HTTPClient()
         request = HTTPRequest(
                 url,
                 method=method,
                 headers={
                     'Cookie':cookie
                 }
             )
         if data and method=="GET":
             url = url_concat(url,data)
             url = url.replace("+","%20")
             request.url = url
         elif data and method=="POST":
             realData = {}
             for i in data:
                 realData[i[0]] = i[1]
             data = urllib.urlencode(realData)
             request.body = data
         response = client.fetch(request)
         return json.loads(response.body)
     except Exception,e:
         # print str(e)
         #traceback.print_exc()
         return str(e)

    def _create_http_request(self, method, host, port, path,
                             params=None, data=None, **kwargs):

        url = 'http://{host}:{port}{uri}'.format(host=host, port=port, uri=path)

        if params and isinstance(params, dict):
            url += '?' + urlencode(params)

        request = HTTPRequest(
            method=method,
            url=url,
            allow_nonstandard_methods=True,
            connect_timeout=self._connect_timeout,
            request_timeout=self._request_timeout,
            **kwargs
        )

        if data and method in ['POST', 'PUT', 'PATCH']:
            try:
                request.body = json.dumps(data)
            except TypeError as e:
                logging.error(str(e))
                raise DBApiError(e)

        return request

 def fetch(self, request, callback, **kwargs):
     if not isinstance(request, HTTPRequest):
         request = HTTPRequest(url=request, **kwargs)
     if not isinstance(request.headers, HTTPHeaders):
         request.headers = HTTPHeaders(request.headers)
     callback = stack_context.wrap(callback)
     _HTTPConnection(self.io_loop, request, callback)

 def getData(self,url,method,data,cookie):
     try:
         client = HTTPClient()
         request = HTTPRequest(
                 url,
                 method=method,
                 headers={
                     'Cookie':cookie
                 }
             )
         if data and method=="GET":
             data = json.loads(data)
             url = url_concat(url,data)
             request.url = url
         elif data and method=="POST":
             data = json.loads(data)
             print data
             data = urllib.urlencode(data)
             request.body = data
         # print request.url
         response = client.fetch(request)
         return response.body
     except Exception,e:
         # print str(e)
         return None

    def fetch(self, request, callback, **kwargs):
        if not isinstance(request, HTTPRequest):
            request = HTTPRequest(url=request, **kwargs)
        # We're going to modify this (to add Host, Accept-Encoding, etc),
        # so make sure we don't modify the caller's object.  This is also
        # where normal dicts get converted to HTTPHeaders objects.
        request.headers = httputil.HTTPHeaders(request.headers)
        callback = stack_context.wrap(callback)

        key = object()
        self.queue.append((key, request, callback))

        if not len(self.active) < self.max_clients:
            timeout_handle = self.io_loop.add_timeout(
                time.time() + min(request.connect_timeout,
                                  request.request_timeout),
                functools.partial(self._on_timeout, key))
        else:
            timeout_handle = None

        self.waiting[key] = (request, callback, timeout_handle)
        self._process_queue()
        if self.queue:
            logging.debug(
                'max_clients limit reached, request queued. '
                '%d active, %d queued requests.' % (
                    len(self.active), len(self.queue))
            )

    def perform_request(self, request, response, method):
        try:
            constants = request_consts[method]

            url = request[constants.URL]
            timeout = request[constants.TIMEOUT]

            http_request = HTTPRequest(url=url, method=method)
            http_request.request_timeout = float(timeout)/1000

            if method == 'POST':
                http_request.body = request[constants.BODY]

            #adds cookies to request
            params_num = len(request)
            if constants.COOKIES <= params_num - 1:
                cookies = request[constants.COOKIES]
                if len(cookies) > 0:
                    list_of_cookies = list('{0}={1}'.format(cookie, value) for cookie, value in cookies.iteritems())
                    cookies_str = '; '.join(list_of_cookies)

                    http_request.headers.add('Cookie', cookies_str)

            #adds headers to request
            if constants.HEADERS <= params_num - 1:
                for name, values_list in request[constants.HEADERS].iteritems():
                    for value in values_list:
                        http_request.headers.add(name, value)

            self.logger.info("Downloading {0}, headers {1}, method {2}".format(url, http_request.headers, method))
            http_response = yield self.http_client.fetch(http_request)

            response_headers = self._get_headers_from_response(http_response)
            response.write((True, http_response.body, http_response.code, response_headers,))

            response.close()
            self.logger.info("{0} has been successfuly downloaded".format(url))
        except HTTPError as e:
            self.logger.info("Error ({0}) occured while downloading {1}".format(e.message, url))

            if e.response is not None:
                http_response = e.response
                response_headers = self._get_headers_from_response(http_response)
                response.write((False, http_response.body, http_response.code, response_headers,))
            else:
                response.write((False, '', e.code, {},))

            response.close()
        except socket.gaierror as e:
            self.logger.info("Error ({0}) occured while downloading {1}".format(e.message, url))
            response.write((False, '', e.errno, {},))
            response.close()
        except Exception as e:
            self.logger.error("Unhandled error ({0}) occured in perform_request, report about this problem "
                          "to httpclient service developers. Method is {1}, stacktrace is: {2}".format(
                                e.message, method, traceback.format_exc()))

            response.write((False, '', 0, {},))
            response.close()

 def create_request(self):
     request = HTTPRequest(url=self.request_data['url'], headers=self.request_data['headers'])
     self.patch_request(request)
     request.headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.102 Safari/537.36'
     #request.connect_timeout = 0
     request.request_timeout = 0
     request.header_only = False
     return request

 def fetch(self, path, body=None, **kwargs):
     kwargs['url'] = self.get_url(path)
     request = HTTPRequest(**kwargs)
     if body is not None:
         request.body = body
     request.allow_nonstandard_methods = True
     self.http_client.fetch(request, self.stop, method=None)
     return self.wait()

def send_logout_request(step):
    request = HTTPRequest(ROOT_URL + "logout/", validate_cert=False)
    if world.cookie:
        request.headers["Cookie"] = world.cookie
    world.response = world.browser.fetch(request)
    if world.response.code == 200:
        world.cookie = ""
        world.browser.cookie = ""

 def fetch(self, request, callback, **kwargs):
     if not isinstance(request, HTTPRequest):
         request = HTTPRequest(url=request, **kwargs)
     if not isinstance(request.headers, HTTPHeaders):
         request.headers = HTTPHeaders(request.headers)
     callback = stack_context.wrap(callback)
     self.queue.append((request, callback))
     self._process_queue()

 def fetch(self, path, **kwargs):
     kwargs['url'] = self.get_url(path)
     body = kwargs.pop('body', None)
     request = HTTPRequest(**kwargs)
     request.body = body
     request.allow_nonstandard_methods = True
     request.request_timeout = TIMEOUT
     self.http_client.fetch(request, self.stop, **kwargs)
     return self.wait()

    def wrapper(self, request, callback, **kwargs):
        with HttpClientTransContext("tornado.simple_httpclient.SimpleAsyncHTTPClient.fetch") as context:
            if context:
                from tornado.httpclient import HTTPRequest

                if not isinstance(request, HTTPRequest):
                    request = HTTPRequest(url=request, **kwargs)
                request._td_httpclient_node = context
            return func(self, request, callback, **kwargs)

    def post(self):
        # param from the client 
        message = {}
        message['status'] = 'error'
        message['returned_url'] = 'null'
        #url = self.get_argument('url', None)
        comic_id = self.get_argument('img', None)
        self.threash_hold = self.get_argument('threshold', 90)
        if not self.threash_hold:
            self.threash_hold = float(90)
        else:
            self.threash_hold =  float(self.threash_hold)
        if comic_id:
            comic_id = int(comic_id[5:])
        if len(self.request.files['file']) > 0:
            img_file = self.request.files['file'][0]
        # check the client params  
        if not img_file or comic_id <= 0:
            self.write(json.dumps(message))
            self.finish()
        else:
            self.comic_picture_id = comic_id 

        ######################################################
        # print self.client_cv_img 
        filename = img_file['filename']
        saved_path = self.IMAGE_PATH + filename 
        self.client_saved_img = saved_path 
        if not os.path.exists(filename):
            with open(saved_path, "wb") as fp:
                fp.write(img_file['body'])

        # save the client img 
        self.client_cv_img = scv.Image(r'%s' % str(saved_path)) 

        ######################################################
        # ok, we save the client image and gen the SimpleCV img 
        # we pass the client img url to oxford to get the params 
        # get parameters 
        get_params = urllib.urlencode({
                'analyzesFaceLandmarks': 'true',
                'analyzesAge': 'true',
                'analyzesGender': 'true',
                'analyzesHeadPose': 'true',
                })
        url = self.API_URL % get_params
        post_params = {}
        post_params['url'] = self.HOST + saved_path  
        #print post_params['url']
        # request 
        request = HTTPRequest(url, method='POST')
        request.body = json.dumps(post_params)
        request.headers['Content-Type'] = 'application/json'
        request.headers['Ocp-Apim-Subscription-key'] = self.TOKEN 
        # fetch 
        client = AsyncHTTPClient()
        client.fetch(request, self.handleResponse)

 def fetch(self, request, **kwargs):
     headers = kwargs['headers'] if 'headers' in kwargs else default_headers
     if not isinstance(request, HTTPRequest):
         request = HTTPRequest(url=request, headers = headers, **kwargs)
     request.headers = HTTPHeaders(request.headers if request.headers else headers)
     try:
         return self.http.fetch(request)
     except (HTTPError, SyntaxError), e:
         #todo log
         print "[ERROR]", e

    def fetch(self, url, headers=None, body=None, method="GET", callback=None, raise_error=True, cache=None, **kwargs):
        headers = headers or {}
        body = body or "{}"
        """very simlar with AsyncHTTPClient.fetch
        """
        if self._closed:
            raise RuntimeError("fetch() called on closed AsyncHTTPClient")
        future = TracebackFuture()
        if isinstance(body, dict):
            for k,v in body.items():
                if v is None:
                    del body[k]
            body = urllib.urlencode(body)
        for k,v in headers.items(): #headers 只能接收str
            if v:
                headers[k] = str(headers[k])
            else:
                del headers[k]
        request = HTTPRequest(url=url,method=method,headers=headers,body=body, allow_nonstandard_methods=True, request_timeout=600 ,**kwargs)
        # We may modify this (to add Host, Accept-Encoding, etc),
        # so make sure we don't modify the caller's object.  This is also
        # where normal dicts get converted to HTTPHeaders objects.
        request.headers = httputil.HTTPHeaders(request.headers)
        request = _RequestProxy(request, self.defaults)
        if callback is not None:
            callback = stack_context.wrap(callback)

            def handle_future(future):
                exc = future.exception()
                if isinstance(exc, HTTPError) and exc.response is not None:
                    response = exc.response
                elif exc is not None:
                    response = HTTPResponse(
                        request, 599, error=exc,
                        request_time=time.time() - request.start_time)
                else:
                    response = future.result()
                self.io_loop.add_callback(callback, response)
            future.add_done_callback(handle_future)

        def handle_response(response):
            if raise_error and response.error:
                future.set_exception(response.error)
            else:
                try:
                    resp = json.loads(str(response.body))
                    if resp.get("statusCode") and resp.get("statusCode")==800:
                        future.set_result(resp)
                        log.info(json.dumps({"response":resp,"body":body,"headers":headers,"url":url}))
                    else:
                        future.set_result({"error_type":"statusCode is not 800", "response":resp,"body":body,"headers":headers,"url":url})
                        log.error(json.dumps({"error_type":"statusCode is not 800", "response":resp,"body":body,"headers":headers,"url":url}))
                except Exception,e:
                    future.set_result({"error_type":"json.loads failed!","error":str(e),"response.body":response.body,"body":body,"headers":headers,"url":url})
                    log.error(json.dumps({"error_type":"json.loads failed!","error":str(e),"response.body":response.body,"body":body,"headers":headers,"url":url}))

 def _request(self, extension, body, callback):
     """Wraps tornado syntax for sending an HTTP request."""
     request = HTTPRequest('http://{}/{}'.format(self.ip, extension),
                           connect_timeout=self.timeout,
                           request_timeout=self.timeout)
     if body:
         request.body = body
         request.method = 'POST'
     if extension == 'ToolWeb/Cmd':
         request.headers = {'Content-Type': 'text/xml'}
     self.client.fetch(request, callback)

    def post(self, url, body):
        """
        Perform a POST request.
        """

        if hasattr(self, "root_url") and self.root_url:
            url = self.root_url + url

        request = HTTPRequest(url, method="POST", body=body, validate_cert=False)
        if hasattr(self, "cookie") and self.cookie:
            request.headers["Cookie"] = self.cookie
        return HTTPClient.fetch(self, request)