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
