spack.hooks package

Submodules

spack.hooks.extensions module

spack.hooks.extensions.pre_uninstall(spec)

spack.hooks.licensing module

spack.hooks.licensing.post_install(spec)

This hook symlinks local licenses to the global license for licensed software.

spack.hooks.licensing.pre_install(spec)

This hook handles global license setup for licensed software.

spack.hooks.licensing.set_up_license(pkg)

Prompt the user, letting them know that a license is required.

For packages that rely on license files, a global license file is created and opened for editing.

For packages that rely on environment variables to point to a license, a warning message is printed.

For all other packages, documentation on how to set up a license is printed.

spack.hooks.licensing.symlink_license(pkg)

Create local symlinks that point to the global license file.

spack.hooks.licensing.write_license_file(pkg, license_path)

Writes empty license file.

Comments give suggestions on alternative methods of installing a license.

spack.hooks.module_file_generation module

spack.hooks.module_file_generation.post_env_write(env)

spack.hooks.module_file_generation.post_install(spec)

spack.hooks.module_file_generation.post_uninstall(spec)

spack.hooks.monitor module

spack.hooks.monitor.on_analyzer_save(pkg, result)

given a package and a result, if we have a spack monitor, upload the result to it.

spack.hooks.monitor.on_install_failure(spec)

Triggered on failure of an install

spack.hooks.monitor.on_install_start(spec)

On start of an install, we want to ping the server if it exists

spack.hooks.monitor.on_install_success(spec)

On the success of an install (after everything is complete)

spack.hooks.monitor.on_phase_error(pkg, phase_name, log_file)

Triggered on a phase error

spack.hooks.monitor.on_phase_success(pkg, phase_name, log_file)

Triggered on a phase success

spack.hooks.permissions_setters module

spack.hooks.permissions_setters.post_install(spec)

spack.hooks.sbang module

exception spack.hooks.sbang.SbangPathError(message, long_message=None)

Bases: spack.error.SpackError

Raised when the install tree root is too long for sbang to work.

spack.hooks.sbang.filter_shebang(path)

Adds a second shebang line, using sbang, at the beginning of a file, if necessary. Note: Spack imposes a relaxed shebang line limit, meaning that a newline or end of file must occur before spack_shebang_limit bytes. If not, the file is not patched.

spack.hooks.sbang.filter_shebangs_in_directory(directory, filenames=None)

spack.hooks.sbang.get_interpreter(binary_string)

spack.hooks.sbang.install_sbang()

Ensure that sbang is installed in the root of Spack’s install_tree.

This is the shortest known publicly accessible path, and installing sbang here ensures that users can access the script and that sbang itself is in a short path.

spack.hooks.sbang.post_install(spec)

This hook edits scripts so that they call /bin/bash $spack_prefix/bin/sbang instead of something longer than the shebang limit.

spack.hooks.sbang.sbang_install_path()

Location sbang should be installed within Spack’s install_tree.

spack.hooks.sbang.sbang_shebang_line()

Full shebang line that should be prepended to files to use sbang.

The line returned does not have a final newline (caller should add it if needed).

This should be the only place in Spack that knows about what interpreter we use for sbang.

spack.hooks.sbang.spack_shebang_limit = 4096

Spack itself also limits the shebang line to at most 4KB, which should be plenty.

spack.hooks.write_install_manifest module

spack.hooks.write_install_manifest.post_install(spec)

Module contents

This package contains modules with hooks for various stages in the Spack install process. You can add modules here and they’ll be executed by package at various times during the package lifecycle.

Each hook is just a function that takes a package as a parameter. Hooks are not executed in any particular order.

Currently the following hooks are supported:

• pre_install(spec)

• post_install(spec)

• pre_uninstall(spec)

• post_uninstall(spec)

• on_install_start(spec)

• on_install_success(spec)

• on_install_failure(spec)

• on_phase_success(pkg, phase_name, log_file)

• on_phase_error(pkg, phase_name, log_file)

• on_phase_error(pkg, phase_name, log_file)

• on_analyzer_save(pkg, result)

• post_env_write(env)

This can be used to implement support for things like module systems (e.g. modules, lmod, etc.) or to add other custom features.