def _wait_started(self, timeout=None): """TODO.""" sleeper = get_sleeper( interval=(0.04, 0.5), timeout=timeout, raise_timeout_with_msg="Worker start timeout, logfile = {}".format( self.outfile ), ) while next(sleeper): if match_regexps_in_file( self.outfile, [re.compile("Starting child process worker on")] )[0]: self.last_heartbeat = time.time() self.status.change(self.STATUS.STARTED) return if self._handler and self._handler.poll() is not None: raise RuntimeError( "{proc} process exited: {rc} (logfile = {log})".format( proc=self, rc=self._handler.returncode, log=self.outfile, ) )
def _wait_started(self, timeout=None): sleeper = get_sleeper( interval=0.2, timeout=timeout, raise_timeout_with_msg= f"RPyC server start timeout, logfile = {self.std.err_path}", ) while next(sleeper): done, extracts, _ = match_regexps_in_file( self.std.err_path, [re.compile(".*server started on .*:(?P<port>.*)")], ) if done: self.rpyc_port = int(extracts["port"]) self.logger.info( "Remote RPyc server started on %s:%s", self.cfg.remote_host, self.rpyc_port, ) self.status.change(self.STATUS.STARTED) return if self.proc and self.proc.poll() is not None: raise RuntimeError( f"{self} process exited: {self.proc.returncode} (logfile = {self.std.err_path})" )
def _wait_started(self, timeout: float = None) -> None: """ Waits for RPyC server start, changes status to STARTED. :param timeout: timeout in seconds :type timeout: ``float`` :raises: RuntimeError if server startup fails """ sleeper = get_sleeper( interval=0.2, timeout=timeout, raise_timeout_with_msg= f"RPyC server start timeout, logfile = {self.std.err_path}", ) while next(sleeper): done, extracts, _ = match_regexps_in_file( self.std.err_path, [re.compile(".*server started on .*:(?P<port>.*)")], ) if done: self.rpyc_port = int(extracts["port"]) self.logger.info( "Remote RPyc server started on %s:%s", self.cfg.remote_host, self.rpyc_port, ) super(RemoteService, self)._wait_started(timeout=timeout) return if self.proc and self.proc.poll() is not None: raise RuntimeError( f"{self} process exited: {self.proc.returncode} (logfile = {self.std.err_path})" )
def test_http_operate_tests_async(): with InteractivePlan(name='InteractivePlan', interactive_port=0, interactive_block=False, parse_cmdline=False, logger_level=TEST_INFO) as plan: plan.run() wait(lambda: any(plan.i.http_handler_info), 5, raise_on_timeout=True) addr = 'http://{}:{}'.format(*plan.i.http_handler_info) plan.add(make_multitest(1)) plan.add(make_multitest(2)) # TRIGGER ASYNC RUN OF TESTS -> UID response = post_request('{}/async/run_tests'.format(addr), {}).json() expected = { 'message': 'Async operation performed: run_tests', 'error': False, 'trace': None, 'metadata': {}, 'result': re.compile('[0-9|a-z|-]+') } assert compare(expected, response)[0] is True uid = response['result'] # QUERY UID ASYNC OPERATION UNTIL FINISHED sleeper = get_sleeper(0.6, raise_timeout_with_msg='Async result missing.') while next(sleeper): response = post_request('{}/async_result'.format(addr), {'uid': uid}) json_response = response.json() if json_response['error'] is False: assert response.status_code == 200 expected = { 'result': None, 'trace': None, 'error': False, 'message': re.compile('[0-9|a-z|-]+'), 'metadata': { 'state': 'Finished' } } assert compare(expected, json_response)[0] is True break assert response.status_code == 400 # REPORT VIA HTTP response = post_request('{}/sync/report'.format(addr), { 'serialized': True }).json() expected_response = { 'result': plan.i.report(serialized=True), 'error': False, 'metadata': {}, 'trace': None, 'message': 'Sync operation performed: report' } assert compare(response, expected_response)[0] is True
def _wait_stopped(self, timeout=None): sleeper = get_sleeper(1, timeout) while next(sleeper): if self.status.tag != self.status.STOPPED: self.logger.info("Waiting for workers to stop") else: break else: raise RuntimeError("Not able to stop worker {} after {}s".format( self, timeout))
def _wait_stopped(self, timeout=None): sleeper = get_sleeper(1, timeout) while next(sleeper): if self.status != self.status.STOPPED: self.logger.info("Waiting for workers to stop") else: break else: msg = f"Not able to stop worker {self} after {timeout}s" self.logger.error(msg) raise RuntimeError(msg)
def test_http_operate_tests_async(): with InteractivePlan( name="InteractivePlan", interactive_port=0, interactive_block=False, parse_cmdline=False, logger_level=TEST_INFO, ) as plan: plan.run() wait(lambda: any(plan.i.http_handler_info), 5, raise_on_timeout=True) addr = "http://{}:{}".format(*plan.i.http_handler_info) plan.add(make_multitest(1)) plan.add(make_multitest(2)) # TRIGGER ASYNC RUN OF TESTS -> UID response = post_request("{}/async/run_tests".format(addr), {}).json() expected = { "message": "Async operation performed: run_tests", "error": False, "trace": None, "metadata": {}, "result": re.compile("[0-9|a-z|-]+"), } assert compare(expected, response)[0] is True uid = response["result"] # QUERY UID ASYNC OPERATION UNTIL FINISHED sleeper = get_sleeper(0.6, raise_timeout_with_msg="Async result missing.") while next(sleeper): response = post_request("{}/async_result".format(addr), {"uid": uid}) json_response = response.json() if json_response["error"] is False: assert response.status_code == 200 expected = { "result": None, "trace": None, "error": False, "message": re.compile("[0-9|a-z|-]+"), "metadata": { "state": "Finished" }, } assert compare(expected, json_response)[0] is True break assert response.status_code == 400 # REPORT VIA HTTP response = post_request("{}/sync/report".format(addr), { "serialized": True }).json() expected_response = { "result": plan.i.report(serialized=True), "error": False, "metadata": {}, "trace": None, "message": "Sync operation performed: report", } assert compare(response, expected_response)[0] is True