"""Information on an error reported in a test."""

def __init__(self, summary, details):

self.summary = summary

self.details = tuple(details)

def __str__(self):

return self.summary + '\n' + '\n'.join([

' ' + detail for detail in self.details

])

def __eq__(self, other):

if self.summary != other.summary or self.details != other.details:

return False

return True

def __hash__(self):

value = (self.summary, self.details)

def __init__(self, group, tag, description, kwargs):

"""Return an object that acts as a decorator to register functions

if tag in CALLBACKS:

msg = 'audit class "{0}" already registered'

raise ValueError(msg.format(tag))

self.group = group

self.tag = tag

self.description = description

self.kwargs = kwargs

self.callbacks = []

# Init the list of hooks

CALLBACKS[self.tag] = self

# Update the list of tags in the group

GROUPS[self.group].append(self.tag)

def __call__(self, func):

self.callbacks.append(func)

def __getitem__(self, item):

return self.callbacks[item]

def __len__(self):

return len(self.callbacks)

def run(self, **kwargs):

msg = 'please pass "{0}" as keyword arguments'

msg = msg.format(', '.join(self.kwargs))

assert set(self.kwargs) == set(kwargs), msg

errors = []

kwargs['error_cls'] = Error

for fn in self.callbacks:

errors.extend(fn(**kwargs))

"""Run the checks that are part of the group passed as argument.

reports = []

for check in GROUPS[group]:

errors = run_check(check, **kwargs)

reports.append((check, errors))

"""Run the checks associated with a single tag.

group='generic',

tag='GENERIC',

description='Generic checks relying on global variables',

kwargs=()

group='configs',

tag='CFG-COMPILER',

description='Sanity checks on compilers.yaml',

kwargs=()

"""Report compilers with the same spec and two different definitions"""

errors = []

compilers = list(sorted(

spack.config.get('compilers'), key=lambda x: x['compiler']['spec']

))

for spec, group in itertools.groupby(

compilers, key=lambda x: x['compiler']['spec']

):

group = list(group)

if len(group) == 1:

continue

error_msg = 'Compiler defined multiple times: {0}'

try:

details = [str(x._start_mark).strip() for x in group]

except Exception:

details = []

errors.append(error_cls(

summary=error_msg.format(spec), details=details

))

group='configs',

tag='CFG-PACKAGES',

description='Sanity checks on packages.yaml',

kwargs=()

"""Search for duplicate specs declared as externals"""

errors, externals = [], collections.defaultdict(list)

packages_yaml = spack.config.get('packages')

for name, pkg_config in packages_yaml.items():

# No externals can be declared under all

if name == 'all' or 'externals' not in pkg_config:

continue

current_externals = pkg_config['externals']

for entry in current_externals:

# Ask for the string representation of the spec to normalize

# aspects of the spec that may be represented in multiple ways

# e.g. +foo or foo=true

key = str(spack.spec.Spec(entry['spec']))

externals[key].append(entry)

for spec, entries in sorted(externals.items()):

# If there's a single external for a spec we are fine

if len(entries) < 2:

continue

# Otherwise wwe need to report an error

error_msg = 'Multiple externals share the same spec: {0}'.format(spec)

try:

lines = [str(x._start_mark).strip() for x in entries]

details = [

'Please remove all but one of the following entries:'

] + lines + [

'as they might result in non-deterministic hashes'

]

except TypeError:

details = []

errors.append(error_cls(summary=error_msg, details=details))

group='packages',

tag='PKG-DIRECTIVES',

description='Sanity checks on specs used in directives',

kwargs=('pkgs',)

group='packages-https',

tag='PKG-HTTPS-DIRECTIVES',

description='Sanity checks on https checks of package urls, etc.',

kwargs=('pkgs',)

"""Ensure that patches fetched from GitHub have stable sha256 hashes."""

github_patch_url_re = (

r"^https?://github\.com/.+/.+/(?:commit|pull)/[a-fA-F0-9]*.(?:patch|diff)"

)

errors = []

for pkg_name in pkgs:

pkg = spack.repo.get(pkg_name)

for condition, patches in pkg.patches.items():

for patch in patches:

if not isinstance(patch, spack.patch.UrlPatch):

continue

if not re.match(github_patch_url_re, patch.url):

continue

full_index_arg = "?full_index=1"

if not patch.url.endswith(full_index_arg):

errors.append(error_cls(

"patch URL in package {0} must end with {1}".format(

pkg.name, full_index_arg,

),

[patch.url],

))

"""Check for correctness of links

errors = []

for pkg_name in pkgs:

pkg = spack.repo.get(pkg_name)

# Does the homepage have http, and if so, does https work?

if pkg.homepage.startswith('http://'):

https = re.sub("http", "https", pkg.homepage, 1)

try:

response = urlopen(https)

except Exception as e:

msg = 'Error with attempting https for "{0}": '

errors.append(error_cls(msg.format(pkg.name), [str(e)]))

continue

if response.getcode() == 200:

msg = 'Package "{0}" uses http but has a valid https endpoint.'

errors.append(msg.format(pkg.name))

"""Report unknown or wrong variants in directives for this package"""

errors = []

for pkg_name in pkgs:

pkg = spack.repo.get(pkg_name)

# Check "conflicts" directive

for conflict, triggers in pkg.conflicts.items():

for trigger, _ in triggers:

vrn = spack.spec.Spec(conflict)

try:

vrn.constrain(trigger)

except Exception:

# If one of the conflict/trigger includes a platform and the other

# includes an os or target, the constraint will fail if the current

# platform is not the plataform in the conflict/trigger. Audit the

# conflict and trigger separately in that case.

# When os and target constraints can be created independently of

# the platform, TODO change this back to add an error.

errors.extend(_analyze_variants_in_directive(

pkg, spack.spec.Spec(trigger),

directive='conflicts', error_cls=error_cls

))

errors.extend(_analyze_variants_in_directive(

pkg, vrn, directive='conflicts', error_cls=error_cls

))

# Check "depends_on" directive

for _, triggers in pkg.dependencies.items():

triggers = list(triggers)

for trigger in list(triggers):

vrn = spack.spec.Spec(trigger)

errors.extend(_analyze_variants_in_directive(

pkg, vrn, directive='depends_on', error_cls=error_cls

))

# Check "patch" directive

for _, triggers in pkg.provided.items():

triggers = [spack.spec.Spec(x) for x in triggers]

for vrn in triggers:

errors.extend(_analyze_variants_in_directive(

pkg, vrn, directive='patch', error_cls=error_cls

))

# Check "resource" directive

for vrn in pkg.resources:

errors.extend(_analyze_variants_in_directive(

pkg, vrn, directive='resource', error_cls=error_cls

))

"""Report unknown dependencies and wrong variants for dependencies"""

errors = []

for pkg_name in pkgs:

pkg = spack.repo.get(pkg_name)

filename = spack.repo.path.filename_for_package_name(pkg_name)

for dependency_name, dependency_data in pkg.dependencies.items():

# No need to analyze virtual packages

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

continue

try:

dependency_pkg = spack.repo.get(dependency_name)

except spack.repo.UnknownPackageError:

# This dependency is completely missing, so report

# and continue the analysis

summary = (pkg_name + ": unknown package '{0}' in "

"'depends_on' directive".format(dependency_name))

details = [

" in " + filename

]

errors.append(error_cls(summary=summary, details=details))

continue

for _, dependency_edge in dependency_data.items():

dependency_variants = dependency_edge.spec.variants

for name, value in dependency_variants.items():

try:

v, _ = dependency_pkg.variants[name]

v.validate_or_raise(value, pkg=dependency_pkg)

except Exception as e:

summary = (pkg_name + ": wrong variant used for a "

"dependency in a 'depends_on' directive")

error_msg = str(e).strip()

if isinstance(e, KeyError):

error_msg = ('the variant {0} does not '

'exist'.format(error_msg))

error_msg += " in package '" + dependency_name + "'"

errors.append(error_cls(

summary=summary, details=[error_msg, 'in ' + filename]

))

"""Report if version constraints used in directives are not satisfiable"""

errors = []

for pkg_name in pkgs:

pkg = spack.repo.get(pkg_name)

filename = spack.repo.path.filename_for_package_name(pkg_name)

dependencies_to_check = []

for dependency_name, dependency_data in pkg.dependencies.items():

# Skip virtual dependencies for the time being, check on

# their versions can be added later

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

continue

dependencies_to_check.extend(

[edge.spec for edge in dependency_data.values()]

)

for s in dependencies_to_check:

dependency_pkg = None

try:

dependency_pkg = spack.repo.get(s.name)

assert any(

v.satisfies(s.versions) for v in list(dependency_pkg.versions)

)

except Exception:

summary = ("{0}: dependency on {1} cannot be satisfied "

"by known versions of {1.name}").format(pkg_name, s)

details = ['happening in ' + filename]

if dependency_pkg is not None:

details.append('known versions of {0.name} are {1}'.format(

s, ', '.join([str(x) for x in dependency_pkg.versions])

))

errors.append(error_cls(summary=summary, details=details))

variant_exceptions = (

spack.variant.InconsistentValidationError,

spack.variant.MultipleValuesInExclusiveVariantError,

spack.variant.InvalidVariantValueError,

KeyError

)

errors = []

for name, v in constraint.variants.items():

try:

variant, _ = pkg.variants[name]

variant.validate_or_raise(v, pkg=pkg)

except variant_exceptions as e:

summary = pkg.name + ': wrong variant in "{0}" directive'

summary = summary.format(directive)

filename = spack.repo.path.filename_for_package_name(pkg.name)

error_msg = str(e).strip()

if isinstance(e, KeyError):

error_msg = 'the variant {0} does not exist'.format(error_msg)

err = error_cls(summary=summary, details=[

error_msg, 'in ' + filename

])

errors.append(err)