Optional: Bootstrapping clingo

Spack supports using clingo as an external solver to compute which software

needs to be installed. If you have a default compiler supporting C++14 Spack

can automatically bootstrap this tool from sources the first time it is

needed:

.. code-block:: console

If you want to speed-up bootstrapping, you may try to search for ``cmake`` and ``bison``

on your system:

.. code-block:: console

All the tools Spack needs for its own functioning are installed in a separate store, which lives

under the ``${HOME}/.spack`` directory. The software installed there can be queried with:

.. code-block:: console

In case it's needed the bootstrap store can also be cleaned with:

.. code-block:: console

import contextlib

import os

import sys

import llnl.util.filesystem as fs

import llnl.util.tty as tty

import spack.architecture

import spack.config

import spack.paths

import spack.repo

import spack.spec

import spack.store

import spack.user_environment as uenv

import spack.util.executable

from spack.util.environment import EnvironmentModifications

def spack_python_interpreter():

"""Override the current configuration to set the interpreter under

python_cls = type(spack.spec.Spec('python').package)

python_prefix = os.path.dirname(os.path.dirname(sys.executable))

externals = python_cls.determine_spec_details(

python_prefix, [os.path.basename(sys.executable)])

external_python = externals[0]

entry = {

'buildable': False,

'externals': [

{'prefix': python_prefix, 'spec': str(external_python)}

]

}

with spack.config.override('packages:python::', entry):

yield

def make_module_available(module, spec=None, install=False):

"""Ensure module is importable"""

# If we already can import it, that's great

try:

__import__(module)

return

except ImportError:

pass

# If it's already installed, use it

# Search by spec

spec = spack.spec.Spec(spec or module)

# We have to run as part of this python

# We can constrain by a shortened version in place of a version range

# because this spec is only used for querying or as a placeholder to be

# replaced by an external that already has a concrete version. This syntax

# is not suffucient when concretizing without an external, as it will

# concretize to python@X.Y instead of python@X.Y.Z

spec.constrain('^python@%d.%d' % sys.version_info[:2])

installed_specs = spack.store.db.query(spec, installed=True)

for ispec in installed_specs:

# TODO: make sure run-environment is appropriate

module_path = os.path.join(ispec.prefix,

ispec['python'].package.site_packages_dir)

module_path_64 = module_path.replace('/lib/', '/lib64/')

try:

sys.path.append(module_path)

sys.path.append(module_path_64)

__import__(module)

return

except ImportError:

tty.warn("Spec %s did not provide module %s" % (ispec, module))

sys.path = sys.path[:-2]

def _raise_error(module_name, module_spec):

error_msg = 'cannot import module "{0}"'.format(module_name)

if module_spec:

error_msg += ' from spec "{0}'.format(module_spec)

raise ImportError(error_msg)

if not install:

_raise_error(module, spec)

with spack_python_interpreter():

# We will install for ourselves, using this python if needed

# Concretize the spec

spec.concretize()

spec.package.do_install()

module_path = os.path.join(spec.prefix,

spec['python'].package.site_packages_dir)

module_path_64 = module_path.replace('/lib/', '/lib64/')

try:

sys.path.append(module_path)

sys.path.append(module_path_64)

__import__(module)

return

except ImportError:

sys.path = sys.path[:-2]

_raise_error(module, spec)

def get_executable(exe, spec=None, install=False):

"""Find an executable named exe, either in PATH or in Spack

# Search the system first

runner = spack.util.executable.which(exe)

if runner:

return runner

# Check whether it's already installed

spec = spack.spec.Spec(spec or exe)

installed_specs = spack.store.db.query(spec, installed=True)

for ispec in installed_specs:

# filter out directories of the same name as the executable

exe_path = [exe_p for exe_p in fs.find(ispec.prefix, exe)

if fs.is_exe(exe_p)]

if exe_path:

ret = spack.util.executable.Executable(exe_path[0])

envmod = EnvironmentModifications()

for dep in ispec.traverse(root=True, order='post'):

envmod.extend(uenv.environment_modifications_for_spec(dep))

ret.add_default_envmod(envmod)

return ret

else:

tty.warn('Exe %s not found in prefix %s' % (exe, ispec.prefix))

def _raise_error(executable, exe_spec):

error_msg = 'cannot find the executable "{0}"'.format(executable)

if exe_spec:

error_msg += ' from spec "{0}'.format(exe_spec)

raise RuntimeError(error_msg)

# If we're not allowed to install this for ourselves, we can't find it

if not install:

_raise_error(exe, spec)

with spack_python_interpreter():

# We will install for ourselves, using this python if needed

# Concretize the spec

spec.concretize()

spec.package.do_install()

# filter out directories of the same name as the executable

exe_path = [exe_p for exe_p in fs.find(spec.prefix, exe)

if fs.is_exe(exe_p)]

if exe_path:

ret = spack.util.executable.Executable(exe_path[0])

envmod = EnvironmentModifications()

for dep in spec.traverse(root=True, order='post'):

envmod.extend(uenv.environment_modifications_for_spec(dep))

ret.add_default_envmod(envmod)

return ret

_raise_error(exe, spec)

def ensure_bootstrap_configuration():

# Default configuration scopes excluding command

# line and builtin

config_scopes = [

spack.config.ConfigScope(name, path)

for name, path in spack.config.configuration_paths

]

with spack.architecture.use_platform(spack.architecture.real_platform()):

with spack.config.use_configuration(*config_scopes):

with spack.repo.use_repositories(spack.paths.packages_path):

with spack.store.use_store(spack.paths.user_bootstrap_store):

with spack_python_interpreter():

yield

args += ['--single-version-externally-managed']

# Get all relative paths since we set the root to `prefix`

# We query the python with which these will be used for the lib and inc

# directories. This ensures we use `lib`/`lib64` as expected by python.

python = spec['python'].package.command

command_start = 'print(distutils.sysconfig.'

commands = ';'.join([

'import distutils.sysconfig',

command_start + 'get_python_lib(plat_specific=False, prefix=""))',

command_start + 'get_python_lib(plat_specific=True, prefix=""))',

command_start + 'get_python_inc(plat_specific=True, prefix=""))'])

pure_site_packages_dir, plat_site_packages_dir, inc_dir = python(

'-c', commands, output=str, error=str).strip().split('\n')

args += ['--root=%s' % prefix,

'--install-purelib=%s' % pure_site_packages_dir,

'--install-platlib=%s' % plat_site_packages_dir,

'--install-scripts=bin',

'--install-data=""',

'--install-headers=%s' % inc_dir

]

import spack.config

import spack.main

parser.parse_args(['-sdfmpb'], namespace=namespace)

'-b', '--bootstrap', action='store_true',

help="remove software needed to bootstrap Spack")

subparser.add_argument(

'-a', '--all', action=AllClean, help="equivalent to -sdfmpb", nargs=0

args.misc_cache, args.python_cache, args.bootstrap]):

if args.bootstrap:

msg = 'Removing software in "{0}"'

tty.msg(msg.format(spack.paths.user_bootstrap_store))

with spack.store.use_store(spack.paths.user_bootstrap_store):

uninstall = spack.main.SpackCommand('uninstall')

uninstall('-a', '-y')