the original intent was to generate output as if each package was a unit test,
but I noticed that I was only generating test output for top-level packages.
Still need to add output formatting (in a commonly parse-able format like Junit
or TAP). May want to adjust how the build log is accessed in case of a build
failure.
1. Database stores a file version, so we can add to it in the future.
2. Database indexed by hashes and not numerical indexes.
3. Specs built by database have consistent hashes and it's checked.
4. minor naming and whitespace changes.
Most importantly wrote the Lock, Read_Lock_Instance, and Write_Lock_Instance classes in lock.py
Updated the locking in database.py
TODO: Lock on larger areas
Replaced them all with references to the database
Implemented caching in the database. The database now only re-reads data
if the database file exists and was changed since this file last wrote to it.
Added the installed_db field to the spack instance
Left the call to all_specs from testdirectory_layout.py for now.
No methods use the database so far.
Also, a bug fix:
Previous version did not remove the staging directory on a failed install
This led to spack refusing to uninstall dependencies of the failed install
Added to cleanup() to blow away the staging directory on failed install.
Certain remote protocols don't support the `--depth` option. Since this can't
be checked by URL type or in any sane way locally, this version attempts to
clone git repositories with the --depth option, and if that fails attempts the
clone again without it.
Ensures all tags are ready before checkout, using `--branch` if possible and
an extra pull if that is not available. Also adds `--depth 1` to create
shallow clones if the git version is sufficient.
Fixes#64.
It is currently less painful to pull the source from github, compile it into a
gem, then install the gem, than it is to download a gem and install it. This
still lacks an activation mechanism, but `spack use tmuxinator` is functional.
- This can result in the user being prompted to download an unsafe
version.
- Avoids overly strict errors when something *could* be satisfiable
but we don't know about hte version.
- The following now work differently:
spec['mpi']
spec['blas']
This can return a spec for openmpi, mpich, mvapich, etc., EVEN if
the spec is already concretized. This means that in a package that
`depends_on('mpi')`, you can do `spec['mpi']` to see what it was
concretized to. This should simplify MPI and BLAS packages.
'mpi' in spec
'blas' in spec
Previously, if the spec had been concretized, these would be `False`
because there was not a dependency in the DAG with either of these
names. These will now be `True` even if the spec has been
concretized. So, e.g., this will print "YES"
s = Spec('callpath ^mpich')
if 'mpi' in spec:
print "YES"
- Similarly, this will be True:
Spec('mpich').satisfies('mpi')
- Because of the way virtual dependencies are currently implemented,
the above required some fiddling around with `package.py` so that it
would never call `Spec.__contains__` (and result in endless
recursion).
- This should be fixed by allowing virutal dependnecies to have their
own package class.
- This would allow a quicker check for vdeps, without a call to
`all_packages`.
- For the time being, `package.py` shouldn't call `__contains__`
- Expanding archvies like MAGMA 1.6.2 creates extra hidden files that
confuse Spack's staging mechanism.
- Added a special case to ignore hidden files when checking whether
the tarball exploded.
- spack install suppresses build output by default.
- use install -v to show build output on the console too
- package.py uses log_output context to redirect output and log it to a file
- filters color codes out of output written to file
- optionally echos to the terminal
- YAML directory layout knows about its build log.
- can get path to install build log to from directory layout
- Package.install now copies the build log to $prefix/.spack/build.out
- Error message from failed install execution now includes build log location
This includes:
- Much better variant support (+debug/-debug)
- Optional dependency support (depends_on(... , when='<condition>')
- New config file format (YAML in ~/.spack)
- New Spec format (YAML in $prefix/.spack/spec.yaml)
- Can depend conditionally based on variant, compiler, arch, deps, etc
- normalize() is not iterative yet: no chaining depends_ons
- really need a SAT solver, but iterative will at least handle
simple cases.
- Added "strict" option to Spec.satisfies()
- strict checks that ALL of other's constraints are met (not just
the ones self shares)
- Consider splitting these out into two methods: could_satisfy() and
satisfies()
- didn't do this yet as it would require changing code that uses
satisfies()
- Changed semantics of __contains__ to use strict satisfaction (SPACK-56)
- Added tests for optional dependencies.
- The constrain() method on Specs, compilers, versions, etc. now
returns whether the spec changed as a result of the call.
- Variant concretization is tricky:
- During concretization, a spec without variants (e.g., mpich) means
"don't care". So, Spec('mpich').satisfies('mpich+debug') is true
because it *could* still be built that way.
- After concretization, a spec without a particular variant means
"don't know", as that wasn't part of the spec, so the opposite
relationship is true. Assume 'spec' is already installed:
spec.satisfies('mpich+debug')
this is false beacuse the `debug` variant didn't exist when spec
was built, so we can't satisfy the explicit request for +debug.
- Variants are now declarable in packages using the variant() directive.
- Variants are checked - you can't just ask for a random variant, it has to be declared.
- conditional logic (@when, if, '+debug' in spec, etc.) still required in package to
implement variant.
Suppress python stack trace on build error UNLESS in debug mode (spack -d).
Now spack shows errors with a single red arrow, and it's easier to find the actual build output.
spack activate
- now activates dependency extensions
- ensures dependencies are activated in the python installation.
- -f/--force option still allows the old activate behavior.
spack deactivate
- checks for dependents before deactivating (like uninstall)
- deactivate -a/--all <extension> will deactviate a package and ALL
of its dependency extensions.
- deactivate -a/--all <extendee> activates all extensions of <extendee>
e.g.: spack deactivate -a python
- deactivate -f/--force option allows removing regardless of dependents.
- deactivate -f can be run EVEN if a package is not activated.
- allows for clenup of activations gone wrong.
- Real bottleneck is calling normalize() for every spec when we read it.
- Need to store graph information in spec files to avoid the need for this.
- Also, normalizing old specs isn't always possible, so we need to do this anyway.
- packages can now extend only one other package.
- do_activate() and do_deactivate() are now called on the extension,
and they automatically find the extendee
- activate() and deactivate() are still called on the extendee and are
passed the extension.
- packages can be "extended" by others
- allows extension to be symlinked into extendee's prefix.
- used for python modules.
- first module: py-setuptools
- packages that provided same spec (e.g. mpe) were overwritten in the index
- Index now has a set of providers instead of a single provider per provided spec.
- see https://github.com/scalability-llnl/spack/issues/11
- Try to accommodate packages that have grown dependencies better.
- This will only get fully fixed when optional dependencies are supported
and some extra functionality is added to the spec syntax.
- spack urls inspects all URLs in packages, prints out colors to show how they are parased.
- URL extrapolation test added.
- Extrapolation is more consistent now.
- Extrapolation handles more complex URLs.
- More test cases for extrapolation.
- Startup is much faster
- Added test for compiler wrapper parsing.
- Removed old compilation module that had to be imported by old cc.
- Removed cc from python version checks now that it's bash.
- too much going on in this command, and it made subcommand parsing weird.
- information printed is the same but info and package-list are really different commands.
- New inclusive version ranges from git-fetching branch enable a fix.
- Can now write :1 to include 1.3, 1.4, etc.
- couldn't do this before so provides() was weird.
- concretize_version() now Use satisfies(), not intersection.
- version class updated with better intersection/union commands
- version now 1.6 "contains" 1.6.5
- added test for new version functionality
- remove none_high and none_low classes
- version module is now self-contained; save for external 2.7
functools.total_ordering for 2.6 compatibility.
- Tests pass with URL fetching and new scheme.
- Lots of refactoring
- Infrastructure is there for arbitrary fetch policies and more attribtues on the version() call.
- Mirrors do not currently work properly, and they get in the way of a proper git fetch
- Added FetchStrategy class to Spack
- Isolated pieces that need to be separate from Stage for git/svn/http
- Added URLFetchStrategy for curl-based fetching.
- Make spack packages RPATH *ALL* dependencies (i.e. the whole tree)
- prevents callpath link from finding wrong libelf -- always uses the one dyninst used.
# By Todd Gamblin (4) and David Beckingsale (2)
# Via Todd Gamblin
* commit 'b601fd08caf21b5fc11e6998a5ebd20a04ac57ad':
Bugfixes for csh environment modules.
Bugfixes, more consolidation of modules code.
Add csh/tcsh support for modules
Consolidate most module code into spack.modules and spack.cmd.module
Fixed up module support
Added inital module support
- One file with all the module classes (spack/modules.py)
- Has an EnvModule superclass that does most of the work and consolidates common code
- Subclasses have specializations for different module systems (TclModule, Dotkit)
- One command (spack module) for all the types of modules to use
- the one command is used by the scripts, only need to maintain in one place
- has some subcommands for different module types, but they're handled mostly generically.
- Consolidate zsh support into a single setup-env.sh script.
- spack find -p works properly (get path from spec, not package)
- directory layout and PackageDB normalize things automatically unless
they're unknown packages (need to do this for spack find -l)
- install test made robust to mock/main package conflicts
- Spec.copy() does not create superfluous nodes and preserves DAG
connections.
- Spec.normalize() doesn't create extra dependency nodes or throw out
old ones like before.
- Added better test cases for above changes.
Minor things:
- Fixed bug waiting to happen in PackageDB.get()
- instances was keyed by name, not by spec, so caching wasn't really
working at all.
- removed unused PackageDB.compute_dependents function.
- Fixed PackageDB.graph_dependencies() so that spack graph works again.
- Spec comparison is now less strict
- compares based on sorted list of dependencies but not
their structure
- Makes comparison easy when a spec is not normalized.
- This makes the dep_hash consistent for specs read in from a
directory layout. - Can now reliably read in a spec for which the
package has gone away, and still be able to delete its install.
- easy switching between git branches
- Fixed latent bug in Spec.flat_dependencies() (was including root)
- added a test for the directory layout so that this code will get
more exercise.
# By Matthew LeGendre (2) and Todd Gamblin (1)
# Via Todd Gamblin
* commit 'd7a3c7e555bfd93fbf93ec55608d7fc6aa8052f8':
Fix up Matt's openss packages.
Add sqlite to spack
Add libmonitor to spack. Still needs svn support for checkout
- Spack needed symlinks in env for fortran compilers.
- 'fc' is a bash bulitin, so can't use it for fortran compiler.
- switched to 'f90' for this.
- mpich 3 builds with fortran now.
- enabled shared libs in mpich package
- New spack.hooks package
- contains modules with pre and post install hooks
- New dotkit hook module
- generates/removes dotkits on install/uninstall
- New spack use, spack unuse commands
- use same syntax as install/uninstall
- New setup-env.bash script
- Sets up path, dotkit support
- new spack dotkit command
- used by script to parse specs, generate
specs of installed pckages for dotkit file names
- TAU doesn't install to directories with '@' in the name.
- Need to fix up its scripts.
- routines to filter files as sed would, but using python regular expressions.
- TAU package uses this.
- Mirrors now appear in ~/.spackconfig, can be edited in that file.
- spack mirror command allows adding, listing, removing mirrors
- Also still creates mirror directories.
- Fast compiler finding in path and for other directories
- first time spack runs, it searches path.
- user can add more compilers with 'spack compiler add'
- Finds intel, gcc, clang, and pgi compilers with custom version args.
- Builds can plug in alternate compilers with ease (e.g. %intel@12.1)
- no more need for compiler python files.
- Default compilers are found in user's environment and added
to ~/.spackconfig automatically
- User can add new compilers by editing configuration file
- Changed how satisfies() is defined for the various version classes
- Can't just use overlaps() with version lists -- need to account for
more and less specific versions.
If the version is more specific than the constriant (e.g., 4.7.3 is more
specific than 4.7), then it should satisfy the constraint, because if
a user asks for 4.7 they likely do not care about the minor version. If they
do, they can specify it. New Version.satisfies() takes this into account.
- spack.spec.Compiler is now spack.spec.CompilerSpec
- Can load a spack.compilers.* module for a particular spec
- e.g. load Gcc module for gcc@4.7 spec.
The number of variables in the string printed for a checksum failure
was not correct. Now a useful error message is printed instead of a
stack trace and a TypeError.
- Previously, URLs like this wouldn't work with spack create:
http://www.hdfgroup.org/ftp/HDF5/current/src/hdf5-1.8.13.tar.bz2
The '5' in hdf5 would interfere with version wildcard substitution beacuse
the wildcard regex would subsume it.
We now take the name of the package OUT of the URL before splitting it up
and adding version wildcards. This prevents names with numbers from breaking
url.wildcard_version.
Also added a package sanity check test that ensures all builtin packages
work with wildcard_version.
# By Todd Gamblin
# Via Todd Gamblin
* commit 'a0c91791c5ac995b80111a92c94d8fb760caa6e3':
SPACK-25: Add package for boost. Works on Linux currently.
Better temp directory selection.
Status messages now show install and stage directories.
Better version wildcard handling, better spidering
- checksum --dirty and create --dirty now changed to --keep-stage
- install --dirty is now --keep-prefix
- uninstall --force now works properly
- commands use keyword args instead of package instance vars
where possible (less weird package state)
- except clause now catches anything, not just exception
- sys.exit() changed to os._exit() to avoid interfering with unit tests
and to avoid raising SystemExit exception when child processes quit.
- Allow version wildcards to match [_-.] instead of the exact separators
the version was constructed with.
- Handles the fact that boost versions are written both 1.55.0 and 1_55_0.
- Update spidering to handle parse errors and warn that Python < 2.7.3 has
less robust HTML parsing abilities.
- this allows each install to have full control over its environment,
and over spack.
- build process can do whatever it wants and doesn't affect main Spack
process.
- Consolidated build environment stuff from package.py into
build_environment.py
- package.py calls build_environment.py functions just before calling
install(), in do_install()
- Organization is better b/c SPACK_xxxx environment variables are now
in build_environment, the only place they're used. Were previously
cluttering globals.py.
The dependency hash wasn't being generated in a consistent way: when
read from .spec file in the install directory, the spec DAG was not
normalized, but when generated on install, it was. Thus the same
spec can have two possible hashes, which is obviously not good.
In this commit:
- Added a dep_hash function to spec, which should be used to get the
dependency hash in all cases. This function normalizes the spec
before generating the hash.
- removed sha1 functions from Spec and DependencyHash. The one on
Spec is not needed and is confusing (it hashed the whole spec, not
just hash the deps) and the one on DependencyHash wasn't guaranteed
to be safe because it can't normalize its parent spec before
hashing.
Hopefully this makes things consistent and easy.
- Packages now live in <package_name>/package.py
- spack.packages refactored to use a PackageDB object instead of
monolithic module.
- Implementation of mock_packages_test.py is greatly simplified
- Added test to exercise install/uninstall code because that wasn't
covered by existing tests and kept breaking.
