def evaluate(expr):
user_deprecation_warning('evaluate() is deprecated: '
'please use reframe.utility.sanity.evaluate')
if isinstance(expr, _DeferredExpression):
return expr.evaluate()
else:
return expr
def __init__(self, callback=None):
"""Create a basic StatefulParser
callback -- callable to be called when matching criteria are met
(default None, which is equivalent to reframe.utility.always_true)"""
user_deprecation_warning(
'Use of parsers is deprecated. Please refer to the '
'ReFrame tutorial for the new syntax.'),
self._is_on = False
self._callback = callback or always_true
def launcher(self):
'''See :attr:`launcher_type`.
.. deprecated:: 3.2
Please use :attr:`launcher_type` instead.
'''
from reframe.core.exceptions import user_deprecation_warning
user_deprecation_warning("the 'launcher' attribute is deprecated; "
"please use 'launcher_type' instead")
return self.launcher_type
def __init__(cls, name, bases, namespace, **kwargs):
super().__init__(name, bases, namespace, **kwargs)
# Set up the hooks for the pipeline stages based on the _rfm_attach
# attribute; all dependencies will be resolved first in the post-setup
# phase if not assigned elsewhere
hooks = {}
fn_with_deps = []
for v in namespace.values():
if hasattr(v, '_rfm_attach'):
for phase in v._rfm_attach:
try:
hooks[phase].append(v)
except KeyError:
hooks[phase] = [v]
try:
if v._rfm_resolve_deps:
fn_with_deps.append(v)
except AttributeError:
pass
if fn_with_deps:
hooks['post_setup'] = fn_with_deps + hooks.get('post_setup', [])
cls._rfm_pipeline_hooks = hooks
cls._rfm_disabled_hooks = set()
cls._final_methods = {v.__name__ for v in namespace.values()
if hasattr(v, '_rfm_final')}
# Add the final functions from its parents
cls._final_methods.update(*(b._final_methods for b in bases
if hasattr(b, '_final_methods')))
if hasattr(cls, '_rfm_special_test') and cls._rfm_special_test:
return
for v in namespace.values():
for b in bases:
if not hasattr(b, '_final_methods'):
continue
if callable(v) and v.__name__ in b._final_methods:
msg = (f"'{cls.__qualname__}.{v.__name__}' attempts to "
f"override final method "
f"'{b.__qualname__}.{v.__name__}'; "
f"consider using the pipeline hooks instead")
user_deprecation_warning(msg)
def __set__(self, obj, value):
if value is None and self._allow_none:
# Call directly Field's __set__() method; no need for further type
# checking
Field.__set__(self, obj, value)
return
user_deprecation_warning(
'This syntax for sanity and performance checking is deprecated. '
'Please have a look in the ReFrame tutorial.')
# Check first the outer dictionary
if not self._check_type(value, self._outer_typespec):
raise FieldError('attempt to set a sanity pattern field '
'with an invalid dictionary object')
# For the inner dictionary, we need special treatment for the '\e'
# character
for k, v in value.items():
# Check the special entry '\e' first
eof_handler = None
if '\e' in v.keys():
eof_handler = v['\e']
if not callable(eof_handler):
raise FieldError("special key '\e' does not "
"refer to a callable")
# Remove the value temporarily
del v['\e']
try:
if not self._check_type(v, self._inner_typespec):
raise FieldError('attempt to set a sanity pattern field'
'with an invalid dictionary object')
finally:
# Restore '\e'
if eof_handler is not None:
v['\e'] = eof_handler
# All type checking is done; just set the value
Field.__set__(self, obj, value)
def __set__(self, obj, value):
self._check_type(value)
if isinstance(value, tuple):
user_deprecation_warning(
"setting a timer field from a tuple is deprecated: "
"please use a string '<days>d<hours>h<minutes>m<seconds>s'")
h, m, s = value
value = datetime.timedelta(hours=h, minutes=m, seconds=s)
if isinstance(value, str):
time_match = re.match(
r'^((?P<days>\d+)d)?'
r'((?P<hours>\d+)h)?'
r'((?P<minutes>\d+)m)?'
r'((?P<seconds>\d+)s)?$', value)
if not time_match:
raise ValueError('invalid format for timer field')
value = datetime.timedelta(
**{k: int(v)
for k, v in time_match.groupdict().items() if v})
# Call Field's __set__() method, type checking is already performed
Field.__set__(self, obj, value)
def make_deferrable(a):
user_deprecation_warning('make_deferrable() is deprecated: '
'please use reframe.utility.sanity.defer')
return a
def load_from_dict(self, site_config):
if not isinstance(site_config, collections.abc.Mapping):
raise TypeError('site configuration is not a dict')
# We do all the necessary imports here and not on the top, because we
# want to remove import time dependencies
import reframe.core.environments as m_env
from reframe.core.systems import System, SystemPartition
sysconfig = site_config.get('systems', None)
envconfig = site_config.get('environments', None)
modes = site_config.get('modes', {})
if not sysconfig:
raise ValueError('no entry for systems was found')
if not envconfig:
raise ValueError('no entry for environments was found')
# Convert envconfig to a ScopedDict
try:
envconfig = fields.ScopedDict(envconfig)
except TypeError:
raise TypeError('environments configuration '
'is not a scoped dictionary') from None
# Convert modes to a `ScopedDict`; note that `modes` will implicitly
# converted to a scoped dict here, since `self._modes` is a
# `ScopedDictField`.
try:
self._modes = modes
except TypeError:
raise TypeError('modes configuration '
'is not a scoped dictionary') from None
def create_env(system, partition, name):
# Create an environment instance
try:
config = envconfig['%s:%s:%s' % (system, partition, name)]
except KeyError as e:
raise ConfigError("could not find a definition for `%s'" %
name) from None
if not isinstance(config, collections.abc.Mapping):
raise TypeError("config for `%s' is not a dictionary" % name)
try:
envtype = m_env.__dict__[config['type']]
return envtype(name, **config)
except KeyError:
raise ConfigError("no type specified for environment `%s'" %
name) from None
# Populate the systems directory
for sys_name, config in sysconfig.items():
if not isinstance(config, dict):
raise TypeError('system configuration is not a dictionary')
if not isinstance(config['partitions'], collections.abc.Mapping):
raise TypeError('partitions must be a dictionary')
sys_descr = config.get('descr', sys_name)
sys_hostnames = config.get('hostnames', [])
# The System's constructor provides also reasonable defaults, but
# since we are going to set them anyway from the values provided by
# the configuration, we should set default values here. The stage,
# output and log directories default to None, since they are going
# to be set dynamically by the runtime.
sys_prefix = config.get('prefix', '.')
sys_stagedir = config.get('stagedir', None)
sys_outputdir = config.get('outputdir', None)
sys_perflogdir = config.get('perflogdir', None)
sys_logdir = config.get('logdir', None)
sys_resourcesdir = config.get('resourcesdir', '.')
sys_modules_system = config.get('modules_system', None)
# Expand variables
if sys_prefix:
sys_prefix = os.path.expandvars(sys_prefix)
if sys_stagedir:
sys_stagedir = os.path.expandvars(sys_stagedir)
if sys_outputdir:
sys_outputdir = os.path.expandvars(sys_outputdir)
if sys_logdir:
user_deprecation_warning(
"`logdir' attribute in system config is deprecated; "
"please use `perflogdir' instead")
sys_perflogdir = os.path.expandvars(sys_logdir)
if sys_perflogdir:
sys_perflogdir = os.path.expandvars(sys_perflogdir)
if sys_resourcesdir:
sys_resourcesdir = os.path.expandvars(sys_resourcesdir)
system = System(name=sys_name,
descr=sys_descr,
hostnames=sys_hostnames,
prefix=sys_prefix,
stagedir=sys_stagedir,
outputdir=sys_outputdir,
perflogdir=sys_perflogdir,
resourcesdir=sys_resourcesdir,
modules_system=sys_modules_system)
for part_name, partconfig in config.get('partitions', {}).items():
if not isinstance(partconfig, collections.abc.Mapping):
raise TypeError("partition `%s' not configured "
"as a dictionary" % part_name)
part_descr = partconfig.get('descr', part_name)
part_scheduler, part_launcher = self.get_schedsystem_config(
partconfig.get('scheduler', 'local+local'))
part_local_env = m_env.Environment(
name='__rfm_env_%s' % part_name,
modules=partconfig.get('modules', []),
variables=partconfig.get('variables', {}).items())
part_environs = [
create_env(sys_name, part_name, e)
for e in partconfig.get('environs', [])
]
part_access = partconfig.get('access', [])
part_resources = partconfig.get('resources', {})
part_max_jobs = partconfig.get('max_jobs', 1)
system.add_partition(
SystemPartition(name=part_name,
descr=part_descr,
scheduler=part_scheduler,
launcher=part_launcher,
access=part_access,
environs=part_environs,
resources=part_resources,
local_env=part_local_env,
max_jobs=part_max_jobs))
self._systems[sys_name] = system
def deprecation_warning(self):
user_deprecation_warning('feature foo is deprecated')
def __get__(self, obj, objtype):
if self._op & DeprecatedField.OP_GET:
user_deprecation_warning(self._message)
return self._target_field.__get__(obj, objtype)
def __set__(self, obj, value):
if self._op & DeprecatedField.OP_SET:
user_deprecation_warning(self._message)
self._target_field.__set__(obj, value)
def compile(self, **compile_opts):
"""The compilation phase of the regression test pipeline.
:arg compile_opts: Extra options to be passed to the programming
environment for compiling the source code of the test.
:raises reframe.core.exceptions.ReframeError: In case of errors.
"""
if not self._current_environ:
raise PipelineError('no programming environment set')
# Copy the check's resources to the stage directory
if self.sourcesdir:
try:
commonpath = os.path.commonpath(
[self.sourcesdir, self.sourcepath])
except ValueError:
commonpath = None
if commonpath:
self.logger.warn(
"sourcepath `%s' seems to be a subdirectory of "
"sourcesdir `%s', but it will be interpreted "
"as relative to it." % (self.sourcepath, self.sourcesdir))
if os_ext.is_url(self.sourcesdir):
self._clone_to_stagedir(self.sourcesdir)
else:
self._copy_to_stagedir(
os.path.join(self._prefix, self.sourcesdir))
# Verify the sourcepath and determine the sourcepath in the stagedir
if (os.path.isabs(self.sourcepath)
or os.path.normpath(self.sourcepath).startswith('..')):
raise PipelineError(
'self.sourcepath is an absolute path or does not point to a '
'subfolder or a file contained in self.sourcesdir: ' +
self.sourcepath)
staged_sourcepath = os.path.join(self._stagedir, self.sourcepath)
self.logger.debug('Staged sourcepath: %s' % staged_sourcepath)
if os.path.isdir(staged_sourcepath):
if not self.build_system:
# Try to guess the build system
cmakelists = os.path.join(staged_sourcepath, 'CMakeLists.txt')
configure_ac = os.path.join(staged_sourcepath, 'configure.ac')
configure_in = os.path.join(staged_sourcepath, 'configure.in')
if os.path.exists(cmakelists):
self.build_system = 'CMake'
self.build_system.builddir = 'rfm_build'
elif (os.path.exists(configure_ac)
or os.path.exists(configure_in)):
self.build_system = 'Autotools'
self.build_system.builddir = 'rfm_build'
else:
self.build_system = 'Make'
self.build_system.srcdir = self.sourcepath
else:
if not self.build_system:
self.build_system = 'SingleSource'
self.build_system.srcfile = self.sourcepath
self.build_system.executable = self.executable
if compile_opts:
user_deprecation_warning(
'passing options to the compile() method is deprecated; '
'please use a build system.')
# Remove source and executable from compile_opts
compile_opts.pop('source', None)
compile_opts.pop('executable', None)
try:
self.build_system.makefile = compile_opts['makefile']
self.build_system.options = compile_opts['options']
except KeyError:
pass
# Prepare build job
build_commands = [
*self.prebuild_cmd,
*self.build_system.emit_build_commands(self._current_environ),
*self.postbuild_cmd
]
environs = [
self._current_partition.local_env, self._current_environ,
self._user_environ
]
self._build_job = getscheduler('local')(
name='rfm_%s_build' % self.name,
launcher=getlauncher('local')(),
workdir=self._stagedir)
with os_ext.change_dir(self._stagedir):
try:
self._build_job.prepare(build_commands,
environs,
trap_errors=True)
except OSError as e:
raise PipelineError('failed to prepare build job') from e
self._build_job.submit()
def __get__(self, obj, objtype):
user_deprecation_warning(self._message)
return self._target_field.__get__(obj, objtype)
def __set__(self, obj, value):
user_deprecation_warning(self._message)
self._target_field.__set__(obj, value)
