diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/spack/docs/build_settings.rst | 66 | ||||
| -rw-r--r-- | lib/spack/spack/schema/packages.py | 23 | ||||
| -rw-r--r-- | lib/spack/spack/solver/asp.py | 26 | ||||
| -rw-r--r-- | lib/spack/spack/solver/concretize.lp | 178 | ||||
| -rw-r--r-- | lib/spack/spack/test/concretize_preferences.py | 14 | ||||
| -rw-r--r-- | lib/spack/spack/test/concretize_requirements.py | 299 | ||||
| -rw-r--r-- | lib/spack/spack/test/conftest.py | 14 |
7 files changed, 545 insertions, 75 deletions
diff --git a/lib/spack/docs/build_settings.rst b/lib/spack/docs/build_settings.rst index 568b92aac3..c306536c51 100644 --- a/lib/spack/docs/build_settings.rst +++ b/lib/spack/docs/build_settings.rst @@ -339,6 +339,72 @@ concretization rules. A provider lists a value that packages may ``depend_on`` (e.g, MPI) and a list of rules for fulfilling that dependency. +.. _package-requirements: + +-------------------- +Package Requirements +-------------------- + +You can use the configuration to force the concretizer to choose +specific properties for packages when building them. Like preferences, +these are only applied when the package is required by some other +request (e.g. if the package is needed as a dependency of a +request to ``spack install``). + +An example of where this is useful is if you have a package that +is normally built as a dependency but only under certain circumstances +(e.g. only when a variant on a dependent is active): you can make +sure that it always builds the way you want it to; this distinguishes +package configuration requirements from constraints that you add to +``spack install`` or to environments (in those cases, the associated +packages are always built). + +The following is an example of how to enforce package properties in +``packages.yaml``: + +.. code-block:: yaml + + packages: + libfabric: + require: "@1.13.2" + openmpi: + require: + - any_of: ["~cuda", "gcc"] + mpich: + require: + - one_of: ["+cuda", "+rocm"] + +Requirements are expressed using Spec syntax (the same as what is provided +to ``spack install``). In the simplest case, you can specify attributes +that you always want the package to have by providing a single spec to +``require``; in the above example, ``libfabric`` will always build +with version 1.13.2. + +You can provide a more-relaxed constraint and allow the concretizer to +choose between a set of options using ``any_of`` or ``one_of``: + +* ``any_of`` is a list of specs. One of those specs must be satisfied + and it is also allowed for the concretized spec to match more than one. + In the above example, that means you could build ``openmpi+cuda%gcc``, + ``openmpi~cuda%clang`` or ``openmpi~cuda%gcc`` (in the last case, + note that both specs in the ``any_of`` for ``openmpi`` are + satisfied). +* ``one_of`` is also a list of specs, and the final concretized spec + must match exactly one of them. In the above example, that means + you could build ``mpich+cuda`` or ``mpich+rocm`` but not + ``mpich+cuda+rocm`` (note the current package definition for + ``mpich`` already includes a conflict, so this is redundant but + still demonstrates the concept). + +Other notes about ``requires``: + +* You can only specify requirements for specific packages: you cannot + add ``requires`` under ``all``. +* You cannot specify requirements for virtual packages (e.g. you can + specify requirements for ``openmpi`` but not ``mpi``). +* For ``any_of`` and ``one_of``, the order of specs indicates a + preference: items that appear earlier in the list are preferred + (note that these preferences can be ignored in favor of others). .. _package_permissions: diff --git a/lib/spack/spack/schema/packages.py b/lib/spack/spack/schema/packages.py index 87d489028e..92fe9e0ba8 100644 --- a/lib/spack/spack/schema/packages.py +++ b/lib/spack/spack/schema/packages.py @@ -21,6 +21,29 @@ properties = { "default": {}, "additionalProperties": False, "properties": { + "require": { + "oneOf": [ + # 'require' can be a list of requirement_groups. + # each requirement group is a list of one or more + # specs. Either at least one or exactly one spec + # in the group must be satisfied (depending on + # whether you use "any_of" or "one_of", + # repectively) + { + "type": "array", + "items": { + "type": "object", + "properties": { + "one_of": {"type": "array"}, + "any_of": {"type": "array"}, + }, + }, + }, + # Shorthand for a single requirement group with + # one member + {"type": "string"}, + ] + }, "version": { "type": "array", "default": [], diff --git a/lib/spack/spack/solver/asp.py b/lib/spack/spack/solver/asp.py index c28e6f459a..080e21ca5f 100644 --- a/lib/spack/spack/solver/asp.py +++ b/lib/spack/spack/solver/asp.py @@ -927,6 +927,30 @@ class SpackSolverSetup(object): fn.node_compiler_preference(pkg.name, cspec.name, cspec.version, -i * 100) ) + def package_requirement_rules(self, pkg): + pkg_name = pkg.name + config = spack.config.get("packages") + requirements = config.get(pkg_name, {}).get("require", []) + if isinstance(requirements, string_types): + rules = [(pkg_name, "one_of", [requirements])] + else: + rules = [] + for requirement in requirements: + for policy in ("one_of", "any_of"): + if policy in requirement: + rules.append((pkg_name, policy, requirement[policy])) + + for requirement_grp_id, (pkg_name, policy, requirement_grp) in enumerate(rules): + self.gen.fact(fn.requirement_group(pkg_name, requirement_grp_id)) + self.gen.fact(fn.requirement_policy(pkg_name, requirement_grp_id, policy)) + for requirement_weight, spec_str in enumerate(requirement_grp): + spec = spack.spec.Spec(spec_str) + if not spec.name: + spec.name = pkg_name + member_id = self.condition(spec, imposed_spec=spec, name=pkg_name) + self.gen.fact(fn.requirement_group_member(member_id, pkg_name, requirement_grp_id)) + self.gen.fact(fn.requirement_has_weight(member_id, requirement_weight)) + def pkg_rules(self, pkg, tests): pkg = packagize(pkg) @@ -1017,6 +1041,8 @@ class SpackSolverSetup(object): lambda v, p, i: self.gen.fact(fn.pkg_provider_preference(pkg.name, v, p, i)), ) + self.package_requirement_rules(pkg) + def condition(self, required_spec, imposed_spec=None, name=None, msg=None): """Generate facts for a dependency or virtual provider condition. diff --git a/lib/spack/spack/solver/concretize.lp b/lib/spack/spack/solver/concretize.lp index 8ed6b1b6bb..3a497c1d3b 100644 --- a/lib/spack/spack/solver/concretize.lp +++ b/lib/spack/spack/solver/concretize.lp @@ -501,6 +501,49 @@ error(2, "Attempted to use external for '{0}' which does not satisfy any configu #defined external_spec_condition/5. %----------------------------------------------------------------------------- +% Config required semantics +%----------------------------------------------------------------------------- + +requirement_group_satisfied(Package, X) :- + 1 { condition_holds(Y) : requirement_group_member(Y, Package, X) } 1, + node(Package), + requirement_policy(Package, X, "one_of"), + requirement_group(Package, X). + +requirement_weight(Package, W) :- + condition_holds(Y), + requirement_has_weight(Y, W), + requirement_group_member(Y, Package, X), + requirement_policy(Package, X, "one_of"), + requirement_group_satisfied(Package, X). + +requirement_group_satisfied(Package, X) :- + 1 { condition_holds(Y) : requirement_group_member(Y, Package, X) } , + node(Package), + requirement_policy(Package, X, "any_of"), + requirement_group(Package, X). + +requirement_weight(Package, W) :- + W = #min { + Z : requirement_has_weight(Y, Z), condition_holds(Y), requirement_group_member(Y, Package, X); + % We need this to avoid an annoying warning during the solve + % concretize.lp:1151:5-11: info: tuple ignored: + % #sup@73 + 10000 + }, + requirement_policy(Package, X, "any_of"), + requirement_group_satisfied(Package, X). + +error(2, "Cannot satisfy requirement group for package '{0}'", Package) :- + node(Package), + requirement_group(Package, X), + not requirement_group_satisfied(Package, X). + +#defined requirement_group/2. +#defined requirement_group_member/3. +#defined requirement_has_weight/2. + +%----------------------------------------------------------------------------- % Variant semantics %----------------------------------------------------------------------------- % a variant is a variant of a package if it is a variant under some condition @@ -898,8 +941,7 @@ error(2, "No valid version for '{0}' compiler '{1}' satisfies '@{2}'", Package, % the compiler associated with the node satisfy the same constraint node_compiler_version_satisfies(Package, Compiler, Constraint) :- node_compiler_version(Package, Compiler, Version), - compiler_version_satisfies(Compiler, Constraint, Version), - build(Package). + compiler_version_satisfies(Compiler, Constraint, Version). #defined compiler_version_satisfies/3. @@ -1092,12 +1134,24 @@ opt_criterion(100, "number of packages to build (vs. reuse)"). #minimize { 1@100,Package : build(Package), optimize_for_reuse() }. #defined optimize_for_reuse/0. +% A condition group specifies one or more specs that must be satisfied. +% Specs declared first are preferred, so we assign increasing weights and +% minimize the weights. +opt_criterion(75, "requirement weight"). +#minimize{ 0@275: #true }. +#minimize{ 0@75: #true }. +#minimize { + Weight@75+Priority + : requirement_weight(Package, Weight), + build_priority(Package, Priority) +}. + % Minimize the number of deprecated versions being used -opt_criterion(15, "deprecated versions used"). -#minimize{ 0@215: #true }. -#minimize{ 0@15: #true }. +opt_criterion(73, "deprecated versions used"). +#minimize{ 0@273: #true }. +#minimize{ 0@73: #true }. #minimize{ - 1@15+Priority,Package + 1@73+Priority,Package : deprecated(Package, _), build_priority(Package, Priority) }. @@ -1106,51 +1160,51 @@ opt_criterion(15, "deprecated versions used"). % 1. Version weight % 2. Number of variants with a non default value, if not set % for the root(Package) -opt_criterion(14, "version weight"). -#minimize{ 0@214: #true }. -#minimize{ 0@14: #true }. +opt_criterion(70, "version weight"). +#minimize{ 0@270: #true }. +#minimize{ 0@70: #true }. #minimize { - Weight@14+Priority + Weight@70+Priority : root(Package),version_weight(Package, Weight), build_priority(Package, Priority) }. -opt_criterion(13, "number of non-default variants (roots)"). -#minimize{ 0@213: #true }. -#minimize{ 0@13: #true }. +opt_criterion(65, "number of non-default variants (roots)"). +#minimize{ 0@265: #true }. +#minimize{ 0@65: #true }. #minimize { - 1@13+Priority,Package,Variant,Value + 1@65+Priority,Package,Variant,Value : variant_not_default(Package, Variant, Value), root(Package), build_priority(Package, Priority) }. -opt_criterion(12, "preferred providers for roots"). -#minimize{ 0@212 : #true }. -#minimize{ 0@12: #true }. +opt_criterion(60, "preferred providers for roots"). +#minimize{ 0@260: #true }. +#minimize{ 0@60: #true }. #minimize{ - Weight@12+Priority,Provider,Virtual + Weight@60+Priority,Provider,Virtual : provider_weight(Provider, Virtual, Weight), root(Provider), build_priority(Provider, Priority) }. -opt_criterion(11, "default values of variants not being used (roots)"). -#minimize{ 0@211: #true }. -#minimize{ 0@11: #true }. +opt_criterion(55, "default values of variants not being used (roots)"). +#minimize{ 0@255: #true }. +#minimize{ 0@55: #true }. #minimize{ - 1@11+Priority,Package,Variant,Value + 1@55+Priority,Package,Variant,Value : variant_default_not_used(Package, Variant, Value), root(Package), build_priority(Package, Priority) }. % Try to use default variants or variants that have been set -opt_criterion(10, "number of non-default variants (non-roots)"). -#minimize{ 0@210: #true }. -#minimize{ 0@10: #true }. +opt_criterion(50, "number of non-default variants (non-roots)"). +#minimize{ 0@250: #true }. +#minimize{ 0@50: #true }. #minimize { - 1@10+Priority,Package,Variant,Value + 1@50+Priority,Package,Variant,Value : variant_not_default(Package, Variant, Value), not root(Package), build_priority(Package, Priority) @@ -1158,91 +1212,91 @@ opt_criterion(10, "number of non-default variants (non-roots)"). % Minimize the weights of the providers, i.e. use as much as % possible the most preferred providers -opt_criterion(9, "preferred providers (non-roots)"). -#minimize{ 0@209: #true }. -#minimize{ 0@9: #true }. +opt_criterion(45, "preferred providers (non-roots)"). +#minimize{ 0@245: #true }. +#minimize{ 0@45: #true }. #minimize{ - Weight@9+Priority,Provider,Virtual + Weight@45+Priority,Provider,Virtual : provider_weight(Provider, Virtual, Weight), not root(Provider), build_priority(Provider, Priority) }. % Try to minimize the number of compiler mismatches in the DAG. -opt_criterion(8, "compiler mismatches"). -#minimize{ 0@208: #true }. -#minimize{ 0@8: #true }. +opt_criterion(40, "compiler mismatches"). +#minimize{ 0@240: #true }. +#minimize{ 0@40: #true }. #minimize{ - 1@8+Priority,Package,Dependency + 1@40+Priority,Package,Dependency : compiler_mismatch(Package, Dependency), build_priority(Package, Priority) }. % Try to minimize the number of compiler mismatches in the DAG. -opt_criterion(7, "OS mismatches"). -#minimize{ 0@207: #true }. -#minimize{ 0@7: #true }. +opt_criterion(35, "OS mismatches"). +#minimize{ 0@235: #true }. +#minimize{ 0@35: #true }. #minimize{ - 1@7+Priority,Package,Dependency + 1@35+Priority,Package,Dependency : node_os_mismatch(Package, Dependency), build_priority(Package, Priority) }. -opt_criterion(6, "non-preferred OS's"). -#minimize{ 0@206: #true }. -#minimize{ 0@6: #true }. +opt_criterion(30, "non-preferred OS's"). +#minimize{ 0@230: #true }. +#minimize{ 0@30: #true }. #minimize{ - Weight@6+Priority,Package + Weight@30+Priority,Package : node_os_weight(Package, Weight), build_priority(Package, Priority) }. % Choose more recent versions for nodes -opt_criterion(5, "version badness"). -#minimize{ 0@205: #true }. -#minimize{ 0@5: #true }. +opt_criterion(25, "version badness"). +#minimize{ 0@225: #true }. +#minimize{ 0@25: #true }. #minimize{ - Weight@5+Priority,Package + Weight@25+Priority,Package : version_weight(Package, Weight), build_priority(Package, Priority) }. % Try to use all the default values of variants -opt_criterion(4, "default values of variants not being used (non-roots)"). -#minimize{ 0@204: #true }. -#minimize{ 0@4: #true }. +opt_criterion(20, "default values of variants not being used (non-roots)"). +#minimize{ 0@220: #true }. +#minimize{ 0@20: #true }. #minimize{ - 1@4+Priority,Package,Variant,Value + 1@20+Priority,Package,Variant,Value : variant_default_not_used(Package, Variant, Value), not root(Package), build_priority(Package, Priority) }. % Try to use preferred compilers -opt_criterion(3, "non-preferred compilers"). -#minimize{ 0@203: #true }. -#minimize{ 0@3: #true }. +opt_criterion(15, "non-preferred compilers"). +#minimize{ 0@215: #true }. +#minimize{ 0@15: #true }. #minimize{ - Weight@3+Priority,Package + Weight@15+Priority,Package : compiler_weight(Package, Weight), build_priority(Package, Priority) }. % Minimize the number of mismatches for targets in the DAG, try % to select the preferred target. -opt_criterion(2, "target mismatches"). -#minimize{ 0@202: #true }. -#minimize{ 0@2: #true }. +opt_criterion(10, "target mismatches"). +#minimize{ 0@210: #true }. +#minimize{ 0@10: #true }. #minimize{ - 1@2+Priority,Package,Dependency + 1@10+Priority,Package,Dependency : node_target_mismatch(Package, Dependency), build_priority(Package, Priority) }. -opt_criterion(1, "non-preferred targets"). -#minimize{ 0@201: #true }. -#minimize{ 0@1: #true }. +opt_criterion(5, "non-preferred targets"). +#minimize{ 0@205: #true }. +#minimize{ 0@5: #true }. #minimize{ - Weight@1+Priority,Package + Weight@5+Priority,Package : node_target_weight(Package, Weight), build_priority(Package, Priority) }. diff --git a/lib/spack/spack/test/concretize_preferences.py b/lib/spack/spack/test/concretize_preferences.py index 379e5447d0..9ad5a498ee 100644 --- a/lib/spack/spack/test/concretize_preferences.py +++ b/lib/spack/spack/test/concretize_preferences.py @@ -12,24 +12,12 @@ import spack.config import spack.package_prefs import spack.repo import spack.util.spack_yaml as syaml -from spack.config import ConfigError, ConfigScope +from spack.config import ConfigError from spack.spec import Spec from spack.version import Version @pytest.fixture() -def concretize_scope(mutable_config, tmpdir): - """Adds a scope for concretization preferences""" - tmpdir.ensure_dir("concretize") - mutable_config.push_scope(ConfigScope("concretize", str(tmpdir.join("concretize")))) - - yield - - mutable_config.pop_scope() - spack.repo.path._provider_index = None - - -@pytest.fixture() def configure_permissions(): conf = syaml.load_config( """\ diff --git a/lib/spack/spack/test/concretize_requirements.py b/lib/spack/spack/test/concretize_requirements.py new file mode 100644 index 0000000000..42d680dd72 --- /dev/null +++ b/lib/spack/spack/test/concretize_requirements.py @@ -0,0 +1,299 @@ +# Copyright 2013-2022 Lawrence Livermore National Security, LLC and other +# Spack Project Developers. See the top-level COPYRIGHT file for details. +# +# SPDX-License-Identifier: (Apache-2.0 OR MIT) + +import sys + +import pytest + +import spack.config +import spack.repo +import spack.util.spack_yaml as syaml +from spack.solver.asp import UnsatisfiableSpecError +from spack.spec import Spec + +pytestmark = pytest.mark.skipif(sys.platform == "win32", reason="Windows uses old concretizer") + + +def update_packages_config(conf_str): + conf = syaml.load_config(conf_str) + spack.config.set("packages", conf["packages"], scope="concretize") + + +_pkgx = ( + "x", + """\ +class X(Package): + version('1.1') + version('1.0') + version('0.9') + + variant('shared', default=True, + description='Build shared libraries') + + depends_on('y') +""", +) + + +_pkgy = ( + "y", + """\ +class Y(Package): + version('2.5') + version('2.4') + version('2.3', deprecated=True) + + variant('shared', default=True, + description='Build shared libraries') +""", +) + + +_pkgv = ( + "v", + """\ +class V(Package): + version('2.1') + version('2.0') +""", +) + + +@pytest.fixture +def create_test_repo(tmpdir, mutable_config): + repo_path = str(tmpdir) + repo_yaml = tmpdir.join("repo.yaml") + with open(str(repo_yaml), "w") as f: + f.write( + """\ +repo: + namespace: testcfgrequirements +""" + ) + + packages_dir = tmpdir.join("packages") + for (pkg_name, pkg_str) in [_pkgx, _pkgy, _pkgv]: + pkg_dir = packages_dir.ensure(pkg_name, dir=True) + pkg_file = pkg_dir.join("package.py") + with open(str(pkg_file), "w") as f: + f.write(pkg_str) + + yield spack.repo.Repo(repo_path) + + +@pytest.fixture +def test_repo(create_test_repo, monkeypatch, mock_stage): + with spack.repo.use_repositories(create_test_repo) as mock_repo_path: + yield mock_repo_path + + +class MakeStage(object): + def __init__(self, stage): + self.stage = stage + + def __call__(self, *args, **kwargs): + return self.stage + + +@pytest.fixture +def fake_installs(monkeypatch, tmpdir): + stage_path = str(tmpdir.ensure("fake-stage", dir=True)) + universal_unused_stage = spack.stage.DIYStage(stage_path) + monkeypatch.setattr( + spack.package_base.Package, "_make_stage", MakeStage(universal_unused_stage) + ) + + +def test_requirement_isnt_optional(concretize_scope, test_repo): + """If a user spec requests something that directly conflicts + with a requirement, make sure we get an error. + """ + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + conf_str = """\ +packages: + x: + require: "@1.0" +""" + update_packages_config(conf_str) + with pytest.raises(UnsatisfiableSpecError): + Spec("x@1.1").concretize() + + +def test_requirement_is_successfully_applied(concretize_scope, test_repo): + """If a simple requirement can be satisfied, make sure the + concretization succeeds and the requirement spec is applied. + """ + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + s1 = Spec("x").concretized() + # Without any requirements/preferences, the later version is preferred + assert s1.satisfies("@1.1") + + conf_str = """\ +packages: + x: + require: "@1.0" +""" + update_packages_config(conf_str) + s2 = Spec("x").concretized() + # The requirement forces choosing the eariler version + assert s2.satisfies("@1.0") + + +def test_multiple_packages_requirements_are_respected(concretize_scope, test_repo): + """Apply requirements to two packages; make sure the concretization + succeeds and both requirements are respected. + """ + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + conf_str = """\ +packages: + x: + require: "@1.0" + y: + require: "@2.4" +""" + update_packages_config(conf_str) + spec = Spec("x").concretized() + assert spec["x"].satisfies("@1.0") + assert spec["y"].satisfies("@2.4") + + +def test_oneof(concretize_scope, test_repo): + """'one_of' allows forcing the concretizer to satisfy one of + the specs in the group (but not all have to be satisfied). + """ + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + conf_str = """\ +packages: + y: + require: + - one_of: ["@2.4", "~shared"] +""" + update_packages_config(conf_str) + spec = Spec("x").concretized() + # The concretizer only has to satisfy one of @2.4/~shared, and @2.4 + # comes first so it is prioritized + assert spec["y"].satisfies("@2.4+shared") + + +def test_one_package_multiple_oneof_groups(concretize_scope, test_repo): + """One package has two 'one_of' groups; check that both are + applied. + """ + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + conf_str = """\ +packages: + y: + require: + - one_of: ["@2.4%gcc", "@2.5%clang"] + - one_of: ["@2.5~shared", "@2.4+shared"] +""" + update_packages_config(conf_str) + + s1 = Spec("y@2.5").concretized() + assert s1.satisfies("%clang~shared") + + s2 = Spec("y@2.4").concretized() + assert s2.satisfies("%gcc+shared") + + +def test_requirements_for_package_that_is_not_needed(concretize_scope, test_repo): + """Specify requirements for specs that are not concretized or + a dependency of a concretized spec (in other words, none of + the requirements are used for the requested spec). + """ + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + # Note that the exact contents aren't important since this isn't + # intended to be used, but the important thing is that a number of + # packages have requirements applied + conf_str = """\ +packages: + x: + require: "@1.0" + y: + require: + - one_of: ["@2.4%gcc", "@2.5%clang"] + - one_of: ["@2.5~shared", "@2.4+shared"] +""" + update_packages_config(conf_str) + + s1 = Spec("v").concretized() + assert s1.satisfies("@2.1") + + +def test_oneof_ordering(concretize_scope, test_repo): + """Ensure that earlier elements of 'one_of' have higher priority. + This priority should override default priority (e.g. choosing + later versions). + """ + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + conf_str = """\ +packages: + y: + require: + - one_of: ["@2.4", "@2.5"] +""" + update_packages_config(conf_str) + + s1 = Spec("y").concretized() + assert s1.satisfies("@2.4") + + s2 = Spec("y@2.5").concretized() + assert s2.satisfies("@2.5") + + +def test_reuse_oneof(concretize_scope, create_test_repo, mutable_database, fake_installs): + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + conf_str = """\ +packages: + y: + require: + - one_of: ["@2.5", "%gcc"] +""" + + with spack.repo.use_repositories(create_test_repo): + s1 = Spec("y@2.5%gcc").concretized() + s1.package.do_install(fake=True, explicit=True) + + update_packages_config(conf_str) + + with spack.config.override("concretizer:reuse", True): + s2 = Spec("y").concretized() + assert not s2.satisfies("@2.5 %gcc") + + +def test_requirements_are_higher_priority_than_deprecation(concretize_scope, test_repo): + """Test that users can override a deprecated version with a requirement.""" + if spack.config.get("config:concretizer") == "original": + pytest.skip("Original concretizer does not support configuration" " requirements") + + # @2.3 is a deprecated versions. Ensure that any_of picks both constraints, + # since they are possible + conf_str = """\ +packages: + y: + require: + - any_of: ["@2.3", "%gcc"] +""" + update_packages_config(conf_str) + + s1 = Spec("y").concretized() + assert s1.satisfies("@2.3") + assert s1.satisfies("%gcc") diff --git a/lib/spack/spack/test/conftest.py b/lib/spack/spack/test/conftest.py index 3440351e93..1bf7af5f3b 100644 --- a/lib/spack/spack/test/conftest.py +++ b/lib/spack/spack/test/conftest.py @@ -706,6 +706,20 @@ def mutable_empty_config(tmpdir_factory, configuration_dir): yield cfg +@pytest.fixture(scope="function") +def concretize_scope(mutable_config, tmpdir): + """Adds a scope for concretization preferences""" + tmpdir.ensure_dir("concretize") + mutable_config.push_scope( + spack.config.ConfigScope("concretize", str(tmpdir.join("concretize"))) + ) + + yield + + mutable_config.pop_scope() + spack.repo.path._provider_index = None + + @pytest.fixture def no_compilers_yaml(mutable_config): """Creates a temporary configuration without compilers.yaml""" |