def test_process_request(self):
@tornado.gen.coroutine
def test_fetch(request, **kwargs):
resp = tornado.httpclient.HTTPResponse(request,
200,
buffer=BytesIO(b"bar"))
raise tornado.gen.Return(resp)
fetch_patcher = patch("tornado.httpclient.AsyncHTTPClient.fetch")
fetch_mock = fetch_patcher.start()
fetch_mock.side_effect = test_fetch
dct = {"response_key": "foobar"}
req = tornado.httputil.HTTPServerRequest("GET", "/foo")
msg = serialize_http_request(req, dict_to_inject=dct)
exchange = HTTPRequestExchange(
msg, Queue(["foo"], host="localhost", port=6379))
yield process_request(exchange, datetime.now())
fetch_patcher.stop()
client = tornadis.Client()
yield client.connect()
res = yield client.call('BRPOP', 'foobar', 0)
self.assertEquals(len(res), 2)
(status_code, body, body_link, headers, extra_dict) = \
unserialize_response_message(res[1])
self.assertEquals(status_code, 200)
self.assertEquals(body, b"bar")
client.disconnect()
def test_serialize_query_string(self):
uri = "/foo/bar"
req = HTTPServerRequest(method='GET', uri=uri)
utf = u"éééééé"
bs = utf.encode('utf-8')
req.query_arguments = {
"foo1": [b"bar1", b"bar2"],
"foo2": [bs],
"foo3": [b"bar3"]
}
msg = serialize_http_request(req)
(hreq, body_link, extra_dict) = \
unserialize_request_message(msg)
o = urlparse(hreq.url)
if six.PY3:
parsed = sorted(parse_qsl(o.query), key=lambda x: x[0])
else:
parsed = sorted(parse_qsl(o.query.encode('ASCII')))
self.assertEquals(parsed[0][0], 'foo1')
self.assertEquals(parsed[0][1], 'bar1')
self.assertEquals(parsed[1][0], 'foo1')
self.assertEquals(parsed[1][1], 'bar2')
self.assertEquals(parsed[2][0], 'foo2')
if six.PY3:
self.assertEquals(parsed[2][1], utf)
else:
self.assertEquals(parsed[2][1], bs)
self.assertEquals(parsed[3][0], 'foo3')
self.assertEquals(parsed[3][1], 'bar3')
def test_serialize_body_link(self):
uri = "/foo/bar"
req = HTTPServerRequest(method='PUT', uri=uri)
msg = serialize_http_request(req, body_link="http://foo.com/bar")
(hreq, body_link, extra_dict) = \
unserialize_request_message(msg)
self.assertEquals(hreq.body, None)
self.assertEquals(body_link, "http://foo.com/bar")
def test_serialize_body(self):
uri = "/foo/bar"
req = HTTPServerRequest(method='PUT', uri=uri, body=b"foo")
msg = serialize_http_request(req)
(hreq, body_link, extra_dict) = \
unserialize_request_message(msg)
self.assertEquals(hreq.method, 'PUT')
self.assertEquals(hreq.body, b"foo")
self.assertEquals(body_link, None)
def test_serialize_dict_to_inject(self):
uri = "/foo/bar"
req = HTTPServerRequest(method='GET', uri=uri)
msg = serialize_http_request(req,
dict_to_inject={
"foo": "foo1",
"bar": "bar1"
})
(hreq, body_link, extra_dict) = \
unserialize_request_message(msg)
self.assertEquals(len(extra_dict), 2)
self.assertEquals(extra_dict['foo'], "foo1")
self.assertEquals(extra_dict['bar'], "bar1")
def test_serialize_basic(self):
uri = "/foo/bar"
req = HTTPServerRequest(method='GET', uri=uri)
req.remote_ip = "127.0.0.1"
msg = serialize_http_request(req)
(hreq, body_link, extra_dict) = \
unserialize_request_message(msg)
self.assertEquals(hreq.method, 'GET')
self.assertTrue(body_link is None)
self.assertEquals(len(extra_dict), 0)
self.assertEquals(hreq.url, "http://127.0.0.1" + uri)
self.assertEquals(hreq.body, None)
self.assertEquals(body_link, None)
def test_serialize_headers(self):
uri = "/foo/bar"
req = HTTPServerRequest(method='GET', uri=uri)
headers = HTTPHeaders()
headers.add("Foo", "bar")
headers.add("Foo", "bar2")
headers.add("Foo2", "bar3")
req.headers = headers
msg = serialize_http_request(req)
(hreq, body_link, extra_dict) = \
unserialize_request_message(msg)
self.assertEquals(len(list(hreq.headers.get_all())), 5)
self.assertEquals(hreq.headers['Foo2'], "bar3")
self.assertEquals(hreq.headers['Foo'], "bar,bar2")
def handle(self, *args, **kwargs):
exchange = HTTPExchange(self.request,
default_redis_host=options.redis_host,
default_redis_port=options.redis_port,
default_redis_queue=options.redis_queue,
default_redis_uds=options.redis_uds)
self.__request_id = exchange.request_id
running_exchanges[self.__request_id] = exchange
yield Rules.execute_input_actions(exchange)
if exchange.response.status_code is not None and \
exchange.response.status_code != "null":
# so we don't push the request on redis
# let's call output actions for headers and body
yield Rules.execute_output_actions(exchange)
self.return_http_reply(exchange)
elif exchange.redis_queue == "null":
# so we don't push the request on redis
# let's call output actions for headers and body
yield Rules.execute_output_actions(exchange)
self.return_http_reply(exchange, force_status=404,
force_body="no redis queue set")
else:
redis_pool = get_redis_pool(host=exchange.redis_host,
port=exchange.redis_port,
uds=exchange.redis_uds)
with (yield redis_pool.connected_client()) as redis:
response_key = "thr:queue:response:%s" % make_unique_id()
serialized_request = serialize_http_request(
exchange.request,
dict_to_inject={
'response_key': response_key,
'priority': exchange.priority,
'creation_time': time.time(),
'request_id': exchange.request_id
})
lpush_res = yield redis.call('LPUSH', exchange.redis_queue,
serialized_request)
if not isinstance(lpush_res, six.integer_types):
yield Rules.execute_output_actions(exchange)
self.return_http_reply(exchange, force_status=500,
force_body="can't connect to bus")
return
before = datetime.datetime.now()
while True:
result = yield redis.call('BRPOP', response_key, 1)
if result and not isinstance(result,
tornadis.ConnectionError):
self.update_exchange_from_response_message(exchange,
result[1])
yield Rules.execute_output_actions(exchange)
self.return_http_reply(exchange)
break
after = datetime.datetime.now()
delta = after - before
if delta.total_seconds() > options.timeout:
yield Rules.execute_output_actions(exchange)
self.return_http_reply(exchange, force_status=504,
force_body="no reply from "
"the backend")
break