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=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: 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 extract_values(self):
"""Extract matching values from input regex configuration options."""
log_unmatched = []
stdout_unmatched = []
stderr_unmatched = []
result = True
regex_sources = []
if self.logpath and self.cfg.log_regexps:
regex_sources.append(
(self.logpath, self.cfg.log_regexps, log_unmatched))
if self.outpath and self.cfg.stdout_regexps:
regex_sources.append(
(self.outpath, self.cfg.stdout_regexps, stdout_unmatched))
if self.errpath and self.cfg.stderr_regexps:
regex_sources.append(
(self.errpath, self.cfg.stderr_regexps, stderr_unmatched))
for outfile, regexps, unmatched in regex_sources:
file_result, file_extracts, file_unmatched = match_regexps_in_file(
logpath=outfile, log_extracts=regexps, return_unmatched=True)
unmatched.extend(file_unmatched)
self.extracts.update(file_extracts)
result = result and file_result
if log_unmatched or stdout_unmatched or stderr_unmatched:
err = ("Timed out starting {}({}):"
" unmatched log_regexps in {}.").format(
type(self).__name__, self.name, self.logpath)
err += format_regexp_matches(
name="log_regexps",
regexps=self.cfg.log_regexps,
unmatched=log_unmatched,
)
err += format_regexp_matches(
name="stdout_regexps",
regexps=self.cfg.stdout_regexps,
unmatched=stdout_unmatched,
)
err += format_regexp_matches(
name="stderr_regexps",
regexps=self.cfg.stderr_regexps,
unmatched=stderr_unmatched,
)
if self.extracts:
err += "{newline}Matching groups:{newline}".format(
newline=os.linesep)
err += os.linesep.join([
"\t{}: {}".format(key, value)
for key, value in self.extracts.items()
])
return FailedAction(error_msg=err)
return result
def test_mixture(self, basic_logfile):
log_extracts = [
re.compile(r"(?P<first>first)"),
re.compile(br"(?P<second>second)"),
]
status, values = match_regexps_in_file(basic_logfile, log_extracts)
assert status is True
assert isinstance(values["first"], bytes)
assert isinstance(values["second"], bytes)
def _wait_started(self, timeout=None):
"""TODO."""
st_time = time.time()
sleep_interval = 0.04
while time.time() - st_time < self.cfg.start_timeout:
time.sleep(min(sleep_interval, 0.5))
if match_regexps_in_file(
self.outfile,
[re.compile('Starting child process worker on')])[0] is True:
self.status.change(self.STATUS.STARTED)
return
sleep_interval *= 2
if self._handler.poll() is not None:
raise RuntimeError(
'{proc} process exited: {rc} (logfile = {log})'.format(
proc=self, rc=self._handler.returncode, log=self.outfile))
raise RuntimeError(
'Could not match starting pattern in {}'.format(self.outfile))
