def test_stop_option(self):
add_rule(Criteria(path='/foo'),
Actions(set_input_header=('Header-Name', 'FOO')), stop=True)
add_rule(Criteria(path='/foo'),
Actions(set_input_header=('Header-Name', 'BAR')))
request = HTTPServerRequest(method='GET', uri='/foo')
Rules.execute_input_actions(HTTPExchange(request))
self.assertEqual(request.headers['Header-Name'], 'FOO')
def test_coroutine_action(self):
Rules.reset()
@gen.coroutine
def coroutine_action(exchange):
yield gen.sleep(0.1)
exchange.set_status_code(202)
add_rule(Criteria(path='/quux'),
Actions(custom_input=coroutine_action,
set_redis_queue='test-queue'),
stop=1)
response = yield self.http_client.fetch(self.get_url('/quux'))
self.assertEqual(response.code, 202)
def test_set_redis_queue_based_on_callable(self):
def callback_false(request):
return False
def callback_true(request):
return True
add_rule(Criteria(custom=callback_false),
Actions(set_redis_queue='not-this-one'), stop=1)
add_rule(Criteria(custom=callback_true),
Actions(set_redis_queue='yes-this-one'))
request = HTTPServerRequest(method='GET', uri='/foo')
exchange = HTTPExchange(request)
Rules.execute_input_actions(exchange)
self.assertEqual(exchange.redis_queue, 'yes-this-one')
def test_non_matching_coroutine_rule(self):
Rules.reset()
@tornado.gen.coroutine
def coroutine_rule(request):
yield tornado.gen.maybe_future(None)
raise tornado.gen.Return(True)
add_rule(Criteria(request=coroutine_rule),
Actions(set_redis_queue='test-queue'),
stop=1)
add_rule(Criteria(path='/quux'), Actions(set_redis_queue='no-match'))
yield self.http_client.fetch(self.get_url('/quux'), raise_error=False)
yield self.redis.connect()
result = yield self.redis.call('BRPOP', 'test-queue', 1)
data = json.loads(result[1].decode())
self.assertEqual(data['path'], '/quux')
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
def setUp(self):
super(TestApp, self).setUp()
self.redis = tornadis.Client()
Rules.reset()
self.make_response_key_predictable()
def setUp(self):
Rules.reset()
def test_set_redis_queue_based_on_path(self):
add_rule(Criteria(path='/foo'), Actions(set_redis_queue='test-queue'))
request = HTTPServerRequest(method='GET', uri='/foo')
exchange = HTTPExchange(request)
Rules.execute_input_actions(exchange)
self.assertEqual(exchange.redis_queue, 'test-queue')
def test_add_rule(self):
add_rule(Criteria(), Actions())
self.assertEqual(Rules.count(), 1)