def send_requests(
client_kwargs,
rolling_event,
client_ready_to_send_event,
exception_to_raise_event,
):
from jina.logging.logger import JinaLogger
from jina.clients import Client
_logger = JinaLogger('test_send_requests')
_logger.debug(f' send request start')
try:
client = Client(**client_kwargs)
client.show_progress = True
_logger.debug(f' Client instantiated with {client_kwargs}')
_logger.debug(f' Set client_ready_to_send_event event')
client_ready_to_send_event.set()
while not rolling_event.is_set():
_logger.debug(f' event is not set')
r = client.post(
'/exec',
[Document() for _ in range(10)],
return_results=True,
port_expose=9090,
)
assert len(r) > 0
assert len(r[0].docs) > 0
for doc in r[0].docs:
assert doc.tags['argument'] in ['value1', 'value2']
time.sleep(0.1)
_logger.debug(f' event is unset')
except:
_logger.error(f' Some error happened while sending requests')
exception_to_raise_event.set()
_logger.debug(f' send requests finished')
async def run_test_until_event(flow,
core_client,
namespace,
endpoint,
stop_event,
logger,
sleep_time=0.05):
# start port forwarding
from jina.clients import Client
gateway_pod_name = (core_client.list_namespaced_pod(
namespace=namespace,
label_selector='app=gateway').items[0].metadata.name)
config_path = os.environ['KUBECONFIG']
import portforward
with portforward.forward(namespace, gateway_pod_name, flow.port, flow.port,
config_path):
client_kwargs = dict(
host='localhost',
port=flow.port,
return_responses=True,
asyncio=True,
)
client_kwargs.update(flow._common_kwargs)
client = Client(**client_kwargs)
client.show_progress = True
async def async_inputs(sent_ids: Set[int], sleep_time: float = 0.05):
i = 0
while True:
sent_ids.add(i)
yield Document(text=f'{i}')
if stop_event.is_set():
logger.info(
f'stop yielding new requests after {i} requests')
return
elif sleep_time:
await asyncio.sleep(sleep_time)
i += 1
responses = []
sent_ids = set()
async for resp in client.post(
endpoint,
inputs=functools.partial(async_inputs, sent_ids, sleep_time),
request_size=1,
):
responses.append(resp)
logger.info(
f'Client sent {len(sent_ids)} and received {(len(responses))} responses'
)
return responses, sent_ids
def send_requests(
client_kwargs,
stop_event: multiprocessing.Event,
scale_event: multiprocessing.Event,
received_responses: multiprocessing.Queue,
response_arrival_times: multiprocessing.Queue,
logger,
):
from jina.clients import Client
client = Client(**client_kwargs)
client.show_progress = True
class ResponseValidator:
def __init__(
self,
received_resposes: multiprocessing.Queue,
response_arrival_times: multiprocessing.Queue,
):
self.prev_time = None
self.received_resposes = received_resposes
self.response_arrival_times = response_arrival_times
def process_response(self, req):
logger.debug(f'Received response {req.data.docs[0].text}')
self.received_resposes.put(req.data.docs[0].text)
if self.prev_time is not None:
self.response_arrival_times.put(time.time() - self.prev_time)
self.prev_time = time.time()
validator = ResponseValidator(received_responses, response_arrival_times)
async def async_inputs():
for i in range(50):
yield Document(text=f'{i}')
if stop_event.is_set():
logger.debug(f'stop sending new requests after {i} requests')
else:
await asyncio.sleep(1.0 if scale_event.is_set() else 0.05)
client.post(
'/',
inputs=async_inputs,
request_size=1,
on_done=validator.process_response,
)
async def run_test(flow, endpoint, num_docs=10, request_size=10):
# start port forwarding
from jina.clients import Client
client_kwargs = dict(
host='localhost',
port=flow.port_expose,
asyncio=True,
)
client_kwargs.update(flow._common_kwargs)
client = Client(**client_kwargs)
client.show_progress = True
responses = []
async for resp in client.post(
endpoint,
inputs=[Document() for _ in range(num_docs)],
return_results=True,
request_size=request_size,
):
responses.append(resp)
return responses
async def run_test(flow,
core_client,
namespace,
endpoint,
n_docs=10,
request_size=100):
# start port forwarding
from jina.clients import Client
gateway_pod_name = (core_client.list_namespaced_pod(
namespace=namespace,
label_selector='app=gateway').items[0].metadata.name)
config_path = os.environ['KUBECONFIG']
import portforward
with portforward.forward(namespace, gateway_pod_name, flow.port, flow.port,
config_path):
client_kwargs = dict(
host='localhost',
port=flow.port,
return_responses=True,
asyncio=True,
)
client_kwargs.update(flow._common_kwargs)
client = Client(**client_kwargs)
client.show_progress = True
responses = []
async for resp in client.post(
endpoint,
inputs=[Document() for _ in range(n_docs)],
request_size=request_size,
):
responses.append(resp)
return responses
