def __init__(self, pav_cfg, tests, _id=None):
"""Initialize the series.
:param pav_cfg: The pavilion configuration object.
:param list tests: The list of test objects that belong to this series.
:param int _id: The test id number. If this is given, it implies that
we're regenerating this series from saved files.
"""
self.pav_cfg = pav_cfg
self.tests = {test.id: test for test in tests}
series_path = self.pav_cfg.working_dir / 'series'
# We're creating this series from scratch.
if _id is None:
# Get the series id and path.
try:
self._id, self.path = dir_db.create_id_dir(
series_path, pav_cfg['shared_group'], pav_cfg['umask'])
except (OSError, TimeoutError) as err:
raise TestSeriesError(
"Could not get id or series directory in '{}': {}".format(
series_path, err))
perm_man = PermissionsManager(None, pav_cfg['shared_group'],
pav_cfg['umask'])
# Create a soft link to the test directory of each test in the
# series.
for test in tests:
link_path = dir_db.make_id_path(self.path, test.id)
try:
link_path.symlink_to(test.path)
perm_man.set_perms(link_path)
except OSError as err:
raise TestSeriesError(
"Could not link test '{}' in series at '{}': {}".
format(test.path, link_path, err))
# Update user.json to record last series run per sys_name
self._save_series_id()
else:
self._id = _id
self.path = dir_db.make_id_path(series_path, self._id)
self._logger = logging.getLogger(self.LOGGER_FMT.format(self._id))
def __init__(self, pav_cfg, tests=None, _id=None, series_config=None,
dep_graph=None, outfile: TextIO = StringIO(),
errfile: TextIO = StringIO()):
"""Initialize the series.
:param pav_cfg: The pavilion configuration object.
:param list tests: The list of test objects that belong to this series.
:param _id: The test id number. If this is given, it implies that
we're regenerating this series from saved files.
:param series_config: Series config, if generated from a series file.
:param dep_graph: The saved dependency graph (when loading).
:param outfile: Where to send user output.
:param errfile: Where to send user error output.
"""
self.pav_cfg = pav_cfg
self.outfile = outfile
self.errfile = errfile
self.tests = {}
self.config = series_config
if not dep_graph:
self.dep_graph = {}
else:
self.dep_graph = dep_graph
self.test_sets = {} # type: Dict[str, TestSet]
self.test_objs = {}
if tests:
self.tests = {test.id: test for test in tests}
series_path = self.pav_cfg.working_dir/'series'
# We're creating this series from scratch.
if _id is None:
# Get the series id and path.
try:
self._id, self.path = dir_db.create_id_dir(
series_path,
pav_cfg['shared_group'],
pav_cfg['umask'])
except (OSError, TimeoutError) as err:
raise TestSeriesError(
"Could not get id or series directory in '{}': {}"
.format(series_path, err))
# Create self.dep_graph, apply ordered: True, check for circular
# dependencies
self.dep_graph = self.create_dependency_graph()
self.save_dep_graph()
# save series config
self.save_series_config()
perm_man = PermissionsManager(None, pav_cfg['shared_group'],
pav_cfg['umask'])
# Create a soft link to the test directory of each test in the
# series.
if tests:
for test in tests:
link_path = dir_db.make_id_path(self.path, test.id)
try:
link_path.symlink_to(test.path)
perm_man.set_perms(link_path)
except OSError as err:
raise TestSeriesError(
"Could not link test '{}' in series at '{}': {}"
.format(test.path, link_path, err))
# Update user.json to record last series run per sys_name
self._save_series_id()
# We're not creating this from scratch (an object was made ahead of
# time).
else:
self._id = _id
self.path = dir_db.make_id_path(series_path, self._id)
self.dep_graph, self.config = self.load_dep_graph()
self._logger = logging.getLogger(self.LOGGER_FMT.format(self._id))
def __init__(self,
pav_cfg,
config,
build_tracker=None,
var_man=None,
_id=None,
rebuild=False,
build_only=False):
"""Create an new TestRun object. If loading an existing test
instance, use the ``TestRun.from_id()`` method.
:param pav_cfg: The pavilion configuration.
:param dict config: The test configuration dictionary.
:param builder.MultiBuildTracker build_tracker: Tracker for watching
and managing the status of multiple builds.
:param variables.VariableSetManager var_man: The variable set manager for this
test.
:param bool build_only: Only build this test run, do not run it.
:param bool rebuild: After determining the build name, deprecate it and select
a new, non-deprecated build.
:param int _id: The test id of an existing test. (You should be using
TestRun.load).
"""
# Just about every method needs this
self._pav_cfg = pav_cfg
self.scheduler = config['scheduler']
# Create the tests directory if it doesn't already exist.
tests_path = pav_cfg.working_dir / 'test_runs'
self.config = config
group, umask = self.get_permissions(pav_cfg, config)
# Get an id for the test, if we weren't given one.
if _id is None:
id_tmp, run_path = dir_db.create_id_dir(tests_path, group, umask)
super().__init__(path=run_path, group=group, umask=umask)
# Set basic attributes
self.id = id_tmp
self.build_only = build_only
self.complete = False
self.created = dt.datetime.now()
self.name = self.make_name(config)
self.rebuild = rebuild
self.suite_path = Path(config.get('suite_path', '.'))
self.user = utils.get_login()
self.uuid = str(uuid.uuid4())
else:
# Load the test info from the given id path.
super().__init__(path=dir_db.make_id_path(tests_path, _id),
group=group,
umask=umask)
self.load_attributes()
self.test_version = config.get('test_version')
if not self.path.is_dir():
raise TestRunNotFoundError(
"No test with id '{}' could be found.".format(self.id))
# Mark the run to build locally.
self.build_local = config.get('build', {}) \
.get('on_nodes', 'false').lower() != 'true'
self._variables_path = self.path / 'variables'
if _id is None:
with PermissionsManager(self.path, self.group, self.umask):
self._save_config()
if var_man is None:
var_man = variables.VariableSetManager()
self.var_man = var_man
self.var_man.save(self._variables_path)
self.sys_name = self.var_man.get('sys_name', '<unknown>')
else:
try:
self.var_man = variables.VariableSetManager.load(
self._variables_path)
except RuntimeError as err:
raise TestRunError(*err.args)
# This will be set by the scheduler
self._job_id = None
with PermissionsManager(self.path / 'status', self.group, self.umask):
# Setup the initial status file.
self.status = StatusFile(self.path / 'status')
if _id is None:
self.status.set(STATES.CREATED,
"Test directory and status file created.")
self.run_timeout = self.parse_timeout(
'run',
config.get('run', {}).get('timeout'))
self.build_timeout = self.parse_timeout(
'build',
config.get('build', {}).get('timeout'))
self.run_log = self.path / 'run.log'
self.build_log = self.path / 'build.log'
self.results_log = self.path / 'results.log'
self.results_path = self.path / 'results.json'
self.build_origin_path = self.path / 'build_origin'
self.build_timeout_file = config.get('build', {}).get('timeout_file')
# Use run.log as the default run timeout file
self.timeout_file = self.run_log
run_timeout_file = config.get('run', {}).get('timeout_file')
if run_timeout_file is not None:
self.timeout_file = self.path / run_timeout_file
build_config = self.config.get('build', {})
self.build_script_path = self.path / 'build.sh' # type: Path
self.build_path = self.path / 'build'
if _id is None:
self._write_script('build',
path=self.build_script_path,
config=build_config)
try:
self.builder = builder.TestBuilder(pav_cfg=pav_cfg,
test=self,
mb_tracker=build_tracker,
build_name=self.build_name)
self.build_name = self.builder.name
except builder.TestBuilderError as err:
raise TestRunError(
"Could not create builder for test {s.name} (run {s.id}): {err}"
.format(s=self, err=err))
run_config = self.config.get('run', {})
self.run_tmpl_path = self.path / 'run.tmpl'
self.run_script_path = self.path / 'run.sh'
if _id is None:
self._write_script('run',
path=self.run_tmpl_path,
config=run_config)
if _id is None:
self.save_attributes()
self.status.set(STATES.CREATED, "Test directory setup complete.")
self._results = None
self.skipped = self._get_skipped() # eval skip.