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