def run_example(self):
r"""This runs an example in the correct language."""
if self.yaml is None:
if self.name is not None:
raise unittest.SkipTest("Could not locate example %s in language %s." %
(self.name, self.language))
else:
# Copy platform specific makefile
if self.language == 'make':
makefile = os.path.join(self.yamldir, 'src', 'Makefile')
if platform._is_win: # pragma: windows
make_ext = '_windows'
else:
make_ext = '_linux'
shutil.copy(makefile + make_ext, makefile)
# Check that language is installed
for x in self.languages_tested:
if not tools.is_lang_installed(x):
raise unittest.SkipTest("%s not installed." % x)
# Check that comm is installed
if self.comm in ['ipc', 'IPCComm']:
from yggdrasil.communication.IPCComm import (
ipcrm_queues, ipc_queues)
qlist = ipc_queues()
if qlist: # pragma: debug
print('Existing queues:', qlist)
ipcrm_queues()
# Run
os.environ.update(self.env)
self.runner = runner.get_runner(self.yaml, namespace=self.namespace)
self.runner.run()
if self.expects_error:
assert(self.runner.error_flag)
else:
assert(not self.runner.error_flag)
try:
self.check_results()
finally:
self.cleanup()
# Remove copied makefile
if self.language == 'make':
makefile = os.path.join(self.yamldir, 'src', 'Makefile')
if os.path.isfile(makefile):
os.remove(makefile)
def test_example(self, example_name, language, namespace, yaml, setup_env,
expects_error, on_mpi, mpi_rank, check_results,
example_cleanup, adv_global_mpi_tag,
optionally_disable_verify_count_fds):
r"""This runs an example in the correct language."""
if example_name.startswith('timesync'):
# Timesync examples include ploting in the verification script
# which opens file descriptors that are not promptly cleaned up
optionally_disable_verify_count_fds()
assert (yaml is not None)
# Run
mpi_tag_start = None
if on_mpi:
mpi_tag_start = adv_global_mpi_tag(1000)
r = runner.get_runner(yaml,
namespace=namespace,
production_run=True,
mpi_tag_start=mpi_tag_start)
try:
try:
r.run()
except runner.IntegrationError:
pass
r.printStatus()
r.printStatus(return_str=True)
if mpi_rank != 0:
return
if expects_error:
assert (r.error_flag)
else:
assert (not r.error_flag)
try:
check_results()
except BaseException: # pragma: debug
if r is not None:
r.printStatus()
raise
finally:
if mpi_rank == 0:
example_cleanup()
def start_integration(self, client_id, x, yamls, **kwargs):
r"""Start an integration if it is not already running.
Args:
client_id (str): ID associated with the client requesting the
integration be started.
x (str, tuple): Hashable object that should be used to
identify the integration being started in the registry of
running integrations.
yamls (list): Set of YAML specification files defining the
integration that should be run as as service.
**kwargs: Additional keyword arguments are passed to get_runner.
Returns:
bool: True if the integration started, False otherwise.
"""
integrations = self.integrations[client_id]
stopped_integrations = self.stopped_integrations[client_id]
if (x in integrations) and (not integrations[x].is_alive):
if not self.stop_integration(client_id, x):
return False
if x in stopped_integrations:
if not self.stop_integration(client_id, x):
return False
stopped_integrations.pop(x)
if x not in integrations:
partial_commtype = {'commtype': self.commtype}
if self.commtype == 'rest':
partial_commtype['client_id'] = client_id
integrations[x] = runner.get_runner(
yamls,
complete_partial=True,
as_service=True,
partial_commtype=partial_commtype,
**kwargs)
integrations[x].run(signal_handler=False)
return True
def call_integration_service(self,
cli,
yamls,
test_yml,
copy_yml=None,
name='test',
yaml_param=None):
r"""Call an integration that includes a service."""
remote_yml = '_remote'.join(os.path.splitext(test_yml))
yamls = copy.copy(yamls)
yamls.remove(test_yml)
if copy_yml:
yamls.remove(copy_yml)
yamls.append(remote_yml)
service_type = cli.service_type
try:
address = cli.address
if copy_yml:
shutil.copy(copy_yml, remote_yml)
remote_code = 'a'
else:
remote_code = 'w'
lines = [
'service:', f' name: {name}', f' yamls: [{test_yml}]',
f' type: {service_type}', f' address: {address}'
]
if yaml_param:
lines.append(' yaml_param:')
for k, v in yaml_param.items():
lines.append(f' {k}: "{v}"')
with open(remote_yml, remote_code) as fd:
fd.write('\n'.join(lines))
r = runner.get_runner(yamls)
r.run()
assert (not r.error_flag)
finally:
if os.path.isfile(remote_yml):
os.remove(remote_yml)
def test_matlab_runner(): # pragma: matlab
r"""Use get_runner to start a Matlab run."""
cr = runner.get_runner([ex_yamls['hello']['matlab']])
cr.run()
def test_get_runner():
r"""Use get_runner to start a run."""
namespace = "test_get_runner_%s" % str(uuid.uuid4)
cr = runner.get_runner([ex_yamls['hello']['python']], namespace=namespace)
cr.run()
cr.sleep()