Python httpclient.HTTPRequest方法代碼示例

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def raw_fetch(self, headers, body):
        with closing(Resolver(io_loop=self.io_loop)) as resolver:
            with closing(SimpleAsyncHTTPClient(self.io_loop,
                                               resolver=resolver)) as client:
                conn = RawRequestHTTPConnection(
                    self.io_loop, client,
                    httpclient._RequestProxy(
                        httpclient.HTTPRequest(self.get_url("/")),
                        dict(httpclient.HTTPRequest._DEFAULTS)),
                    None, self.stop,
                    1024 * 1024, resolver)
                conn.set_request(
                    b"\r\n".join(headers +
                                 [utf8("Content-Length: %d\r\n" % len(body))]) +
                    b"\r\n" + body)
                response = self.wait()
                response.rethrow()
                return response 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def connect_kernel():
    # TODO check status busy/idle
    run_sync(manager.list_kernels())
    kernels = {
        kernel_id: dateparser.parse(kernel["last_activity"])
        for kernel_id, kernel in manager._kernels.items()
    }
    kernel_id = url_escape(sorted(kernels, key=kernels.get)[0])
    client = GatewayClient.instance()
    url = url_path_join(client.ws_url, client.kernels_endpoint, kernel_id, "channels")
    ws_req = HTTPRequest(url=url)
    return run_sync(websocket_connect(ws_req)) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def get(self, callback, path, params=None, headers=None):
        uri = self.uri(path, params)
        request = httpclient.HTTPRequest(uri,
                                         method='GET',
                                         validate_cert=self.verify,
                                         headers=headers)
        return self._request(callback, request) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def put(self, callback, path, params=None, data='', headers=None):
        uri = self.uri(path, params)
        request = httpclient.HTTPRequest(uri,
                                         method='PUT',
                                         body='' if data is None else data,
                                         validate_cert=self.verify,
                                         headers=headers)
        return self._request(callback, request) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def delete(self, callback, path, params=None, data='', headers=None):
        uri = self.uri(path, params)
        request = httpclient.HTTPRequest(uri,
                                         method='DELETE',
                                         body='' if data is None else data,
                                         validate_cert=self.verify,
                                         headers=headers)
        request.allow_nonstandard_methods = True
        return self._request(callback, request) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def post(self, callback, path, params=None, data='', headers=None):
        uri = self.uri(path, params)
        request = httpclient.HTTPRequest(uri,
                                         method='POST',
                                         body=data,
                                         validate_cert=self.verify,
                                         headers=headers)
        return self._request(callback, request) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_websocket_headers(self):
        # Ensure that arbitrary headers can be passed through websocket_connect.
        ws = yield websocket_connect(
            HTTPRequest('ws://127.0.0.1:%d/header' % self.get_http_port(),
                        headers={'X-Test': 'hello'}))
        response = yield ws.read_message()
        self.assertEqual(response, 'hello')
        yield self.close(ws) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_check_origin_valid_no_path(self):
        port = self.get_http_port()

        url = 'ws://127.0.0.1:%d/echo' % port
        headers = {'Origin': 'http://127.0.0.1:%d' % port}

        ws = yield websocket_connect(HTTPRequest(url, headers=headers),
                                     io_loop=self.io_loop)
        ws.write_message('hello')
        response = yield ws.read_message()
        self.assertEqual(response, 'hello')
        yield self.close(ws) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_check_origin_valid_with_path(self):
        port = self.get_http_port()

        url = 'ws://127.0.0.1:%d/echo' % port
        headers = {'Origin': 'http://127.0.0.1:%d/something' % port}

        ws = yield websocket_connect(HTTPRequest(url, headers=headers),
                                     io_loop=self.io_loop)
        ws.write_message('hello')
        response = yield ws.read_message()
        self.assertEqual(response, 'hello')
        yield self.close(ws) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_check_origin_invalid_partial_url(self):
        port = self.get_http_port()

        url = 'ws://127.0.0.1:%d/echo' % port
        headers = {'Origin': '127.0.0.1:%d' % port}

        with self.assertRaises(HTTPError) as cm:
            yield websocket_connect(HTTPRequest(url, headers=headers),
                                    io_loop=self.io_loop)
        self.assertEqual(cm.exception.code, 403) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_check_origin_invalid_subdomains(self):
        port = self.get_http_port()

        url = 'ws://localhost:%d/echo' % port
        # Subdomains should be disallowed by default.  If we could pass a
        # resolver to websocket_connect we could test sibling domains as well.
        headers = {'Origin': 'http://subtenant.localhost'}

        with self.assertRaises(HTTPError) as cm:
            yield websocket_connect(HTTPRequest(url, headers=headers),
                                    io_loop=self.io_loop)

        self.assertEqual(cm.exception.code, 403) 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_reuse_request_from_response(self):
        # The response.request attribute should be an HTTPRequest, not
        # a _RequestProxy.
        # This test uses self.http_client.fetch because self.fetch calls
        # self.get_url on the input unconditionally.
        url = self.get_url('/hello')
        response = yield self.http_client.fetch(url)
        self.assertEqual(response.request.url, url)
        self.assertTrue(isinstance(response.request, HTTPRequest))
        response2 = yield self.http_client.fetch(response.request)
        self.assertEqual(response2.body, b'Hello world!') 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_request_set(self):
        proxy = _RequestProxy(HTTPRequest('http://example.com/',
                                          user_agent='foo'),
                              dict())
        self.assertEqual(proxy.user_agent, 'foo') 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_default_set(self):
        proxy = _RequestProxy(HTTPRequest('http://example.com/'),
                              dict(network_interface='foo'))
        self.assertEqual(proxy.network_interface, 'foo') 

# 需要導入模塊: from tornado import httpclient [as 別名]
# 或者: from tornado.httpclient import HTTPRequest [as 別名]
def test_both_set(self):
        proxy = _RequestProxy(HTTPRequest('http://example.com/',
                                          proxy_host='foo'),
                              dict(proxy_host='bar'))
        self.assertEqual(proxy.proxy_host, 'foo')