sync with upstream

Author: grodzki-lanl

docs/recipes.md

@@ -15,6 +15,7 @@ A recipe is comprised of the following yaml files in a directory:
 * `post-install`: _optional_ a script to run after Spack has been executed to build the stack.
 * `pre-install`: _optional_ a script to run before any packages have been built.
 
+[](){#ref-recipes-config}
 ## Configuration
 
 ```yaml title="config.yaml"
@@ -26,17 +27,18 @@ spack:
     packages:
         repo: https://github.com/spack/spack-packages.git
         commit: develop
-modules: true
 description: "HPC development tools for building MPI applications with the GNU compiler toolchain"
+default-view: develop
 version: 2
 ```
 
 * `name`: a plain text name for the environment
 * `store`: the location where the environment will be mounted.
 * `spack`: which spack and package repositories to use for installation.
-* `modules`: (_deprecated_) _optional_ enable/disable module file generation.
 * `description`: _optional_ a string that describes the environment (default empty).
+* `default-view`: _default = null_ the name of a uenv view to load if no view is explicitly requested by the user. See the documentation for [default views][ref-recipes-default-view]. If no default view is specified, none will be set.
 * `version`:  _default = 1_ the version of the uenv recipe (see below)
+* `modules`: (_deprecated_) _optional_ enable/disable module file generation.
 
 !!! note "uenv recipe versions"
     Stackinator 6 introduces breaking changes to the uenv recipe format, introduced to support Spack v1.0.
@@ -350,27 +352,34 @@ For example, the `views` description:
 ```yaml
 cuda-env:
   views:
-    default:
+    full:
     no-python:
       exclude:
         - 'python'
 ```
 
 will configure two views:
 
-* `default`: a view of all the software in the environment using the default settings of Spack.
-* `no-python`: everything in the default view, except any versions of `python`.
+* `full`: a view of all the software in the environment using the full settings of Spack.
+* `no-python`: everything in the `full` view, except any versions of `python`.
+
+!!! warning "only name views default if they are loaded by default"
+    It is possible to name views `default`, and there are uenv images like `prgenv-gnu` that follow this practice for legacy reasons.
+
+    However the name default can be confusing for users because it implies that the view is loaded by default.
+    However, [default views][ref-recipes-default-view] must be explicitly set in [`config.yaml`][ref-recipes-config].
 
 Stackinator provides some additional options that are not provided by Spack, to fine tune the view, that can be set in the `uenv:` field:
 
 ```yaml
 cuda-env:
   views:
-    uenv:
-      add_compilers: true
-      prefix_paths:
-        LD_LIBRARY_PATH: [lib, lib64]
-      env_vars:
+    my-view:
+      uenv:
+        add_compilers: true
+        prefix_paths:
+          LD_LIBRARY_PATH: [lib, lib64]
+        env_vars:
           set:
           - WOMBAT: null
           - NOCOLOR: "1"
@@ -392,6 +401,18 @@ cuda-env:
 !!! info
     See the [interfaces documentation](interfaces.md#environment-views) for more information about how the environment views are provided.
 
+[](){#ref-recipes-default-view}
+#### Setting default views
+
+!!! info "available in uenv 9.3 and later"
+    Default views are only loaded in recent versions of uenv.
+    Older uenv versions will ignore the default view - it is not an error to load a uenv that provides a default view using uenv 9.2 and older.
+
+It is possible to specify a view that will be loaded automatically if no view is specified, by setting the `default-view` field in [`config.yaml` file][ref-recipes-config].
+
+* a default view is only used if it is explicitly specified in `config.yaml`.
+* if a uenv is started with a view specified, the default view is ignored.
+
 #### Setting environment variables with `env_vars`
 
 The `views:<view_name>:uenv:env_vars` field can be used to further fine-tune the environment variables that are set when the view is started.
@@ -545,7 +566,7 @@ The post-install script is templated using Jinja, with the following variables a
 The use of Jinja templates is demonstrated in the following example of a bash script that generates an activation script that adds the installation path of GROMACS to the system PATH:
 
 ```bash title="post-install script that generates a simple activation script."
-#!/bin/bash
+#!/usr/bin/env bash
 
 gmx_path=$(spack -C {{ env.config }} location -i gromacs)/bin
 echo "export PATH=$gmx_path:$PATH" >> {{ env.mount }}/activate.sh

stackinator/builder.py

@@ -156,6 +156,7 @@ def environment_meta(self, recipe):
         meta["name"] = conf["name"]
         meta["description"] = conf["description"]
         meta["views"] = recipe.environment_view_meta
+        meta["default-view"] = recipe.default_view
         meta["mount"] = str(recipe.mount)
         modules = None
         if recipe.with_modules:

stackinator/etc/Make.inc

@@ -29,4 +29,4 @@ store:
 	touch $@
 
 # Because Spack doesn't know how to find compilers, we help it by getting the bin folder of gcc, clang, nvc given a install prefix
-compiler_bin_dirs = $$(find $(1) '(' -name gcc -o -name clang -o -name nvc ')' -path '*/bin/*' '(' -type f -o -type l ')' -exec dirname {} +)
+compiler_bin_dirs = $$(find $(1) '(' -name gcc -o -name clang -o -name nvc -o -name icx ')' -path '*/bin/*' '(' -type f -o -type l ')' -exec dirname {} +)

stackinator/etc/bwrap-mutable-root.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 args=()
 shopt -s dotglob
 for d in /*; do

stackinator/etc/envvars.py

@@ -1,8 +1,9 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 
 import argparse
 import json
 import os
+import re
 from enum import Enum
 from typing import List, Optional
 
@@ -206,6 +207,11 @@ def is_list_var(name: str) -> bool:
     return name in list_variables
 
 
+class VarExpansionError(Exception):
+    def __init__(self, variable_name) -> None:
+        super().__init__(f'"{variable_name}" variable cannot be expanded')
+
+
 class EnvVarSet:
     """
     A set of environment variable updates.
@@ -219,6 +225,57 @@ def __init__(self):
         # toggles whether post export commands will be generated
         self._generate_post = True
 
+    @classmethod
+    def from_envvars(cls, input: dict, substitutions: dict):
+        def expand_vars(s):
+            def var_expansion(m: re.Match):
+                try:
+                    return substitutions[m.group(1)]
+                except KeyError:
+                    raise VarExpansionError(m.group(0))
+
+            return re.sub(r"\$@(\w+)@", var_expansion, s)
+
+        # TODO: one day this code will be revisited because we need to append_path
+        # or prepend_path to a variable that isn't in envvars.is_list_var
+        # On that day, extend the environments.yaml views:uenv:env_vars field
+        # to also accept a list of env var names to add to the blessed list of prefix paths
+
+        env = EnvVarSet()
+
+        for v in input.get("set", []):
+            ((name, value),) = v.items()
+            if value is not None:
+                value = expand_vars(value)
+
+            # insist that the only 'set' operation on prefix variables is to unset/reset them
+            # this requires that users use append and prepend to build up the variables
+            if is_list_var(name) and value is not None:
+                raise RuntimeError(f"{name} is a prefix variable")
+            else:
+                if is_list_var(name):
+                    env.set_list(name, [], EnvVarOp.SET)
+                else:
+                    env.set_scalar(name, value)
+
+        for v in input.get("prepend_path", []):
+            ((name, value),) = v.items()
+            if value is not None:
+                value = expand_vars(value)
+            if not is_list_var(name):
+                raise RuntimeError(f"{name} is not a known prefix path variable")
+            env.set_list(name, [value], EnvVarOp.PREPEND)
+
+        for v in input.get("append_path", []):
+            ((name, value),) = v.items()
+            if value is not None:
+                value = expand_vars(value)
+            if not is_list_var(name):
+                raise RuntimeError(f"{name} is not a known prefix path variable")
+            env.set_list(name, [value], EnvVarOp.APPEND)
+
+        return env
+
     @property
     def lists(self):
         return self._lists
@@ -541,7 +598,7 @@ def meta_impl(args):
         for var_name, value in recipe_vars["scalar"].items():
             spack_vars["values"]["scalar"][var_name] = value
         for var_name, updates in recipe_vars["list"].items():
-            spack_vars["values"]["list"].setdefault(name, [])
+            spack_vars["values"]["list"].setdefault(var_name, [])
             spack_vars["values"]["list"][var_name] += updates
 
         # update the global meta data to include the environment variable state

stackinator/recipe.py

@@ -5,8 +5,8 @@
 import jinja2
 import yaml
 
-from . import root_logger, schema, spack_util, mirror
-from .etc import envvars
+from . import cache, root_logger, schema, spack_util, mirror
+from .etc.envvars import EnvVarSet
 
 
 class Recipe:
@@ -87,14 +87,6 @@ def __init__(self, args):
                 self._logger.error(f"modules.yaml:{self.with_modules}")
                 raise RuntimeError("conflicting modules configuration detected")
 
-        # optional packages.yaml file
-        packages_path = self.path / "packages.yaml"
-        self._logger.debug(f"opening {packages_path}")
-        self.packages = None
-        if packages_path.is_file():
-            with packages_path.open() as fid:
-                self.packages = yaml.load(fid, Loader=yaml.Loader)
-
         self._logger.debug("creating packages")
 
         # load recipe/packages.yaml -> recipe_packages (if it exists)
@@ -169,8 +161,23 @@ def __init__(self, args):
             schema.EnvironmentsValidator.validate(raw)
             self.generate_environment_specs(raw)
 
+        # check that the default view exists (if one has been set)
+        self._default_view = self.config["default-view"]
+        if self._default_view is not None:
+            available_views = [view["name"] for env in self.environments.values() for view in env["views"]]
+            # add the modules and spack views to the list of available views
+            if self.with_modules:
+                available_views.append("modules")
+            available_views.append("spack")
+            if self._default_view not in available_views:
+                self._logger.error(
+                    f"The default-view {self._default_view} is not the name of a view in the environments.yaml "
+                    "definition (one of {[name for name in available_views]}"
+                )
+                raise RuntimeError("Ivalid default-view in the recipe.")
+
         # load the optional mirrors.yaml from system config, and add any additional
-        # mirrors specified on the command line.
+        # mirrors specified on the command line. 
         self._logger.debug("Configuring mirrors.")
         self.mirrors = mirror.Mirrors(self.system_config_path, pathlib.Path(args.cache) if args.cache else None)
 
@@ -262,66 +269,28 @@ def with_modules(self) -> bool:
     def find_spack_version(self, develop):
         return "1.0"
 
+    @property
+    def default_view(self):
+        return self._default_view
+
     @property
     def environment_view_meta(self):
         # generate the view meta data that is presented in the squashfs image meta data
         view_meta = {}
         for _, env in self.environments.items():
             for view in env["views"]:
-                # recipe authors can substitute the name of the view, the mount
-                # and view path into environment variables using '$@key@' where
-                # key is one of view_name, mount and view_path.
-                substitutions = {
-                    "view_name": str(view["name"]),
-                    "mount": str(self.mount),
-                    "view_path": str(view["config"]["root"]),
-                }
-
-                def fill(s):
-                    return re.sub(
-                        r"\$@(\w+)@",
-                        lambda m: substitutions.get(m.group(1), m.group(0)),
-                        s,
-                    )
-
-                ev_inputs = view["extra"]["env_vars"]
-                env = envvars.EnvVarSet()
-
-                # TODO: one day this code will be revisited because we need to append_path
-                # or prepend_path to a variable that isn't in envvars.is_list_var
-                # On that day, extend the environments.yaml views:uenv:env_vars field
-                # to also accept a list of env var names to add to the blessed list of prefix paths
-
-                for v in ev_inputs["set"]:
-                    ((name, value),) = v.items()
-                    if value is not None:
-                        value = fill(value)
-
-                    # insist that the only 'set' operation on prefix variables is to unset/reset them
-                    # this requires that users use append and prepend to build up the variables
-                    if envvars.is_list_var(name) and value is not None:
-                        raise RuntimeError(f"{name} in the {view['name']} view is a prefix variable.")
-                    else:
-                        if envvars.is_list_var(name):
-                            env.set_list(name, [], envvars.EnvVarOp.SET)
-                        else:
-                            env.set_scalar(name, value)
-                for v in ev_inputs["prepend_path"]:
-                    ((name, value),) = v.items()
-                    if value is not None:
-                        value = fill(value)
-                    if not envvars.is_list_var(name):
-                        raise RuntimeError(f"{name} in the {view['name']} view is not a known prefix path variable")
-
-                    env.set_list(name, [value], envvars.EnvVarOp.APPEND)
-                for v in ev_inputs["append_path"]:
-                    ((name, value),) = v.items()
-                    if value is not None:
-                        value = fill(value)
-                    if not envvars.is_list_var(name):
-                        raise RuntimeError(f"{name} in the {view['name']} view is not a known prefix path variable")
-
-                    env.set_list(name, [value], envvars.EnvVarOp.PREPEND)
+                try:
+                    # recipe authors can substitute the name of the view, the mount
+                    # and view path into environment variables using '$@key@' where
+                    # key is one of view_name, mount and view_path.
+                    substitutions = {
+                        "view_name": str(view["name"]),
+                        "mount": str(self.mount),
+                        "view_path": str(view["config"]["root"]),
+                    }
+                    env = EnvVarSet.from_envvars(view["extra"]["env_vars"], substitutions)
+                except Exception as err:
+                    raise RuntimeError(f'In view "{view["name"]}": {err}')
 
                 view_meta[view["name"]] = {
                     "root": view["config"]["root"],
@@ -398,6 +367,10 @@ def generate_environment_specs(self, raw):
             # Which will compile the upstream MPI with nvfortran, as well as downstream dependendencies.
             if config["prefer"] is None:
                 compiler = config["compiler"][0]
+                # spack uses a different name for the intel oneapi compilers
+                # than the package that installs them.
+                if compiler == "intel-oneapi-compilers":
+                    compiler = "oneapi"
                 config["prefer"] = [
                     f"%[when=%c] c={compiler} %[when=%cxx] cxx={compiler} %[when=%fortran] fortran={compiler}"
                 ]
@@ -484,6 +457,15 @@ def generate_compiler_specs(self, raw):
             llvm_amdgpu["exclude_from_cache"] = cache_exclude
             compilers["llvm-amdgpu"] = llvm_amdgpu
 
+        if raw["intel-oneapi-compilers"] is not None:
+            oneapi = {}
+            oneapi_version = raw["intel-oneapi-compilers"]["version"]
+            oneapi["packages"] = False
+            oneapi["specs"] = [f"intel-oneapi-compilers@{oneapi_version}"]
+
+            oneapi["exclude_from_cache"] = cache_exclude
+            compilers["intel-oneapi-compilers"] = oneapi
+
         self.compilers = compilers
 
     # The path of the default configuration for the target system/cluster

stackinator/schema/compilers.json

@@ -60,6 +60,22 @@
                 }
             ],
             "default": null
+        },
+        "intel-oneapi-compilers": {
+            "oneOf": [
+                {
+                    "type": "object",
+                    "properties": {
+                        "version": {"type": "string"}
+                    },
+                    "additionalProperties": false,
+                    "required": ["version"]
+                },
+                {
+                    "type": "null"
+                }
+            ],
+            "default": null
         }
     }
 }