1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
# Copyright 2013-2021 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)
"""Components that manage Spack's installation tree.
An install tree, or "build store" consists of two parts:
1. A package database that tracks what is installed.
2. A directory layout that determines how the installations
are laid out.
The store contains all the install prefixes for packages installed by
Spack. The simplest store could just contain prefixes named by DAG hash,
but we use a fancier directory layout to make browsing the store and
debugging easier.
The directory layout is currently hard-coded to be a YAMLDirectoryLayout,
so called because it stores build metadata within each prefix, in
`spec.yaml` files. In future versions of Spack we may consider allowing
install trees to define their own layouts with some per-tree
configuration.
"""
import os
import re
import six
import llnl.util.lang
import llnl.util.tty as tty
import spack.paths
import spack.config
import spack.util.path
import spack.database
import spack.directory_layout
#: default installation root, relative to the Spack install path
default_install_tree_root = os.path.join(spack.paths.opt_path, 'spack')
def parse_install_tree(config_dict):
"""Parse config settings and return values relevant to the store object.
Arguments:
config_dict (dict): dictionary of config values, as returned from
spack.config.get('config')
Returns:
(tuple): triple of the install tree root, the unpadded install tree
root (before padding was applied), and the projections for the
install tree
Encapsulate backwards compatibility capabilities for install_tree
and deprecated values that are now parsed as part of install_tree.
"""
# The following two configs are equivalent, the first being the old format
# and the second the new format. The new format is also more flexible.
# config:
# install_tree: /path/to/root$padding:128
# install_path_scheme: '{name}-{version}'
# config:
# install_tree:
# root: /path/to/root
# padding: 128
# projections:
# all: '{name}-{version}'
install_tree = config_dict.get('install_tree', {})
padded_length = False
if isinstance(install_tree, six.string_types):
tty.warn("Using deprecated format for configuring install_tree")
unpadded_root = install_tree
unpadded_root = spack.util.path.canonicalize_path(unpadded_root)
# construct projection from previous values for backwards compatibility
all_projection = config_dict.get(
'install_path_scheme',
spack.directory_layout.default_projections['all'])
projections = {'all': all_projection}
else:
unpadded_root = install_tree.get('root', default_install_tree_root)
unpadded_root = spack.util.path.canonicalize_path(unpadded_root)
padded_length = install_tree.get('padded_length', False)
if padded_length is True:
padded_length = spack.util.path.get_system_path_max()
padded_length -= spack.util.path.SPACK_MAX_INSTALL_PATH_LENGTH
projections = install_tree.get(
'projections', spack.directory_layout.default_projections)
path_scheme = config_dict.get('install_path_scheme', None)
if path_scheme:
tty.warn("Deprecated config value 'install_path_scheme' ignored"
" when using new install_tree syntax")
# Handle backwards compatibility for padding
old_pad = re.search(r'\$padding(:\d+)?|\${padding(:\d+)?}', unpadded_root)
if old_pad:
if padded_length:
msg = "Ignoring deprecated padding option in install_tree root "
msg += "because new syntax padding is present."
tty.warn(msg)
else:
unpadded_root = unpadded_root.replace(old_pad.group(0), '')
if old_pad.group(1) or old_pad.group(2):
length_group = 2 if '{' in old_pad.group(0) else 1
padded_length = int(old_pad.group(length_group)[1:])
else:
padded_length = spack.util.path.get_system_path_max()
padded_length -= spack.util.path.SPACK_MAX_INSTALL_PATH_LENGTH
unpadded_root = unpadded_root.rstrip(os.path.sep)
if padded_length:
root = spack.util.path.add_padding(unpadded_root, padded_length)
if len(root) != padded_length:
msg = "Cannot pad %s to %s characters." % (root, padded_length)
msg += " It is already %s characters long" % len(root)
tty.warn(msg)
else:
root = unpadded_root
return (root, unpadded_root, projections)
class Store(object):
"""A store is a path full of installed Spack packages.
Stores consist of packages installed according to a
``DirectoryLayout``, along with an index, or _database_ of their
contents. The directory layout controls what paths look like and how
Spack ensures that each uniqe spec gets its own unique directory (or
not, though we don't recommend that). The database is a signle file
that caches metadata for the entire Spack installation. It prevents
us from having to spider the install tree to figure out what's there.
Args:
root (str): path to the root of the install tree
unpadded_root (str): path to the root of the install tree without
padding; the sbang script has to be installed here to work with
padded roots
path_scheme (str): expression according to guidelines in
``spack.util.path`` that describes how to construct a path to
a package prefix in this store
hash_length (int): length of the hashes used in the directory
layout; spec hash suffixes will be truncated to this length
"""
def __init__(
self, root, unpadded_root=None, projections=None, hash_length=None
):
self.root = root
self.unpadded_root = unpadded_root or root
self.db = spack.database.Database(
root, upstream_dbs=retrieve_upstream_dbs())
self.layout = spack.directory_layout.YamlDirectoryLayout(
root, projections=projections, hash_length=hash_length)
def reindex(self):
"""Convenience function to reindex the store DB with its own layout."""
return self.db.reindex(self.layout)
def _store():
"""Get the singleton store instance."""
config_dict = spack.config.get('config')
root, unpadded_root, projections = parse_install_tree(config_dict)
hash_length = spack.config.get('config:install_hash_length')
return Store(root=root,
unpadded_root=unpadded_root,
projections=projections,
hash_length=hash_length)
#: Singleton store instance
store = llnl.util.lang.Singleton(_store)
def _store_root():
return store.root
def _store_unpadded_root():
return store.unpadded_root
def _store_db():
return store.db
def _store_layout():
return store.layout
# convenience accessors for parts of the singleton store
root = llnl.util.lang.LazyReference(_store_root)
unpadded_root = llnl.util.lang.LazyReference(_store_unpadded_root)
db = llnl.util.lang.LazyReference(_store_db)
layout = llnl.util.lang.LazyReference(_store_layout)
def retrieve_upstream_dbs():
other_spack_instances = spack.config.get('upstreams', {})
install_roots = []
for install_properties in other_spack_instances.values():
install_roots.append(install_properties['install_tree'])
return _construct_upstream_dbs_from_install_roots(install_roots)
def _construct_upstream_dbs_from_install_roots(
install_roots, _test=False):
accumulated_upstream_dbs = []
for install_root in reversed(install_roots):
upstream_dbs = list(accumulated_upstream_dbs)
next_db = spack.database.Database(
install_root, is_upstream=True, upstream_dbs=upstream_dbs)
next_db._fail_when_missing_deps = _test
next_db._read()
accumulated_upstream_dbs.insert(0, next_db)
return accumulated_upstream_dbs
|
