"""

# Here we sort first on the fact that a version is marked

# as preferred in the package, then on the fact that the

# version is not develop, then lexicographically

key_fn = lambda v: (pkg.versions[v].get('preferred', False),

not v.isdevelop(),

v)

"""Manages a single phase of the installation.

def __init__(self, name):

self.name = name

self.run_before = []

self.run_after = []

def __get__(self, instance, owner):

# The caller is a class that is trying to customize

# my behavior adding something

if instance is None:

return self

# If instance is there the caller wants to execute the

# install phase, thus return a properly set wrapper

phase = getattr(instance, self.name)

@functools.wraps(phase)

def phase_wrapper(spec, prefix):

# Check instance attributes at the beginning of a phase

self._on_phase_start(instance)

# Execute phase pre-conditions,

# and give them the chance to fail

for callback in self.run_before:

callback(instance)

phase(spec, prefix)

# Execute phase sanity_checks,

# and give them the chance to fail

for callback in self.run_after:

callback(instance)

# Check instance attributes at the end of a phase

self._on_phase_exit(instance)

return phase_wrapper

def _on_phase_start(self, instance):

# If a phase has a matching stop_before_phase attribute,

# stop the installation process raising a StopPhase

if getattr(instance, 'stop_before_phase', None) == self.name:

from spack.build_environment import StopPhase

raise StopPhase('Stopping before \'{0}\' phase'.format(self.name))

def _on_phase_exit(self, instance):

# If a phase has a matching last_phase attribute,

# stop the installation process raising a StopPhase

if getattr(instance, 'last_phase', None) == self.name:

from spack.build_environment import StopPhase

raise StopPhase('Stopping at \'{0}\' phase'.format(self.name))

def copy(self):

try:

return copy.deepcopy(self)

except TypeError:

# This bug-fix was not back-ported in Python 2.6

# http://bugs.python.org/issue1515

other = InstallPhase(self.name)

other.run_before.extend(self.run_before)

other.run_after.extend(self.run_after)

"""Check if a package is detectable and add default implementations

def __init__(cls, name, bases, attr_dict):

if hasattr(cls, 'executables') and hasattr(cls, 'libraries'):

msg = "a package can have either an 'executables' or 'libraries' attribute"

msg += " [package '{0.name}' defines both]"

raise spack.error.SpackError(msg.format(cls))

# On windows, extend the list of regular expressions to look for

# filenames ending with ".exe"

# (in some cases these regular expressions include "$" to avoid

# pulling in filenames with unexpected suffixes, but this allows

# for example detecting "foo.exe" when the package writer specified

# that "foo" was a possible executable.

# If a package has the executables or libraries attribute then it's

# assumed to be detectable

if hasattr(cls, 'executables') or hasattr(cls, 'libraries'):

@property

def platform_executables(self):

def to_windows_exe(exe):

if exe.endswith('$'):

exe = exe.replace('$', '%s$' % win_exe_ext())

else:

exe += win_exe_ext()

return exe

plat_exe = []

if hasattr(self, 'executables'):

for exe in self.executables:

if sys.platform == 'win32':

exe = to_windows_exe(exe)

plat_exe.append(exe)

return plat_exe

@classmethod

def determine_spec_details(cls, prefix, objs_in_prefix):

"""Allow ``spack external find ...`` to locate installations.

objs_by_version = collections.defaultdict(list)

# The default filter function is the identity function for the

# list of executables

filter_fn = getattr(cls, 'filter_detected_exes',

lambda x, exes: exes)

objs_in_prefix = filter_fn(prefix, objs_in_prefix)

for obj in objs_in_prefix:

try:

version_str = cls.determine_version(obj)

if version_str:

objs_by_version[version_str].append(obj)

except Exception as e:

msg = ('An error occurred when trying to detect '

'the version of "{0}" [{1}]')

tty.debug(msg.format(obj, str(e)))

specs = []

for version_str, objs in objs_by_version.items():

variants = cls.determine_variants(objs, version_str)

# Normalize output to list

if not isinstance(variants, list):

variants = [variants]

for variant in variants:

if isinstance(variant, six.string_types):

variant = (variant, {})

variant_str, extra_attributes = variant

spec_str = '{0}@{1} {2}'.format(

cls.name, version_str, variant_str

)

# Pop a few reserved keys from extra attributes, since

# they have a different semantics

external_path = extra_attributes.pop('prefix', None)

external_modules = extra_attributes.pop(

'modules', None

)

try:

spec = spack.spec.Spec(

spec_str,

external_path=external_path,

external_modules=external_modules

)

except Exception as e:

msg = 'Parsing failed [spec_str="{0}", error={1}]'

tty.debug(msg.format(spec_str, str(e)))

else:

specs.append(spack.spec.Spec.from_detection(

spec, extra_attributes=extra_attributes

))

return sorted(specs)

@classmethod

def determine_variants(cls, objs, version_str):

return ''

# Register the class as a detectable package

detectable_packages[cls.namespace].append(cls.name)

# Attach function implementations to the detectable class

default = False

if not hasattr(cls, 'determine_spec_details'):

default = True

cls.determine_spec_details = determine_spec_details

if default and not hasattr(cls, 'determine_version'):

msg = ('the package "{0}" in the "{1}" repo needs to define'

' the "determine_version" method to be detectable')

NotImplementedError(msg.format(cls.name, cls.namespace))

if default and not hasattr(cls, 'determine_variants'):

cls.determine_variants = determine_variants

# This function should not be overridden by subclasses,

# as it is not designed for bespoke pkg detection but rather

# on a per-platform basis

if 'platform_executables' in cls.__dict__.keys():

raise PackageError("Packages should not override platform_executables")

cls.platform_executables = platform_executables

DetectablePackageMeta,

spack.directives.DirectiveMeta,

spack.mixins.PackageMixinsMeta,

spack.multimethod.MultiMethodMeta

):

"""

phase_fmt = '_InstallPhase_{0}'

# These are accessed only through getattr, by name

_InstallPhase_run_before = {} # type: Dict[str, List[Callable]]

_InstallPhase_run_after = {} # type: Dict[str, List[Callable]]

def __new__(cls, name, bases, attr_dict):

"""

if 'phases' in attr_dict:

# Turn the strings in 'phases' into InstallPhase instances

# and add them as private attributes

_InstallPhase_phases = [PackageMeta.phase_fmt.format(x) for x in attr_dict['phases']] # NOQA: ignore=E501

for phase_name, callback_name in zip(_InstallPhase_phases, attr_dict['phases']): # NOQA: ignore=E501

attr_dict[phase_name] = InstallPhase(callback_name)

attr_dict['_InstallPhase_phases'] = _InstallPhase_phases

def _flush_callbacks(check_name):

# Name of the attribute I am going to check it exists

check_attr = PackageMeta.phase_fmt.format(check_name)

checks = getattr(cls, check_attr)

if checks:

for phase_name, funcs in checks.items():

phase_attr = PackageMeta.phase_fmt.format(phase_name)

try:

# Search for the phase in the attribute dictionary

phase = attr_dict[phase_attr]

except KeyError:

# If it is not there it's in the bases

# and we added a check. We need to copy

# and extend

for base in bases:

phase = getattr(base, phase_attr, None)

if phase is not None:

break

phase = attr_dict[phase_attr] = phase.copy()

getattr(phase, check_name).extend(funcs)

# Clear the attribute for the next class

setattr(cls, check_attr, {})

_flush_callbacks('run_before')

_flush_callbacks('run_after')

# Reset names for packages that inherit from another

# package with a different name

attr_dict['_name'] = None

return super(PackageMeta, cls).__new__(cls, name, bases, attr_dict)

@staticmethod

def register_callback(check_type, *phases):

def _decorator(func):

attr_name = PackageMeta.phase_fmt.format(check_type)

check_list = getattr(PackageMeta, attr_name)

for item in phases:

checks = check_list.setdefault(item, [])

checks.append(func)

setattr(PackageMeta, attr_name, check_list)

return func

return _decorator

@property

def package_dir(self):

"""Directory where the package.py file lives."""

return os.path.abspath(os.path.dirname(self.module.__file__))

@property

def module(self):

"""Module object (not just the name) that this package is defined in.

return __import__(self.__module__, fromlist=[self.__name__])

@property

def namespace(self):

"""Spack namespace for the package, which identifies its repo."""

return spack.repo.namespace_from_fullname(self.__module__)

@property

def fullname(self):

"""Name of this package, including the namespace"""

return '%s.%s' % (self.namespace, self.name)

@property

def fullnames(self):

"""

fullnames = []

for cls in inspect.getmro(self):

namespace = getattr(cls, 'namespace', None)

if namespace:

fullnames.append('%s.%s' % (namespace, self.name))

if namespace == 'builtin':

# builtin packages cannot inherit from other repos

break

return fullnames

@property

def name(self):

"""The name of this package.

if self._name is None:

self._name = self.module.__name__

if '.' in self._name:

self._name = self._name[self._name.rindex('.') + 1:]

"""Decorator: executes instance function only if object has attr valuses.

def _execute_under_condition(func):

@functools.wraps(func)

def _wrapper(instance, *args, **kwargs):

# If all the attributes have the value we require, then execute

has_all_attributes = all(

[hasattr(instance, key) for key in attr_dict]

)

if has_all_attributes:

has_the_right_values = all(

[getattr(instance, key) == value for key, value in attr_dict.items()] # NOQA: ignore=E501

)

if has_the_right_values:

func(instance, *args, **kwargs)

return _wrapper

"""This collects all functionality related to adding installed Spack

def view_source(self):

"""The source root directory that will be added to the view: files are

return self.spec.prefix

def view_destination(self, view):

"""The target root directory: each file is added relative to this

return view.get_projection_for_spec(self.spec)

def view_file_conflicts(self, view, merge_map):

"""Report any files which prevent adding this package to the view. The

return set(dst for dst in merge_map.values() if os.path.lexists(dst))

def add_files_to_view(self, view, merge_map, skip_if_exists=True):

"""Given a map of package files to destination paths in the view, add

if skip_if_exists:

for src, dst in merge_map.items():

if not os.path.lexists(dst):

view.link(src, dst, spec=self.spec)

else:

for src, dst in merge_map.items():

view.link(src, dst, spec=self.spec)

def remove_files_from_view(self, view, merge_map):

"""Given a map of package files to files currently linked in the view,

"""Build the pathname of the test log file

return os.path.join(test_stage,

"""This is the superclass for all spack packages.

#

# These are default values for instance variables.

#

#: A list or set of build time test functions to be called when tests

#: are executed or 'None' if there are no such test functions.

build_time_test_callbacks = None # type: Optional[List[str]]

#: By default, packages are not virtual

#: Virtual packages override this attribute

virtual = False

#: Most Spack packages are used to install source or binary code while

#: those that do not can be used to install a set of other Spack packages.

has_code = True

#: A list or set of install time test functions to be called when tests

#: are executed or 'None' if there are no such test functions.

install_time_test_callbacks = None # type: Optional[List[str]]

#: By default we build in parallel. Subclasses can override this.

parallel = True

#: By default do not run tests within package's install()

run_tests = False

# FIXME: this is a bad object-oriented design, should be moved to Clang.

#: By default do not setup mockup XCode on macOS with Clang

use_xcode = False

#: Most packages are NOT extendable. Set to True if you want extensions.

extendable = False

#: When True, add RPATHs for the entire DAG. When False, add RPATHs only

#: for immediate dependencies.

transitive_rpaths = True

#: List of prefix-relative file paths (or a single path). If these do

#: not exist after install, or if they exist but are not files,

#: sanity checks fail.

sanity_check_is_file = [] # type: List[str]

#: List of prefix-relative directory paths (or a single path). If

#: these do not exist after install, or if they exist but are not

#: directories, sanity checks will fail.

sanity_check_is_dir = [] # type: List[str]

#: List of glob expressions. Each expression must either be

#: absolute or relative to the package source path.

#: Matching artifacts found at the end of the build process will be

#: copied in the same directory tree as _spack_build_logfile and

#: _spack_build_envfile.

archive_files = [] # type: List[str]

#: Boolean. Set to ``True`` for packages that require a manual download.

#: This is currently used by package sanity tests and generation of a

#: more meaningful fetch failure error.

manual_download = False

#: Set of additional options used when fetching package versions.

fetch_options = {} # type: Dict[str, Any]

#

# Set default licensing information

#

#: Boolean. If set to ``True``, this software requires a license.

#: If set to ``False``, all of the ``license_*`` attributes will

#: be ignored. Defaults to ``False``.

license_required = False

#: String. Contains the symbol used by the license manager to denote

#: a comment. Defaults to ``#``.

license_comment = '#'

#: List of strings. These are files that the software searches for when

#: looking for a license. All file paths must be relative to the

#: installation directory. More complex packages like Intel may require

#: multiple licenses for individual components. Defaults to the empty list.

license_files = [] # type: List[str]

#: List of strings. Environment variables that can be set to tell the

#: software where to look for a license if it is not in the usual location.

#: Defaults to the empty list.

license_vars = [] # type: List[str]

#: String. A URL pointing to license setup instructions for the software.

#: Defaults to the empty string.

license_url = ''

#: Verbosity level, preserved across installs.

_verbose = None

#: index of patches by sha256 sum, built lazily

_patches_by_hash = None

#: Package homepage where users can find more information about the package

homepage = None # type: str

#: Default list URL (place to find available versions)

list_url = None # type: str

#: Link depth to which list_url should be searched for new versions

list_depth = 0

#: List of strings which contains GitHub usernames of package maintainers.

#: Do not include @ here in order not to unnecessarily ping the users.

maintainers = [] # type: List[str]

#: List of attributes to be excluded from a package's hash.

metadata_attrs = [

"homepage",

"url",

"urls",

"list_url",

"extendable",

"parallel",

"make_jobs",

"maintainers",

"tags",

]

#: Boolean. If set to ``True``, the smoke/install test requires a compiler.

#: This is currently used by smoke tests to ensure a compiler is available

#: to build a custom test code.

test_requires_compiler = False

#: List of test failures encountered during a smoke/install test run.

test_failures = None

#: TestSuite instance used to manage smoke/install tests for one or more

#: specs.

test_suite = None

def __init__(self, spec):

# this determines how the package should be built.

self.spec = spec

# Allow custom staging paths for packages

self.path = None

# Keep track of whether or not this package was installed from

# a binary cache.

self.installed_from_binary_cache = False

# Ensure that only one of these two attributes are present

if getattr(self, 'url', None) and getattr(self, 'urls', None):

msg = "a package can have either a 'url' or a 'urls' attribute"

msg += " [package '{0.name}' defines both]"

raise ValueError(msg.format(self))

# init internal variables

self._stage = None

self._fetcher = None

# Set up timing variables

self._fetch_time = 0.0

if self.is_extension:

spack.repo.get(self.extendee_spec)._check_extendable()

super(PackageBase, self).__init__()

@property

def installed_upstream(self):

if not hasattr(self, '_installed_upstream'):

upstream, record = spack.store.db.query_by_spec_hash(

self.spec.dag_hash())

self._installed_upstream = upstream

return self._installed_upstream

@classmethod

def possible_dependencies(

cls, transitive=True, expand_virtuals=True, deptype='all',

visited=None, missing=None, virtuals=None):

"""Return dict of possible dependencies of this package.

deptype = spack.dependency.canonical_deptype(deptype)

visited = {} if visited is None else visited

missing = {} if missing is None else missing

visited.setdefault(cls.name, set())

for name, conditions in cls.dependencies.items():

# check whether this dependency could be of the type asked for

types = [dep.type for cond, dep in conditions.items()]

types = set.union(*types)

if not any(d in types for d in deptype):

continue

# expand virtuals if enabled, otherwise just stop at virtuals

if spack.repo.path.is_virtual(name):

if virtuals is not None:

virtuals.add(name)

if expand_virtuals:

providers = spack.repo.path.providers_for(name)

dep_names = [spec.name for spec in providers]

else:

visited.setdefault(cls.name, set()).add(name)

visited.setdefault(name, set())

continue

else:

dep_names = [name]

# add the dependency names to the visited dict

visited.setdefault(cls.name, set()).update(set(dep_names))

# recursively traverse dependencies

for dep_name in dep_names:

if dep_name in visited:

continue

visited.setdefault(dep_name, set())

# skip the rest if not transitive

if not transitive:

continue

try:

dep_cls = spack.repo.path.get_pkg_class(dep_name)

except spack.repo.UnknownPackageError:

# log unknown packages

missing.setdefault(cls.name, set()).add(dep_name)

continue

dep_cls.possible_dependencies(

transitive, expand_virtuals, deptype, visited, missing,

virtuals)

return visited

def enum_constraints(self, visited=None):

"""Return transitive dependency constraints on this package."""

if visited is None:

visited = set()

visited.add(self.name)

names = []

clauses = []

for name in self.dependencies:

if name not in visited and not spack.spec.Spec(name).virtual:

pkg = spack.repo.get(name)

dvis, dnames, dclauses = pkg.enum_constraints(visited)

visited |= dvis

names.extend(dnames)

clauses.extend(dclauses)

return visited

# package_dir and module are *class* properties (see PackageMeta),

# but to make them work on instances we need these defs as well.

@property

def package_dir(self):

"""Directory where the package.py file lives."""

return type(self).package_dir

@property

def module(self):

"""Module object that this package is defined in."""

return type(self).module

@property

def namespace(self):

"""Spack namespace for the package, which identifies its repo."""

return type(self).namespace

@property

def fullname(self):

"""Name of this package, including namespace: namespace.name."""

return type(self).fullname

@property

def fullnames(self):

return type(self).fullnames

@property

def name(self):

"""Name of this package (the module without parent modules)."""

return type(self).name

@property

def global_license_dir(self):

"""Returns the directory where global license files for all

return os.path.join(spack.paths.prefix, 'etc', 'spack', 'licenses')

@property

def global_license_file(self):

"""Returns the path where a global license file for this

if not self.license_files:

return

return os.path.join(self.global_license_dir, self.name,

os.path.basename(self.license_files[0]))

@property

def version(self):

if not self.spec.versions.concrete:

raise ValueError("Version requested for a package that"

" does not have a concrete version.")

return self.spec.versions[0]

@memoized

def version_urls(self):

"""OrderedDict of explicitly defined URLs for versions of this package.

version_urls = collections.OrderedDict()

for v, args in sorted(self.versions.items()):

if 'url' in args:

version_urls[v] = args['url']

return version_urls

def nearest_url(self, version):

"""Finds the URL with the "closest" version to ``version``.

version_urls = self.version_urls()

if version in version_urls:

return version_urls[version]

last_url = None

for v, u in self.version_urls().items():