# reindexing takes a significant amount of time, and there's

# no reason to do it from DB version 0.9.3 to version 5. The

# only difference is that v5 can contain "deprecated_for"

# fields. So, skip the reindex for this transition. The new

# version is saved to disk the first time the DB is written.

(Version('0.9.3'), Version('5')),

(Version('5'), Version('6'))

'spec',

'ref_count',

'path',

'installed',

'explicit',

'installation_time',

'deprecated_for',

"""Decorator that automatically converts the argument of a single-arg

def converter(self, spec_like, *args, **kwargs):

if not isinstance(spec_like, spack.spec.Spec):

spec_like = spack.spec.Spec(spec_like)

return function(self, spec_like, *args, **kwargs)

INSTALLED = InstallStatus('installed')

DEPRECATED = InstallStatus('deprecated')

MISSING = InstallStatus('missing')

@classmethod

def canonicalize(cls, query_arg):

if query_arg is True:

return [cls.INSTALLED]

elif query_arg is False:

return [cls.MISSING]

elif query_arg is any:

return [cls.INSTALLED, cls.DEPRECATED, cls.MISSING]

elif isinstance(query_arg, InstallStatus):

return [query_arg]

else:

try: # Try block catches if it is not an iterable at all

if any(type(x) != InstallStatus for x in query_arg):

raise TypeError

except TypeError:

raise TypeError(

'installation query must be `any`, boolean, '

'InstallStatus, or iterable of InstallStatus')

"""A record represents one installation in the DB.

def __init__(

self,

spec,

path,

installed,

ref_count=0,

explicit=False,

installation_time=None,

deprecated_for=None,

in_buildcache=False,

):

self.spec = spec

self.path = str(path) if path else None

self.installed = bool(installed)

self.ref_count = ref_count

self.explicit = explicit

self.installation_time = installation_time or _now()

self.deprecated_for = deprecated_for

self.in_buildcache = in_buildcache

def install_type_matches(self, installed):

installed = InstallStatuses.canonicalize(installed)

if self.installed:

return InstallStatuses.INSTALLED in installed

elif self.deprecated_for:

return InstallStatuses.DEPRECATED in installed

else:

return InstallStatuses.MISSING in installed

def to_dict(self, include_fields=default_install_record_fields):

rec_dict = {}

for field_name in include_fields:

if field_name == 'spec':

rec_dict.update({'spec': self.spec.node_dict_with_hashes()})

elif field_name == 'deprecated_for' and self.deprecated_for:

rec_dict.update({'deprecated_for': self.deprecated_for})

else:

rec_dict.update({field_name: getattr(self, field_name)})

return rec_dict

@classmethod

def from_dict(cls, spec, dictionary):

d = dict(dictionary.items())

d.pop('spec', None)

# Old databases may have "None" for path for externals

if 'path' not in d or d['path'] == 'None':

d['path'] = None

if 'installed' not in d:

d['installed'] = False

"""Per-process lock objects for each install prefix."""

_prefix_locks = {} # type: Dict[str, lk.Lock]

"""Per-process failure (lock) objects for each install prefix."""

_prefix_failures = {} # type: Dict[str, lk.Lock]

def __init__(self, root, db_dir=None, upstream_dbs=None,

is_upstream=False, enable_transaction_locking=True,

record_fields=default_install_record_fields):

"""Create a Database for Spack installations under ``root``.

self.root = root

# If the db_dir is not provided, default to within the db root.

self._db_dir = db_dir or os.path.join(self.root, _db_dirname)

# Set up layout of database files within the db dir

self._index_path = os.path.join(self._db_dir, 'index.json')

self._verifier_path = os.path.join(self._db_dir, 'index_verifier')

self._lock_path = os.path.join(self._db_dir, 'lock')

# This is for other classes to use to lock prefix directories.

self.prefix_lock_path = os.path.join(self._db_dir, 'prefix_lock')

# Ensure a persistent location for dealing with parallel installation

# failures (e.g., across near-concurrent processes).

self._failure_dir = os.path.join(self._db_dir, 'failures')

# Support special locks for handling parallel installation failures

# of a spec.

self.prefix_fail_path = os.path.join(self._db_dir, 'prefix_failures')

# Create needed directories and files

if not os.path.exists(self._db_dir):

fs.mkdirp(self._db_dir)

if not os.path.exists(self._failure_dir) and not is_upstream:

fs.mkdirp(self._failure_dir)

self.is_upstream = is_upstream

self.last_seen_verifier = ''

# Failed write transactions (interrupted by exceptions) will alert

# _write. When that happens, we set this flag to indicate that

# future read/write transactions should re-read the DB. Normally it

# would make more sense to resolve this at the end of the transaction

# but typically a failed transaction will terminate the running

# instance of Spack and we don't want to incur an extra read in that

# case, so we defer the cleanup to when we begin the next transaction

self._state_is_inconsistent = False

# initialize rest of state.

self.db_lock_timeout = (

spack.config.get('config:db_lock_timeout') or _db_lock_timeout)

self.package_lock_timeout = (

spack.config.get('config:package_lock_timeout') or

_pkg_lock_timeout)

tty.debug('DATABASE LOCK TIMEOUT: {0}s'.format(

str(self.db_lock_timeout)))

timeout_format_str = ('{0}s'.format(str(self.package_lock_timeout))

if self.package_lock_timeout else 'No timeout')

tty.debug('PACKAGE LOCK TIMEOUT: {0}'.format(

str(timeout_format_str)))

if self.is_upstream:

self.lock = ForbiddenLock()

else:

self.lock = lk.Lock(self._lock_path,

default_timeout=self.db_lock_timeout,

desc='database')

self._data = {}

# For every installed spec we keep track of its install prefix, so that

# we can answer the simple query whether a given path is already taken

# before installing a different spec.

self._installed_prefixes = set()

self.upstream_dbs = list(upstream_dbs) if upstream_dbs else []

# whether there was an error at the start of a read transaction

self._error = None

# For testing: if this is true, an exception is thrown when missing

# dependencies are detected (rather than just printing a warning

# message)

self._fail_when_missing_deps = False

if enable_transaction_locking:

self._write_transaction_impl = lk.WriteTransaction

self._read_transaction_impl = lk.ReadTransaction

else:

self._write_transaction_impl = lang.nullcontext

self._read_transaction_impl = lang.nullcontext

self._record_fields = record_fields

def write_transaction(self):

"""Get a write lock context manager for use in a `with` block."""

return self._write_transaction_impl(

self.lock, acquire=self._read, release=self._write)

def read_transaction(self):

"""Get a read lock context manager for use in a `with` block."""

return self._read_transaction_impl(self.lock, acquire=self._read)

def _failed_spec_path(self, spec):

"""Return the path to the spec's failure file, which may not exist."""

if not spec.concrete:

raise ValueError('Concrete spec required for failure path for {0}'

.format(spec.name))

return os.path.join(self._failure_dir,

'{0}-{1}'.format(spec.name, spec.full_hash()))

def clear_all_failures(self):

"""Force remove install failure tracking files."""

tty.debug('Releasing prefix failure locks')

for pkg_id in list(self._prefix_failures.keys()):

lock = self._prefix_failures.pop(pkg_id, None)

if lock:

lock.release_write()

# Remove all failure markings (aka files)

tty.debug('Removing prefix failure tracking files')

for fail_mark in os.listdir(self._failure_dir):

try:

os.remove(os.path.join(self._failure_dir, fail_mark))

except OSError as exc:

tty.warn('Unable to remove failure marking file {0}: {1}'

.format(fail_mark, str(exc)))

def clear_failure(self, spec, force=False):

"""

failure_locked = self.prefix_failure_locked(spec)

if failure_locked and not force:

tty.msg('Retaining failure marking for {0} due to lock'

.format(spec.name))

return

if failure_locked:

tty.warn('Removing failure marking despite lock for {0}'

.format(spec.name))

lock = self._prefix_failures.pop(spec.prefix, None)

if lock:

lock.release_write()

if self.prefix_failure_marked(spec):

try:

path = self._failed_spec_path(spec)

tty.debug('Removing failure marking for {0}'.format(spec.name))

os.remove(path)

except OSError as err:

tty.warn('Unable to remove failure marking for {0} ({1}): {2}'

.format(spec.name, path, str(err)))

def mark_failed(self, spec):

"""

# Dump the spec to the failure file for (manual) debugging purposes

path = self._failed_spec_path(spec)

with open(path, 'w') as f:

spec.to_json(f)

# Also ensure a failure lock is taken to prevent cleanup removal

# of failure status information during a concurrent parallel build.

err = 'Unable to mark {0.name} as failed.'

prefix = spec.prefix

if prefix not in self._prefix_failures:

mark = lk.Lock(

self.prefix_fail_path,

start=spec.dag_hash_bit_prefix(bit_length(sys.maxsize)),

length=1,

default_timeout=self.package_lock_timeout, desc=spec.name)

try:

mark.acquire_write()

except lk.LockTimeoutError:

# Unlikely that another process failed to install at the same

# time but log it anyway.

tty.debug('PID {0} failed to mark install failure for {1}'

.format(os.getpid(), spec.name))

tty.warn(err.format(spec))

# Whether we or another process marked it as a failure, track it

# as such locally.

self._prefix_failures[prefix] = mark

return self._prefix_failures[prefix]

def prefix_failed(self, spec):

"""Return True if the prefix (installation) is marked as failed."""

# The failure was detected in this process.

if spec.prefix in self._prefix_failures:

return True

# The failure was detected by a concurrent process (e.g., an srun),

# which is expected to be holding a write lock if that is the case.

if self.prefix_failure_locked(spec):

return True

# Determine if the spec may have been marked as failed by a separate

# spack build process running concurrently.

return self.prefix_failure_marked(spec)

def prefix_failure_locked(self, spec):

"""Return True if a process has a failure lock on the spec."""

check = lk.Lock(

self.prefix_fail_path,

start=spec.dag_hash_bit_prefix(bit_length(sys.maxsize)),

length=1,

default_timeout=self.package_lock_timeout, desc=spec.name)

return check.is_write_locked()

def prefix_failure_marked(self, spec):

"""Determine if the spec has a persistent failure marking."""

return os.path.exists(self._failed_spec_path(spec))

def prefix_lock(self, spec, timeout=None):

"""Get a lock on a particular spec's installation directory.

timeout = timeout or self.package_lock_timeout

prefix = spec.prefix

if prefix not in self._prefix_locks:

self._prefix_locks[prefix] = lk.Lock(

self.prefix_lock_path,

start=spec.dag_hash_bit_prefix(bit_length(sys.maxsize)),

length=1,

default_timeout=timeout, desc=spec.name)

elif timeout != self._prefix_locks[prefix].default_timeout:

self._prefix_locks[prefix].default_timeout = timeout

return self._prefix_locks[prefix]

@contextlib.contextmanager

def prefix_read_lock(self, spec):

prefix_lock = self.prefix_lock(spec)

prefix_lock.acquire_read()

try:

yield self

except lk.LockError:

# This addresses the case where a nested lock attempt fails inside

# of this context manager

raise

except (Exception, KeyboardInterrupt):

prefix_lock.release_read()

raise

else:

prefix_lock.release_read()

@contextlib.contextmanager

def prefix_write_lock(self, spec):

prefix_lock = self.prefix_lock(spec)

prefix_lock.acquire_write()

try:

yield self

except lk.LockError:

# This addresses the case where a nested lock attempt fails inside

# of this context manager

raise

except (Exception, KeyboardInterrupt):

prefix_lock.release_write()

raise

else:

prefix_lock.release_write()

def _write_to_file(self, stream):

"""Write out the database in JSON format to the stream passed

# map from per-spec hash code to installation record.

installs = dict((k, v.to_dict(include_fields=self._record_fields))

for k, v in self._data.items())

# database includes installation list and version.

# NOTE: this DB version does not handle multiple installs of

# the same spec well. If there are 2 identical specs with

# different paths, it can't differentiate.

# TODO: fix this before we support multiple install locations.

database = {

'database': {

'installs': installs,

'version': str(_db_version)

}

}

try:

sjson.dump(database, stream)

except (TypeError, ValueError) as e:

raise sjson.SpackJSONError("error writing JSON database:", str(e))

def _read_spec_from_dict(self, hash_key, installs, hash=ht.dag_hash):

"""Recursively construct a spec from a hash in a YAML database.

spec_dict = installs[hash_key]['spec']

# Install records don't include hash with spec, so we add it in here

# to ensure it is read properly.

if 'name' not in spec_dict.keys():

# old format, can't update format here

for name in spec_dict:

spec_dict[name]['hash'] = hash_key

else:

# new format, already a singleton

spec_dict[hash.name] = hash_key

# Build spec from dict first.

spec = spack.spec.Spec.from_node_dict(spec_dict)

return spec

def db_for_spec_hash(self, hash_key):

with self.read_transaction():

if hash_key in self._data:

return self

for db in self.upstream_dbs:

if hash_key in db._data:

return db

def query_by_spec_hash(self, hash_key, data=None):

if data and hash_key in data:

return False, data[hash_key]

if not data:

with self.read_transaction():

if hash_key in self._data:

return False, self._data[hash_key]

for db in self.upstream_dbs:

if hash_key in db._data:

return True, db._data[hash_key]

return False, None

def _assign_dependencies(self, hash_key, installs, data):

# Add dependencies from other records in the install DB to

# form a full spec.

spec = data[hash_key].spec

spec_node_dict = installs[hash_key]['spec']

if 'name' not in spec_node_dict:

# old format

spec_node_dict = spec_node_dict[spec.name]

if 'dependencies' in spec_node_dict:

yaml_deps = spec_node_dict['dependencies']

for dname, dhash, dtypes, _ in spack.spec.Spec.read_yaml_dep_specs(

yaml_deps):

# It is important that we always check upstream installations

# in the same order, and that we always check the local

# installation first: if a downstream Spack installs a package

# then dependents in that installation could be using it.

# If a hash is installed locally and upstream, there isn't

# enough information to determine which one a local package

# depends on, so the convention ensures that this isn't an

# issue.

upstream, record = self.query_by_spec_hash(dhash, data=data)

child = record.spec if record else None

if not child:

msg = ("Missing dependency not in database: "

"%s needs %s-%s" % (

spec.cformat('{name}{/hash:7}'),

dname, dhash[:7]))

if self._fail_when_missing_deps:

raise MissingDependenciesError(msg)

tty.warn(msg)

continue

spec._add_dependency(child, dtypes)

def _read_from_file(self, filename):

"""Fill database from file, do not maintain old data.

try:

with open(filename, 'r') as f:

fdata = sjson.load(f)

except Exception as e:

raise six.raise_from(

CorruptDatabaseError("error parsing database:", str(e)),

e,

)

if fdata is None:

return

def check(cond, msg):

if not cond:

raise CorruptDatabaseError(

"Spack database is corrupt: %s" % msg, self._index_path)

check('database' in fdata, "no 'database' attribute in JSON DB.")

# High-level file checks

db = fdata['database']

check('installs' in db, "no 'installs' in JSON DB.")

check('version' in db, "no 'version' in JSON DB.")

installs = db['installs']

# TODO: better version checking semantics.

version = Version(db['version'])

if version > _db_version:

raise InvalidDatabaseVersionError(_db_version, version)

elif version < _db_version:

if not any(

old == version and new == _db_version

for old, new in _skip_reindex

):

tty.warn(

"Spack database version changed from %s to %s. Upgrading."

% (version, _db_version)

)

self.reindex(spack.store.layout)

installs = dict(

(k, v.to_dict(include_fields=self._record_fields))

for k, v in self._data.items()

)

def invalid_record(hash_key, error):

msg = ("Invalid record in Spack database: "

"hash: %s, cause: %s: %s")

msg %= (hash_key, type(error).__name__, str(error))

raise CorruptDatabaseError(msg, self._index_path)

# Build up the database in three passes:

#

# 1. Read in all specs without dependencies.

# 2. Hook dependencies up among specs.

# 3. Mark all specs concrete.

#

# The database is built up so that ALL specs in it share nodes

# (i.e., its specs are a true Merkle DAG, unlike most specs.)

# Pass 1: Iterate through database and build specs w/o dependencies

data = {}

installed_prefixes = set()

for hash_key, rec in installs.items():

try:

# This constructs a spec DAG from the list of all installs

spec = self._read_spec_from_dict(hash_key, installs)

# Insert the brand new spec in the database. Each

# spec has its own copies of its dependency specs.

# TODO: would a more immmutable spec implementation simplify

# this?

data[hash_key] = InstallRecord.from_dict(spec, rec)

if not spec.external and 'installed' in rec and rec['installed']:

installed_prefixes.add(rec['path'])

except Exception as e:

invalid_record(hash_key, e)

# Pass 2: Assign dependencies once all specs are created.

for hash_key in data:

try:

self._assign_dependencies(hash_key, installs, data)

except MissingDependenciesError:

raise

except Exception as e:

invalid_record(hash_key, e)

# Pass 3: Mark all specs concrete. Specs representing real

# installations must be explicitly marked.

# We do this *after* all dependencies are connected because if we

# do it *while* we're constructing specs,it causes hashes to be

# cached prematurely.

for hash_key, rec in data.items():

rec.spec._mark_root_concrete()

self._data = data

self._installed_prefixes = installed_prefixes

def reindex(self, directory_layout):

"""Build database index from scratch based on a directory layout.

if self.is_upstream:

raise UpstreamDatabaseLockingError(

"Cannot reindex an upstream database")

# Special transaction to avoid recursive reindex calls and to

# ignore errors if we need to rebuild a corrupt database.

def _read_suppress_error():

try:

if os.path.isfile(self._index_path):

self._read_from_file(self._index_path)

except CorruptDatabaseError as e:

self._error = e

self._data = {}

self._installed_prefixes = set()

transaction = lk.WriteTransaction(

self.lock, acquire=_read_suppress_error, release=self._write

)

with transaction:

if self._error:

tty.warn(

"Spack database was corrupt. Will rebuild. Error was:",

str(self._error)

)

self._error = None

old_data = self._data

old_installed_prefixes = self._installed_prefixes

try:

self._construct_from_directory_layout(

directory_layout, old_data)

except BaseException:

# If anything explodes, restore old data, skip write.

self._data = old_data

self._installed_prefixes = old_installed_prefixes

raise

def _construct_entry_from_directory_layout(self, directory_layout,

old_data, spec,

deprecator=None):

# Try to recover explicit value from old DB, but

# default it to True if DB was corrupt. This is

# just to be conservative in case a command like

# "autoremove" is run by the user after a reindex.

tty.debug(

'RECONSTRUCTING FROM SPEC.YAML: {0}'.format(spec))

explicit = True

inst_time = os.stat(spec.prefix).st_ctime

if old_data is not None:

old_info = old_data.get(spec.dag_hash())

if old_info is not None:

explicit = old_info.explicit

inst_time = old_info.installation_time

extra_args = {

'explicit': explicit,

'installation_time': inst_time

}

self._add(spec, directory_layout, **extra_args)

if deprecator:

self._deprecate(spec, deprecator)

def _construct_from_directory_layout(self, directory_layout, old_data):

# Read first the `spec.yaml` files in the prefixes. They should be

# considered authoritative with respect to DB reindexing, as

# entries in the DB may be corrupted in a way that still makes

# them readable. If we considered DB entries authoritative

# instead, we would perpetuate errors over a reindex.

with directory_layout.disable_upstream_check():

# Initialize data in the reconstructed DB

self._data = {}

self._installed_prefixes = set()

# Start inspecting the installed prefixes

processed_specs = set()

for spec in directory_layout.all_specs():

self._construct_entry_from_directory_layout(directory_layout,

old_data, spec)

processed_specs.add(spec)

for spec, deprecator in directory_layout.all_deprecated_specs():

self._construct_entry_from_directory_layout(directory_layout,

old_data, spec,

deprecator)

processed_specs.add(spec)

for key, entry in old_data.items():

# We already took care of this spec using

# `spec.yaml` from its prefix.

if entry.spec in processed_specs:

msg = 'SKIPPING RECONSTRUCTION FROM OLD DB: {0}'

msg += ' [already reconstructed from spec.yaml]'

tty.debug(msg.format(entry.spec))

continue

# If we arrived here it very likely means that

# we have external specs that are not dependencies

# of other specs. This may be the case for externally

# installed compilers or externally installed

# applications.

tty.debug(

'RECONSTRUCTING FROM OLD DB: {0}'.format(entry.spec))

try:

layout = None if entry.spec.external else spack.store.layout

kwargs = {

'spec': entry.spec,

'directory_layout': layout,

'explicit': entry.explicit,

'installation_time': entry.installation_time # noqa: E501

}

self._add(**kwargs)

processed_specs.add(entry.spec)

except Exception as e:

# Something went wrong, so the spec was not restored

# from old data

tty.debug(e)

self._check_ref_counts()

def _check_ref_counts(self):

"""Ensure consistency of reference counts in the DB.

counts = {}

for key, rec in self._data.items():

counts.setdefault(key, 0)

for dep in rec.spec.dependencies(deptype=_tracked_deps):

dep_key = dep.dag_hash()

counts.setdefault(dep_key, 0)

counts[dep_key] += 1

if rec.deprecated_for:

counts.setdefault(rec.deprecated_for, 0)

counts[rec.deprecated_for] += 1

for rec in self._data.values():

key = rec.spec.dag_hash()

expected = counts[key]

found = rec.ref_count

if not expected == found:

raise AssertionError(

"Invalid ref_count: %s: %d (expected %d), in DB %s" %

(key, found, expected, self._index_path))

def _write(self, type, value, traceback):

"""Write the in-memory database index to its file path.