hlrs-software-stack/spack
7
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove view print for now.

Browse source
This commit is contained in:
Brett Viren 2016-05-19 08:35:54 -06:00
parent 1bbe6409e1
commit 126fc10b9d
2 changed files with 3 additions and 187 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
lib/spack/docs/basic_usage.rst
View file

@ -330,124 +330,6 @@ of libelf would look like this:
The full spec syntax is discussed in detail in :ref:`sec-specs`.
``spack view print``
~~~~~~~~~~~~~~~~~~~~~~
``spack view print`` is a subcommand of ``spack view`` which displays information about one or more installed packages and their dependencies using a user-provided format string. The string can reverence variables in a shell-like manner for example ``$variable`` or ``${variable}text``. It can also include ``\t`` for tabs and ``\n`` for new lines.
Some of the supported variables are:
``name``
The package name.
``version``
The package version.
``spec``
The package specification.
``root``
The root specification.
``prefix``
The installation directory.
``variants``
The collection of variants, if any.
``namespace``
The package repository name space.
``compiler``
The compiler \`name@versoin\` used to build the package.
``architecture``
The architecture targeted by the compiler.
``dependencies``
A comma-separated list of names of packages on which the package depends.
``dependents``
A comma-separated list of names of packages which depend on the package.
``hash``
The Spack hash for the package.
``url``
The source URL for the package.
``stage``
The directory for staging the build.
``build_log``
The path to the build log file.
``rpath``
The colon-separated library \`RPATH\` used in building the package.
Here are some example uses of `spack view print`. A simple line-oriented report of information can be produced:
.. code-block:: sh
$ spack view print '$name\t$version\t$hash\n' cmake@3.5.2
ncurses 6.0 bvbu4ixbnvtodpik4qzljlx3ukpyfrcz
zlib 1.2.8 ckki7zlryxrsetfqkgoxxahlhqqjni7n
openssl 1.0.2g 6zbar63sciso253nptxyrnhupymo7oyi
cmake 3.5.2 wprvmoczkpw4tiy5ybuk5zr7saus2d7g
There are better ways to do this but a slow-and-dirty shell init procedure can be formed:
.. code-block:: sh
$ spack view print 'export PATH="${prefix}/bin:$$PATH"\n' m4
export PATH="/spack/opt/spack/linux-x86_64/gcc-5.2.1/libsigsegv-2.10-h6hsv76hffcjoe3nsaihzxemniwiedu2/bin:$PATH"
export PATH="/spack/opt/spack/linux-x86_64/gcc-5.2.1/m4-1.4.17-a4ikhddnk2zonr66mbwaqb226uhigcrp/bin:$PATH"
$ eval $(spack view print 'export PATH="${prefix}/bin:$$PATH"\n' m4)
Or, maybe you have some external application that can chew on Spack data in which case you can dump it to some easily parsed markup syntax such as YAML:
.. code-block:: sh
$ spack view print '${name}:\n - version: ${version}\n - url : ${url}\n - spec: ${spec}\n - prefix: ${prefix}\n - root : ${root}\n - stage : ${stage}\n - log: ${build_log}\n' m4
Which might produce something like:
.. code-block:: yaml
libsigsegv:
- version: 2.10
- url : ftp://ftp.gnu.org/gnu/libsigsegv/libsigsegv-2.10.tar.gz
- spec: libsigsegv@2.10%gcc@5.2.1=linux-x86_64-h6hsv76
- prefix: /spack/opt/spack/linux-x86_64/gcc-5.2.1/libsigsegv-2.10-h6hsv76hffcjoe3nsaihzxemniwiedu2
- root : m4@1.4.17%gcc@5.2.1+sigsegv=linux-x86_64^libsigsegv@2.10%gcc@5.2.1=linux-x86_64
- stage : /spack/var/spack/stage/libsigsegv-2.10-h6hsv76hffcjoe3nsaihzxemniwiedu2
- log: /spack/opt/spack/linux-x86_64/gcc-5.2.1/libsigsegv-2.10-h6hsv76hffcjoe3nsaihzxemniwiedu2/.spack/build.out
m4:
- version: 1.4.17
- url : ftp://ftp.gnu.org/gnu/m4/m4-1.4.17.tar.gz
- spec: m4@1.4.17%gcc@5.2.1+sigsegv=linux-x86_64-a4ikhdd
- prefix: /spack/opt/spack/linux-x86_64/gcc-5.2.1/m4-1.4.17-a4ikhddnk2zonr66mbwaqb226uhigcrp
- root : m4@1.4.17%gcc@5.2.1+sigsegv=linux-x86_64^libsigsegv@2.10%gcc@5.2.1=linux-x86_64
- stage : /spack/var/spack/stage/m4-1.4.17-a4ikhddnk2zonr66mbwaqb226uhigcrp
- log: /spack/opt/spack/linux-x86_64/gcc-5.2.1/m4-1.4.17-a4ikhddnk2zonr66mbwaqb226uhigcrp/.spack/build.out
Or, maybe you want to do something with information about package dependencies by generating some ready-to-import Python code holding the tree:
.. code-block:: sh
$ spack view print '$name = dict(name = "$name", parents = [$dependencies], children = [$dependents])\n' cmake@3.5.2
Producing this Python code
.. code-block:: python
ncurses = dict(name = "ncurses", parents = []])
zlib = dict(name = "zlib", parents = []])
openssl = dict(name = "openssl", parents = [zlib]])
cmake = dict(name = "cmake", parents = [ncurses,openssl]])
Compiler configuration

72
lib/spack/spack/cmd/view.py
View file

@ -24,9 +24,8 @@
##############################################################################
'''Produce a "view" of a Spack DAG.
A "view" is the product of applying a function on a set of package specs.
This set consists of:
A "view" is file hierarchy representing the union of a number of
Spack-installed package file hierarchies. The union is formed from:
- specs resolved from the package names given by the user (the seeds)
@ -35,7 +34,7 @@
- less any specs with names matching the regular expressions given by
`--exclude`
The `view` command provides a number of functions (the "actions"):
The `view` can be built and tore down via a number of methods (the "actions"):
- symlink :: a file system view which is a directory hierarchy that is
the union of the hierarchies of the installed packages in the DAG
@ -46,8 +45,6 @@
- statlink :: a view producing a status report of a symlink or
hardlink view.
- format :: a view printing one string per spec following a given format.
The file system view concept is imspired by Nix, implemented by
brett.viren@gmail.com ca 2016.
@ -68,7 +65,6 @@
import os
import re
import sys
import spack
import spack.cmd
import llnl.util.tty as tty
@ -117,13 +113,6 @@ def setup_parser(sp):
help="Path to file system view directory.")
act.add_argument('specs', **specs_opts)
# The formatted print action.
act = ssp.add_parser('print',
help="Print a string to stdout based on given format")
act.add_argument('format', nargs=1,
help="Format describing per-package printout.")
act.add_argument('specs', **specs_opts)
return
@ -190,42 +179,6 @@ def flatten(seeds, descend=True):
return flat
def spec2dict(spec):
'Convert info in a spec into a simple dictionary.'
# Expclitly convert instead of just returning spec.__dict__ as
# some things need processing or are properties.
#
pkg = spec.package
inst_deps = ','.join([s.name for s in pkg.installed_dependents]),
ret = dict(name=spec.name,
spec=spec.short_spec,
colorspec=spec.cshort_spec, # color
root=spec.root,
prefix=spec.prefix,
version=spec.version,
variants=spec.variants,
namespace=spec.namespace,
compiler=spec.compiler,
architecture=spec.architecture,
dependencies=','.join(spec.dependencies.keys()),
dependents=','.join(spec.dependents.keys()),
external=spec.external or "False",
hash=spec.dag_hash(),
# package related:
url=pkg.url,
stage=pkg.stage.path,
installed=pkg.installed,
installed_dependents=inst_deps,
build_log=pkg.build_log_path,
rpath=':'.join(pkg.rpath),
# ...
)
return ret
def check_one(spec, path, verbose=False):
'Check status of view in path against spec'
dotspack = os.path.join(path, '.spack', spec.name)
@ -326,25 +279,6 @@ def visitor_statlink(specs, args):
visitor_check = visitor_statlink
def visitor_print(specs, args):
'Print a string for each spec using args.format.'
fmt = args.format[0]
from string import Template
t = Template(fmt)
for spec in specs:
kwds = spec2dict(spec)
try:
text = t.substitute(kwds)
except KeyError:
tty.error("Format error, use keywords: %s" %
(', '.join(kwds.keys()), ))
raise
# argparser escapes these
text = text.replace(r'\n', '\n').replace(r'\t', '\t')
sys.stdout.write(text)
def view(parser, args):
'Produce a view of a set of packages.'